BTC USD 83,891.9 Gold USD 4,163.14
Time now: Jun 1, 12:00 AM

:: Linux :: Siapa handal Makefile & GCC ?

Megat Sri Rama

Megat Sri Rama

CG Top Poster Club
gem
Messages
20,266
Joined
Aug 28, 2007
Messages
20,266
Reaction score
507
Points
161
Masalah Linux pun ya, Android pun ya...

Aku tgh nak recompile kernel Android untuk Xperia X8, guna source code dari Sony Ericsson.

Environment : Ubuntu 10.10 over VirtualBox over Windows 7

Aku buat dua folder :

~/android/source/ : untuk source code dari SonyEricsson
~/myandroid/ : untuk source code dari Git repository dari Google (repo init -u git://android.git.kernel.org/platform/manifest.git), ia tak mengandungi source kernel, cuma cabang Platform sahaja, sebab yang penting adalah fail yang ada dalam folder /platform/toolchain seperti compiler.

working directory sewaktu compile adalah di ~/android/source/kernel/



Setting :

export ARCH=arm
export CROSS_COMPILE=arm-eabi-
export PATH=$PATH:~/myandroid/prebuilt/linux-x86/toolchain/arm-eabi-4.4.0/bin


.config aku ambil dari Android 1.6 X10
untuk telefon versi selepas dari 1.6 memang tiada fail /proc/config.gz dalam telefon.


pertama kali, aku compile tanpa ubah apa-apa. Semua OK.

kali kedua, aku make clean, aku ubah pada .config :
1. feature untuk swap support pada kernel
2. tukar processor kepada MSM_72X7
3. ubah board kepada "Shakira" (codename untuk X8)

kemudian aku dapat error ni :

Code: 
arch/arm/mach-msm/built-in.o: In function `shakira_gpio_event_matrix_func':
/home/android/android/sources/kernel/arch/arm/mach-msm/board-shakira-keypad.c:90: undefined reference to `semc_gpio_event_matrix_func'

android tu dua kali sebab username linux aku pun android.

aku dah google, tiada satu pun kes ni disebut.

aku dah periksa semua fail (ada 5) yang menyebut kata kunci "semc_gpio_event_matrix_func" semuanya memanggil header file dengan baik... malah aku tukar dari #include <header.file> jadi #include "header.file"

biasanya masalah compile "undefined reference to" dikatakan berkaitan soal linking sama ada dynamic atau static.

bagaimana nak ubah benda tu dalam "makefile" atau "make file" (android_kernel.mk)? bagaimana pula nak link secara statik/dinamik untuk fail ini sahaja...






dalam semua fail di bawah ~/android/sources tu, cuma 5 yang ada sebut "semc_gpio_event_matrix_func"

  1. /home/android/android/sources/kernel/arch/arm/mach-msm/board-mimmi-keypad.c
  2. /home/android/android/sources/kernel/arch/arm/mach-msm/board-robyn-keypad.c
  3. /home/android/android/sources/kernel/arch/arm/mach-msm/board-shakira-keypad.c
  4. /home/android/android/sources/kernel/drivers/misc/semc/gpio_matrix/semc_gpio_matrix.c
  5. /home/android/android/sources/kernel/include/linux/semc/gpio_event.h


Fail berwarna merah tidak digunakan, ia untuk handphone SE model lain.

Berikut adalah fail-fail yang terlibat :
 
Last edited:
Fail 1 - /home/android/android/sources/kernel/arch/arm/mach-msm/board-shakira-keypad.c

Code: 
/*
 * Copyright (C) 2009 SEMC
 * Copyright (c) 2008-2009, Code Aurora Forum. All rights reserved.
 * Author: Daniel Nygren <[email protected]>
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 */

#include <linux/platform_device.h>
#include <linux/gpio_event.h>
#include <linux/semc/gpio_event.h>
#include "board-delta-keypad.h"
#include <mach/semc_rpc_server_handset.h>
#include <asm/mach-types.h>
#include <linux/gpio.h>

#define DBG(X)

static unsigned int keypad_row_gpios[] = { 31 };
static unsigned int keypad_col_gpios[] = { 36, 37, 38, 39, 40, 41 };
static atomic_t driver_up_and_running = ATOMIC_INIT(0);
static struct gpio_event_input_devs *kbd_input_dev;

#define KEYMAP_INDEX(row, col) ((row)*ARRAY_SIZE(keypad_col_gpios) + (col))

static const unsigned short keypad_keymap_shakira[ARRAY_SIZE(keypad_col_gpios) *
					  ARRAY_SIZE(keypad_row_gpios)] = {
	[KEYMAP_INDEX(0, 0)] = KEY_BACK,		/* Left */
	[KEYMAP_INDEX(0, 1)] = KEY_HOME,		/* Middle */
	[KEYMAP_INDEX(0, 2)] = KEY_MENU,		/* Right */
	[KEYMAP_INDEX(0, 3)] = KEY_VOLUMEUP,
	[KEYMAP_INDEX(0, 4)] = KEY_VOLUMEDOWN,
	[KEYMAP_INDEX(0, 5)] = KEY_CAMERA,		/* Camera Snap */
};

static const unsigned short wakeup_inputs[ARRAY_SIZE(keypad_col_gpios)] = {
	0,
	1,  /* KEY_HOME */
	0,
	1,  /* KEY_VOLUMEUP */
	1,  /* KEY_VOLUMEDOWN  */
	0,
};

static unsigned short w_enabled_inputs[ARRAY_SIZE(keypad_col_gpios)];

static void configure_wakeup_inputs(const unsigned short *wi)
{
	int i;
	for (i = 0; i < ARRAY_SIZE(keypad_col_gpios); i++) {
		if (w_enabled_inputs[i] == wi[i])
			continue;
		if (set_irq_wake(gpio_to_irq(keypad_col_gpios[i]), wi[i])) {
			printk(KERN_ERR "%s: set_irq_wake failed for GPIO %d\n",
					__func__, keypad_col_gpios[i]);
		} else {
			DBG(printk(KERN_DEBUG
				   "%s: set_irq_wake=%d  for GPIO %d\n",
				   __func__, wi[i],  keypad_col_gpios[i]);)
			w_enabled_inputs[i] = wi[i];
		}
	}
}

static int shakira_gpio_event_matrix_func(
			struct gpio_event_input_devs *input_devs,
			struct gpio_event_info *info,
			void **data, int func)
{
	if (func == GPIO_EVENT_FUNC_INIT) {
		struct input_dev *input_dev = input_devs->dev[0];

		kbd_input_dev = input_devs;
		input_set_capability(input_dev, EV_KEY, KEY_POWER);
		input_set_capability(input_dev, EV_KEY, KEY_END);
		atomic_set(&driver_up_and_running, 1);
	}
	if (func == GPIO_EVENT_FUNC_UNINIT)
		atomic_set(&driver_up_and_running, 0);

	configure_wakeup_inputs(wakeup_inputs);
	return semc_gpio_event_matrix_func(input_devs, info, data, func);
}


/* Shakira keypad platform device information */
static struct gpio_event_matrix_info shakira_keypad_matrix_info = {
	.info.func	= shakira_gpio_event_matrix_func,
	.keymap		= keypad_keymap_shakira,
	.output_gpios	= keypad_row_gpios,
	.input_gpios	= keypad_col_gpios,
	.noutputs	= ARRAY_SIZE(keypad_row_gpios),
	.ninputs	= ARRAY_SIZE(keypad_col_gpios),
	.settle_time.tv.nsec = 0,
	.poll_time.tv.nsec = 20 * NSEC_PER_MSEC,
	.flags		= GPIOKPF_LEVEL_TRIGGERED_IRQ |
			  GPIOKPF_PRINT_UNMAPPED_KEYS
};

static struct gpio_event_info *shakira_keypad_info[] = {
	&shakira_keypad_matrix_info.info
};

static struct gpio_event_platform_data shakira_keypad_data = {
	.name		= "shakira_keypad",
	.info		= shakira_keypad_info,
	.info_count	= ARRAY_SIZE(shakira_keypad_info)
};

struct platform_device keypad_device_shakira = {
	.name	= GPIO_EVENT_DEV_NAME,
	.id	= -1,
	.dev	= {
		.platform_data	= &shakira_keypad_data,
	},
};

struct platform_device *get_keypad_device_delta(void)
{
	return &keypad_device_shakira;
}

void keypad_rpc_key_callback(uint32_t key, uint32_t event)
{
	if (!atomic_read(&driver_up_and_running)) {
		DBG(printk(KERN_DEBUG "%s: Power key ignored, driver"
				" not ready\n", __func__));
		return;
	}

	switch (key) {
	case HS_PWR_K:
		key = KEY_POWER;
		break;
	case HS_END_K:
		key = KEY_END;
		break;
	default:
		return;
	}
	DBG(printk(KERN_DEBUG "%s: reporting key (code %d, value %d)\n",
			__func__, key, event != HS_REL_K);)
	input_report_key(kbd_input_dev->dev[0], key, event != HS_REL_K);
}
 
Last edited:
Fail 2 - /home/android/android/sources/kernel/drivers/misc/semc/gpio_matrix/semc_gpio_matrix.c

Code: 
/* drivers/misc/semc/gpio_matrix/gpio_matrix.c
 *
 * Based upon kernel/drivers/input/misc/gpio_matrix.c
 */

#include <linux/kernel.h>
#include <linux/gpio.h>
#include "linux/gpio_event.h"
#include <linux/hrtimer.h>
#include <linux/interrupt.h>
#include <linux/wakelock.h>

struct gpio_kp {
	struct gpio_event_input_devs *input_devs;
	struct gpio_event_matrix_info *keypad_info;
	struct hrtimer timer;
	struct wake_lock wake_lock;
	int current_output;
	unsigned int use_irq:1;
	unsigned int key_state_changed:1;
	unsigned int last_key_state_changed:1;
	unsigned int some_keys_pressed:2;
	unsigned long keys_pressed[0];
};

static void clear_phantom_key(struct gpio_kp *kp, int out, int in)
{
	struct gpio_event_matrix_info *mi = kp->keypad_info;
	int key_index = out * mi->ninputs + in;
	unsigned short keyentry = mi->keymap[key_index];
	unsigned short keycode = keyentry & MATRIX_KEY_MASK;
	unsigned short dev = keyentry >> MATRIX_CODE_BITS;

	if (!test_bit(keycode, kp->input_devs->dev[dev]->key)) {
		if (mi->flags & GPIOKPF_PRINT_PHANTOM_KEYS)
			pr_info("gpiomatrix: phantom key %x, %d-%d (%d-%d) "
				"cleared\n", keycode, out, in,
				mi->output_gpios[out], mi->input_gpios[in]);
		__clear_bit(key_index, kp->keys_pressed);
	} else {
		if (mi->flags & GPIOKPF_PRINT_PHANTOM_KEYS)
			pr_info("gpiomatrix: phantom key %x, %d-%d (%d-%d) "
				"not cleared\n", keycode, out, in,
				mi->output_gpios[out], mi->input_gpios[in]);
	}
}

static int restore_keys_for_input(struct gpio_kp *kp, int out, int in)
{
	int rv = 0;
	int key_index;

	key_index = out * kp->keypad_info->ninputs + in;
	while (out < kp->keypad_info->noutputs) {
		if (test_bit(key_index, kp->keys_pressed)) {
			rv = 1;
			clear_phantom_key(kp, out, in);
		}
		key_index += kp->keypad_info->ninputs;
		out++;
	}
	return rv;
}

static void remove_phantom_keys(struct gpio_kp *kp)
{
	int out, in, inp;
	int key_index;

	if (kp->some_keys_pressed < 3)
		return;

	for (out = 0; out < kp->keypad_info->noutputs; out++) {
		inp = -1;
		key_index = out * kp->keypad_info->ninputs;
		for (in = 0; in < kp->keypad_info->ninputs; in++, key_index++) {
			if (test_bit(key_index, kp->keys_pressed)) {
				if (inp == -1) {
					inp = in;
					continue;
				}
				if (inp >= 0) {
					if (!restore_keys_for_input(kp, out + 1,
									inp))
						break;
					clear_phantom_key(kp, out, inp);
					inp = -2;
				}
				restore_keys_for_input(kp, out, in);
			}
		}
	}
}

static void report_key(struct gpio_kp *kp, int key_index, int out, int in)
{
	struct gpio_event_matrix_info *mi = kp->keypad_info;
	int pressed = test_bit(key_index, kp->keys_pressed);
	unsigned short keyentry = mi->keymap[key_index];
	unsigned short keycode = keyentry & MATRIX_KEY_MASK;
	unsigned short dev = keyentry >> MATRIX_CODE_BITS;

	if (pressed != test_bit(keycode, kp->input_devs->dev[dev]->key)) {
		if (keycode == KEY_RESERVED) {
			if (mi->flags & GPIOKPF_PRINT_UNMAPPED_KEYS)
				pr_info("gpiomatrix: unmapped key, %d-%d "
					"(%d-%d) changed to %d\n",
					out, in, mi->output_gpios[out],
					mi->input_gpios[in], pressed);
		} else {
			if (mi->flags & GPIOKPF_PRINT_MAPPED_KEYS)
				pr_info("gpiomatrix: key %x, %d-%d (%d-%d) "
					"changed to %d\n", keycode,
					out, in, mi->output_gpios[out],
					mi->input_gpios[in], pressed);
			if (mi->info.event)
				mi->info.event(kp->input_devs, &mi->info, NULL, dev, 0,
							keycode, pressed);
			else
				input_report_key(kp->input_devs->dev[dev], keycode, pressed);
		}
	}
}

static enum hrtimer_restart gpio_keypad_timer_func(struct hrtimer *timer)
{
	int out, in;
	int key_index;
	int gpio;
	struct gpio_kp *kp = container_of(timer, struct gpio_kp, timer);
	struct gpio_event_matrix_info *mi = kp->keypad_info;
	unsigned gpio_keypad_flags = mi->flags;
	unsigned polarity = !!(gpio_keypad_flags & GPIOKPF_ACTIVE_HIGH);

	out = kp->current_output;
	if (out == mi->noutputs) {
		out = 0;
		kp->last_key_state_changed = kp->key_state_changed;
		kp->key_state_changed = 0;
		kp->some_keys_pressed = 0;
	} else {
		key_index = out * mi->ninputs;
		for (in = 0; in < mi->ninputs; in++, key_index++) {
			gpio = mi->input_gpios[in];
			if (gpio_get_value(gpio) ^ !polarity) {
				if (kp->some_keys_pressed < 3)
					kp->some_keys_pressed++;
				kp->key_state_changed |= !__test_and_set_bit(
						key_index, kp->keys_pressed);
			} else
				kp->key_state_changed |= __test_and_clear_bit(
						key_index, kp->keys_pressed);
		}
		gpio = mi->output_gpios[out];
		if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
			gpio_set_value(gpio, !polarity);
		else
			gpio_direction_input(gpio);
		out++;
	}
	kp->current_output = out;
	if (out < mi->noutputs) {
		gpio = mi->output_gpios[out];
		if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
			gpio_set_value(gpio, polarity);
		else
			gpio_direction_output(gpio, polarity);
		hrtimer_start(timer, mi->settle_time, HRTIMER_MODE_REL);
		return HRTIMER_NORESTART;
	}
	if (gpio_keypad_flags & GPIOKPF_DEBOUNCE) {
		if (kp->key_state_changed) {
			hrtimer_start(&kp->timer, mi->debounce_delay,
				      HRTIMER_MODE_REL);
			return HRTIMER_NORESTART;
		}
		kp->key_state_changed = kp->last_key_state_changed;
	}
	if (kp->key_state_changed) {
		if (gpio_keypad_flags & GPIOKPF_REMOVE_SOME_PHANTOM_KEYS)
			remove_phantom_keys(kp);
		key_index = 0;
		for (out = 0; out < mi->noutputs; out++)
			for (in = 0; in < mi->ninputs; in++, key_index++)
				report_key(kp, key_index, out, in);
	}
	if (!kp->use_irq || kp->some_keys_pressed) {
		hrtimer_start(timer, mi->poll_time, HRTIMER_MODE_REL);
		return HRTIMER_NORESTART;
	}

	/* No keys are pressed, reenable interrupt */
	for (out = 0; out < mi->noutputs; out++) {
		if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
			gpio_set_value(mi->output_gpios[out], polarity);
		else
			gpio_direction_output(mi->output_gpios[out], polarity);
	}
	for (in = 0; in < mi->ninputs; in++)
		enable_irq(gpio_to_irq(mi->input_gpios[in]));
	wake_unlock(&kp->wake_lock);
	return HRTIMER_NORESTART;
}

static irqreturn_t gpio_keypad_irq_handler(int irq_in, void *dev_id)
{
	int i;
	struct gpio_kp *kp = dev_id;
	struct gpio_event_matrix_info *mi = kp->keypad_info;
	unsigned gpio_keypad_flags = mi->flags;

	if (!kp->use_irq) /* ignore interrupt while registering the handler */
		return IRQ_HANDLED;

	for (i = 0; i < mi->ninputs; i++)
		disable_irq(gpio_to_irq(mi->input_gpios[i]));
	for (i = 0; i < mi->noutputs; i++) {
		if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
			gpio_set_value(mi->output_gpios[i],
				!(gpio_keypad_flags & GPIOKPF_ACTIVE_HIGH));
		else
			gpio_direction_input(mi->output_gpios[i]);
	}
	wake_lock(&kp->wake_lock);
	hrtimer_start(&kp->timer, ktime_set(0, 10000), HRTIMER_MODE_REL);
	return IRQ_HANDLED;
}

static int gpio_keypad_request_irqs(struct gpio_kp *kp)
{
	int i;
	int err;
	unsigned int irq;
	unsigned long request_flags;
	struct gpio_event_matrix_info *mi = kp->keypad_info;

	switch (mi->flags & (GPIOKPF_ACTIVE_HIGH|GPIOKPF_LEVEL_TRIGGERED_IRQ)) {
	default:
		request_flags = IRQF_TRIGGER_FALLING;
		break;
	case GPIOKPF_ACTIVE_HIGH:
		request_flags = IRQF_TRIGGER_RISING;
		break;
	case GPIOKPF_LEVEL_TRIGGERED_IRQ:
		request_flags = IRQF_TRIGGER_LOW;
		break;
	case GPIOKPF_LEVEL_TRIGGERED_IRQ | GPIOKPF_ACTIVE_HIGH:
		request_flags = IRQF_TRIGGER_HIGH;
		break;
	}

saya potong dua fail ni, panjang sangat.
 
Last edited:
(sambung dari yang atas)
/home/android/android/sources/kernel/drivers/misc/semc/gpio_matrix/semc_gpio_matrix.c

Code: 
	for (i = 0; i < mi->ninputs; i++) {
		err = irq = gpio_to_irq(mi->input_gpios[i]);
		if (err < 0)
			goto err_gpio_get_irq_num_failed;
		err = request_irq(irq, gpio_keypad_irq_handler, request_flags,
				  "gpio_kp", kp);
		if (err) {
			pr_err("gpiomatrix: request_irq failed for input %d, "
				"irq %d\n", mi->input_gpios[i], irq);
			goto err_request_irq_failed;
		}
		disable_irq(irq);
	}
	return 0;

	for (i = mi->noutputs - 1; i >= 0; i--) {
		free_irq(gpio_to_irq(mi->input_gpios[i]), kp);
err_request_irq_failed:
err_gpio_get_irq_num_failed:
		;
	}
	return err;
}

int semc_gpio_event_matrix_func(struct gpio_event_input_devs *input_devs,
	struct gpio_event_info *info, void **data, int func)
{
	int i;
	int err;
	int key_count;
	struct gpio_kp *kp;
	struct gpio_event_matrix_info *mi;

	mi = container_of(info, struct gpio_event_matrix_info, info);
	if (func == GPIO_EVENT_FUNC_SUSPEND || func == GPIO_EVENT_FUNC_RESUME) {
		/* TODO: disable scanning */
		return 0;
	}

	if (func == GPIO_EVENT_FUNC_INIT) {
		if (mi->keymap == NULL ||
		   mi->input_gpios == NULL ||
		   mi->output_gpios == NULL) {
			err = -ENODEV;
			pr_err("gpiomatrix: Incomplete pdata\n");
			goto err_invalid_platform_data;
		}
		key_count = mi->ninputs * mi->noutputs;

		*data = kp = kzalloc(sizeof(*kp) + sizeof(kp->keys_pressed[0]) *
				     BITS_TO_LONGS(key_count), GFP_KERNEL);
		if (kp == NULL) {
			err = -ENOMEM;
			pr_err("gpiomatrix: Failed to allocate private data\n");
			goto err_kp_alloc_failed;
		}
		kp->input_devs = input_devs;
		kp->keypad_info = mi;
		for (i = 0; i < key_count; i++) {
			unsigned short keyentry = mi->keymap[i];
			unsigned short keycode = keyentry & MATRIX_KEY_MASK;
			unsigned short dev = keyentry >> MATRIX_CODE_BITS;
			if (dev >= input_devs->count) {
				pr_err("gpiomatrix: bad device index %d >= "
					"%d for key code %d\n",
					dev, input_devs->count, keycode);
				err = -EINVAL;
				goto err_bad_keymap;
			}
			if (keycode && keycode <= KEY_MAX)
				input_set_capability(input_devs->dev[dev],
							EV_KEY, keycode);
		}

		for (i = 0; i < mi->noutputs; i++) {
			if (gpio_cansleep(mi->output_gpios[i])) {
				pr_err("gpiomatrix: unsupported output gpio %d,"
					" can sleep\n", mi->output_gpios[i]);
				err = -EINVAL;
				goto err_request_output_gpio_failed;
			}
			err = gpio_request(mi->output_gpios[i], "gpio_kp_out");
			if (err) {
				pr_err("gpiomatrix: gpio_request failed for "
					"output %d\n", mi->output_gpios[i]);
				goto err_request_output_gpio_failed;
			}
			if (mi->flags & GPIOKPF_DRIVE_INACTIVE)
				err = gpio_direction_output(mi->output_gpios[i],
					!(mi->flags & GPIOKPF_ACTIVE_HIGH));
			else
				err = gpio_direction_input(mi->output_gpios[i]);
			if (err) {
				pr_err("gpiomatrix: gpio_configure failed for "
					"output %d\n", mi->output_gpios[i]);
				goto err_output_gpio_configure_failed;
			}
		}
		for (i = 0; i < mi->ninputs; i++) {
			err = gpio_request(mi->input_gpios[i], "gpio_kp_in");
			if (err) {
				pr_err("gpiomatrix: gpio_request failed for "
					"input %d\n", mi->input_gpios[i]);
				goto err_request_input_gpio_failed;
			}
			err = gpio_direction_input(mi->input_gpios[i]);
			if (err) {
				pr_err("gpiomatrix: gpio_direction_input failed"
					" for input %d\n", mi->input_gpios[i]);
				goto err_gpio_direction_input_failed;
			}
		}
		kp->current_output = mi->noutputs;
		kp->key_state_changed = 1;

		hrtimer_init(&kp->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
		kp->timer.function = gpio_keypad_timer_func;
		wake_lock_init(&kp->wake_lock, WAKE_LOCK_SUSPEND, "gpio_kp");
		err = gpio_keypad_request_irqs(kp);
		kp->use_irq = err == 0;

		pr_info("SEMC GPIO Matrix Keypad Driver: Start keypad matrix for "
			"%s%s in %s mode\n", input_devs->dev[0]->name,
			(input_devs->count > 1) ? "..." : "",
			kp->use_irq ? "interrupt" : "polling");

		if (kp->use_irq)
			wake_lock(&kp->wake_lock);
		hrtimer_start(&kp->timer, ktime_set(0, 10000),
				 HRTIMER_MODE_REL);

		return 0;
	}

	err = 0;
	kp = *data;

	if (kp->use_irq)
		for (i = mi->noutputs - 1; i >= 0; i--)
			free_irq(gpio_to_irq(mi->input_gpios[i]), kp);

	hrtimer_cancel(&kp->timer);
	wake_lock_destroy(&kp->wake_lock);
	for (i = mi->noutputs - 1; i >= 0; i--) {
err_gpio_direction_input_failed:
		gpio_free(mi->input_gpios[i]);
err_request_input_gpio_failed:
		;
	}
	for (i = mi->noutputs - 1; i >= 0; i--) {
err_output_gpio_configure_failed:
		gpio_free(mi->output_gpios[i]);
err_request_output_gpio_failed:
		;
	}
err_bad_keymap:
	kfree(kp);
err_kp_alloc_failed:
err_invalid_platform_data:
	return err;
}










Fail 3 - /linux/semc/gpio_event.h

Code: 
#ifndef _SEMC_GPIO_EVENT_H_
#define _SEMC_GPIO_EVENT_H_

#include <linux/gpio_event.h>
#include <linux/input.h>

int semc_gpio_event_matrix_func(struct gpio_event_input_devs *input_dev, 
struct gpio_event_info *info, void **data, int func);

int semc_gpio_event_input_func(struct gpio_event_input_devs *input_dev,	
struct gpio_event_info *info, void **data, int func);

#endif /*_SEMC_GPIO_EVENT_H_*/

apa yang tak kena, ya?








Bagi yang biasa compile driver dan kernel Linux (dan apa-apa software yang perlu customization), rasanya dah masak dengan benda ni.
Jadi minta bantuan dan pendapat.



terima kasih.
 
Last edited:
anybody who feels like helping, don't bother downloading the code..

original SE source = 145MB
android platform repo = 2.5GB
android kernel repo = 1.5GB

if you need to see any file, or the file structure, just ask.

but if you insist, here's the url :

android : android.git.kernel.org
SE : http://developer.sonyericsson.com/cws/devworld/search-downloads/opensource?cc=gb&lc=en ( x10_x10mini_X10minipro_x8_eclair_2.1.A.0.435.tar.gz)
 
SIAPAKAH GERANGANYE YANG DAPAT MEMBANTU TT NI...bump skit
 
rebellion said:
SIAPAKAH GERANGANYE YANG DAPAT MEMBANTU TT NI...bump skit
Click to expand...

Terima kasih...

Rasanya calonnya tidak perlu handal sangat Linux, cukup kalau biasa sangat main dengan makefile dan compile itu ini.

Kebanyakan aplikasi yang sedikit teknikal dalam Linux (contoh : video/audio encoder/decoder), di download source code dan dicompile sendiri. Biasanya perlu diubah setting compilation-nya.

Tak perlu tahu pasal Android pun, rasanya la.





Aku rasa aku selalu tengok orang cerita pasal Linux dalam CG ni dulu.
 
Aku dah jumpa... Sony Ericsson sengaja kasi fail yang tak boleh nak dicompile tanpa diperbetulkan dulu, kaitan antara satu fail dengan fail lain yang berkenaan banyak yang hilang (dalam #include dan kat dalam makefile), banyak fail penting (drivers, yang penting macam simcard dectection tak dicompile jadi object)... Mulut cakap Open Source, tapi tak ikhlas.

FALAT.



Siapa terror makefile kat sini?

aku nak teruskan soalan, tapi nak tanya dulu...

ini dah tak ada kena mengena dengan Android lagi dah... it's all about compiling your codes in Linux environment.

Tolong... Aku bukan nak korang buatkan kerja, just point me to the right direction.
 

Similar threads

Xploit Machine
PC News Perisian Muat Turun Percuma Sebar 'Malware' Sasar Pengguna Linux
Replies
0
Views
214
Xploit Machine
Xploit Machine
Xploit Machine
PC Tips & Tricks Belajar Menaip Menggunakan Terminal Di Linux
Replies
1
Views
438
dell
dell
Xploit Machine
eBooks Coding for Linux - Volume 38 - 2019
Replies
1
Views
672
Hendadda
Hendadda
Xploit Machine
eBooks The Linux Command Line - A Complete Introduction
Replies
1
Views
787
Morlugamand
Morlugamand
puteribobo
picture tak upload siapa bole tlg selesaikan masalah ini tq
2
Replies
12
Views
2K
dinosuros
D

Welcome to the one of the largest online investment & business portal in South-East Asia. You currently view about 1/3 of our forum sections. In order to enter all sections without restrictions, you may have to register to get full view and more functions available.

Forum statistics

Threads
793,990
Messages
26,715,069
Members
175,585
Latest member
fundlineuk

What's new

Copyright ©2005 - 2026, CariGold.com

Disclaimer: All posts published herein are merely based on individual views, and they do not expressly or by implications represent those of CariGold.com or its owner. It is hereby made clear that CariGold.com does not endorse, support, adopt or vouch any views, programs and/or business opportunities posted herein. CariGold.com also does not give and/or offer any investment advice to any members and/or readers. All members and readers are advised to independently consult their own consultants, lawyers and/or families before making any investment and/or business decisions. This forum is merely a place for general discussions. It is hereby agreed by all members and/or readers that CariGold. com is in no way responsible and/or liable for any damages and/or losses suffered by anyone of you.

Back
Top
Log in Register