static int gpio_event_probe(struct platform_device *pdev)
{
int err;
struct gpio_event *ip;
struct gpio_event_platform_data *event_info;
int dev_count = 1;
int i;
int registered = 0;
event_info = pdev->dev.platform_data;
if (event_info == NULL) {
pr_err("gpio_event_probe: No pdata\n");
return -ENODEV;
}
if ((!event_info->name && !event_info->names[0]) ||
!event_info->info || !event_info->info_count) {
pr_err("gpio_event_probe: Incomplete pdata\n");
return -ENODEV;
}
if (!event_info->name)
while (event_info->names[dev_count])
dev_count++;
ip = kzalloc(sizeof(*ip) +
sizeof(ip->state[0]) * event_info->info_count +
sizeof(*ip->input_devs) +
sizeof(ip->input_devs->dev[0]) * dev_count, GFP_KERNEL);
if (ip == NULL) {
err = -ENOMEM;
pr_err("gpio_event_probe: Failed to allocate private data\n");
goto err_kp_alloc_failed;
}
ip->input_devs = (void*)&ip->state[event_info->info_count];
platform_set_drvdata(pdev, ip);
for (i = 0; i < dev_count; i++) {
struct input_dev *input_dev = input_allocate_device();
if (input_dev == NULL) {
err = -ENOMEM;
pr_err("gpio_event_probe: "
"Failed to allocate input device\n");
goto err_input_dev_alloc_failed;
}
input_set_drvdata(input_dev, ip);
input_dev->name = event_info->name ?
event_info->name : event_info->names[i];
input_dev->event = gpio_input_event;
ip->input_devs->dev[i] = input_dev;
}
ip->input_devs->count = dev_count;
ip->info = event_info;
if (event_info->power) {
#ifdef CONFIG_HAS_EARLYSUSPEND
ip->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
ip->early_suspend.suspend = gpio_event_suspend;
ip->early_suspend.resume = gpio_event_resume;
register_early_suspend(&ip->early_suspend);
#endif
ip->info->power(ip->info, 1);
}
err = gpio_event_call_all_func(ip, GPIO_EVENT_FUNC_INIT);
if (err)
goto err_call_all_func_failed;
for (i = 0; i < dev_count; i++) {
err = input_register_device(ip->input_devs->dev[i]);
if (err) {
pr_err("gpio_event_probe: Unable to register %s "
"input device\n", ip->input_devs->dev[i]->name);
goto err_input_register_device_failed;
}
registered++;
}
#if defined(CONFIG_MACH_VASTO)
/* sys fs */
key_class = class_create(THIS_MODULE, "key");
if (IS_ERR(key_class))
pr_err("Failed to create class(key)!\n");
key_dev = device_create(key_class, NULL, 0, NULL, "key");
if (IS_ERR(key_dev))
pr_err("Failed to create device(key)!\n");
if (device_create_file(key_dev, &dev_attr_key) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_key.attr.name);
/* sys fs */
#endif
return 0;
err_input_register_device_failed:
gpio_event_call_all_func(ip, GPIO_EVENT_FUNC_UNINIT);
err_call_all_func_failed:
if (event_info->power) {
#ifdef CONFIG_HAS_EARLYSUSPEND
unregister_early_suspend(&ip->early_suspend);
#endif
ip->info->power(ip->info, 0);
}
for (i = 0; i < registered; i++)
input_unregister_device(ip->input_devs->dev[i]);
for (i = dev_count - 1; i >= registered; i--) {
input_free_device(ip->input_devs->dev[i]);
err_input_dev_alloc_failed:
;
}
kfree(ip);
err_kp_alloc_failed:
return err;
}
static int pm8058_kp_config_drv(int gpio_start, int num_gpios)
{
int rc;
struct pm8058_gpio kypd_drv = {
.direction = PM_GPIO_DIR_OUT,
.output_buffer = PM_GPIO_OUT_BUF_OPEN_DRAIN,
.output_value = 0,
.pull = PM_GPIO_PULL_NO,
.vin_sel = 2,
.out_strength = PM_GPIO_STRENGTH_LOW,
.function = PM_GPIO_FUNC_1,
.inv_int_pol = 1,
};
if (gpio_start < 0 || num_gpios < 0 || num_gpios > PM8058_GPIOS)
return -EINVAL;
while (num_gpios--) {
rc = pm8058_gpio_config(gpio_start++, &kypd_drv);
if (rc) {
pr_err("%s: FAIL pm8058_gpio_config(): rc=%d.\n",
__func__, rc);
return rc;
}
}
return 0;
}
static int pm8058_kp_config_sns(int gpio_start, int num_gpios)
{
int rc;
struct pm8058_gpio kypd_sns = {
.direction = PM_GPIO_DIR_IN,
.pull = PM_GPIO_PULL_UP_31P5,
.vin_sel = 2,
.out_strength = PM_GPIO_STRENGTH_NO,
.function = PM_GPIO_FUNC_NORMAL,
.inv_int_pol = 1,
};
if (gpio_start < 0 || num_gpios < 0 || num_gpios > PM8058_GPIOS)
return -EINVAL;
while (num_gpios--) {
rc = pm8058_gpio_config(gpio_start++, &kypd_sns);
if (rc) {
pr_err("%s: FAIL pm8058_gpio_config(): rc=%d.\n",
__func__, rc);
return rc;
}
}
return 0;
}
static int __devinit pmic8058_kp_probe(struct platform_device *pdev)
{
struct pmic8058_keypad_data *pdata = pdev->dev.platform_data;
struct pmic8058_kp *kp;
int rc, i;
unsigned short *keycodes;
u8 ctrl_val;
struct pm8058_chip *pm_chip;
pm_chip = platform_get_drvdata(pdev);
if (pm_chip == NULL) {
dev_err(&pdev->dev, "no parent data passed in\n");
return -EFAULT;
}
if (!pdata || !pdata->num_cols || !pdata->num_rows ||
pdata->num_cols > MATRIX_MAX_COLS ||
pdata->num_rows > MATRIX_MAX_ROWS ||
pdata->num_cols < MATRIX_MIN_COLS ||
pdata->num_rows < MATRIX_MIN_ROWS ||
!pdata->keymap) {
dev_err(&pdev->dev, "invalid platform data\n");
return -EINVAL;
}
if (pdata->rows_gpio_start < 0 || pdata->cols_gpio_start < 0) {
dev_err(&pdev->dev, "invalid gpio_start platform data\n");
return -EINVAL;
}
if (!pdata->scan_delay_ms || pdata->scan_delay_ms > MAX_SCAN_DELAY
|| pdata->scan_delay_ms < MIN_SCAN_DELAY ||
!is_power_of_2(pdata->scan_delay_ms)) {
dev_err(&pdev->dev, "invalid keypad scan time supplied\n");
return -EINVAL;
}
if (!pdata->row_hold_ns || pdata->row_hold_ns > MAX_ROW_HOLD_DELAY
|| pdata->row_hold_ns < MIN_ROW_HOLD_DELAY ||
((pdata->row_hold_ns % MIN_ROW_HOLD_DELAY) != 0)) {
dev_err(&pdev->dev, "invalid keypad row hold time supplied\n");
return -EINVAL;
}
if (pm8058_rev(pm_chip) == PM_8058_REV_1p0) {
if (!pdata->debounce_ms
|| !is_power_of_2(pdata->debounce_ms[0])
|| pdata->debounce_ms[0] > MAX_DEBOUNCE_A0_TIME
|| pdata->debounce_ms[0] < MIN_DEBOUNCE_A0_TIME) {
dev_err(&pdev->dev, "invalid debounce time supplied\n");
return -EINVAL;
}
} else {
if (!pdata->debounce_ms
|| ((pdata->debounce_ms[1] % 5) != 0)
|| pdata->debounce_ms[1] > MAX_DEBOUNCE_B0_TIME
|| pdata->debounce_ms[1] < MIN_DEBOUNCE_B0_TIME) {
dev_err(&pdev->dev, "invalid debounce time supplied\n");
return -EINVAL;
}
}
kp = kzalloc(sizeof(*kp), GFP_KERNEL);
if (!kp)
return -ENOMEM;
keycodes = kzalloc(MATRIX_MAX_SIZE * sizeof(keycodes), GFP_KERNEL);
if (!keycodes) {
rc = -ENOMEM;
goto err_alloc_mem;
}
platform_set_drvdata(pdev, kp);
kp->pdata = pdata;
kp->dev = &pdev->dev;
kp->keycodes = keycodes;
kp->pm_chip = pm_chip;
if (pm8058_rev(pm_chip) == PM_8058_REV_1p0)
kp->flags |= KEYF_FIX_LAST_ROW;
kp->input = input_allocate_device();
if (!kp->input) {
dev_err(&pdev->dev, "unable to allocate input device\n");
rc = -ENOMEM;
goto err_alloc_device;
}
kp->key_sense_irq = platform_get_irq(pdev, 0);
if (kp->key_sense_irq < 0) {
dev_err(&pdev->dev, "unable to get keypad sense irq\n");
rc = -ENXIO;
goto err_get_irq;
}
kp->key_stuck_irq = platform_get_irq(pdev, 1);
if (kp->key_stuck_irq < 0) {
dev_err(&pdev->dev, "unable to get keypad stuck irq\n");
rc = -ENXIO;
goto err_get_irq;
}
if (pdata->input_name)
kp->input->name = pdata->input_name;
else
kp->input->name = "PMIC8058 keypad";
if (pdata->input_phys_device)
kp->input->phys = pdata->input_phys_device;
else
kp->input->phys = "pmic8058_keypad/input0";
kp->input->dev.parent = &pdev->dev;
kp->input->id.bustype = BUS_HOST;
kp->input->id.version = 0x0001;
kp->input->id.product = 0x0001;
kp->input->id.vendor = 0x0001;
kp->input->evbit[0] = BIT_MASK(EV_KEY);
if (pdata->rep)
__set_bit(EV_REP, kp->input->evbit);
kp->input->keycode = keycodes;
kp->input->keycodemax = MATRIX_MAX_SIZE;
kp->input->keycodesize = sizeof(*keycodes);
for (i = 0; i < pdata->keymap_size; i++) {
unsigned int row = KEY_ROW(pdata->keymap[i]);
unsigned int col = KEY_COL(pdata->keymap[i]);
unsigned short keycode = KEY_VAL(pdata->keymap[i]);
keycodes[(row << 3) + col] = keycode;
__set_bit(keycode, kp->input->keybit);
}
__clear_bit(KEY_RESERVED, kp->input->keybit);
input_set_capability(kp->input, EV_MSC, MSC_SCAN);
input_set_drvdata(kp->input, kp);
rc = input_register_device(kp->input);
if (rc < 0) {
dev_err(&pdev->dev, "unable to register keypad input device\n");
goto err_get_irq;
}
memset(kp->keystate, 0xff, sizeof(kp->keystate));
memset(kp->stuckstate, 0xff, sizeof(kp->stuckstate));
rc = pmic8058_kpd_init(kp);
if (rc < 0) {
dev_err(&pdev->dev, "unable to initialize keypad controller\n");
goto err_kpd_init;
}
rc = pm8058_kp_config_sns(pdata->cols_gpio_start,
pdata->num_cols);
if (rc < 0) {
dev_err(&pdev->dev, "unable to configure keypad sense lines\n");
goto err_gpio_config;
}
rc = pm8058_kp_config_drv(pdata->rows_gpio_start,
pdata->num_rows);
if (rc < 0) {
dev_err(&pdev->dev, "unable to configure keypad drive lines\n");
goto err_gpio_config;
}
rc = request_irq(kp->key_sense_irq, pmic8058_kp_irq,
IRQF_TRIGGER_RISING, "pmic-keypad", kp);
if (rc < 0) {
dev_err(&pdev->dev, "failed to request keypad sense irq\n");
goto err_req_sense_irq;
}
rc = request_irq(kp->key_stuck_irq, pmic8058_kp_stuck_irq,
IRQF_TRIGGER_RISING, "pmic-keypad-stuck", kp);
if (rc < 0) {
dev_err(&pdev->dev, "failed to request keypad stuck irq\n");
goto err_req_stuck_irq;
}
rc = pmic8058_kp_read(kp, &ctrl_val, KEYP_CTRL, 1);
ctrl_val |= KEYP_CTRL_KEYP_EN;
rc = pmic8058_kp_write_u8(kp, ctrl_val, KEYP_CTRL);
__dump_kp_regs(kp, "probe");
device_init_wakeup(&pdev->dev, pdata->wakeup);
return 0;
err_req_stuck_irq:
free_irq(kp->key_sense_irq, NULL);
err_req_sense_irq:
err_gpio_config:
err_kpd_init:
input_unregister_device(kp->input);
kp->input = NULL;
err_get_irq:
input_free_device(kp->input);
err_alloc_device:
kfree(keycodes);
err_alloc_mem:
kfree(kp);
return rc;
}
static int __devexit pmic8058_kp_remove(struct platform_device *pdev)
{
struct pmic8058_kp *kp = platform_get_drvdata(pdev);
device_init_wakeup(&pdev->dev, 0);
free_irq(kp->key_stuck_irq, NULL);
free_irq(kp->key_sense_irq, NULL);
input_unregister_device(kp->input);
platform_set_drvdata(pdev, NULL);
kfree(kp->input->keycode);
kfree(kp);
return 0;
}
static struct platform_driver pmic8058_kp_driver = {
.probe = pmic8058_kp_probe,
.remove = __devexit_p(pmic8058_kp_remove),
.driver = {
.name = "pm8058-keypad",
.owner = THIS_MODULE,
#ifdef CONFIG_PM
.pm = &pm8058_kp_pm_ops,
#endif
},
};
static int __init pmic8058_kp_init(void)
{
return platform_driver_register(&pmic8058_kp_driver);
}
module_init(pmic8058_kp_init);
static void __exit pmic8058_kp_exit(void)
{
platform_driver_unregister(&pmic8058_kp_driver);
}
static int __devinit eeti_ts_probe(struct i2c_client *client,
const struct i2c_device_id *idp)
{
struct eeti_ts_platform_data *pdata;
struct eeti_ts_priv *priv;
struct input_dev *input;
unsigned int irq_flags;
int err = -ENOMEM;
/* In contrast to what's described in the datasheet, there seems
* to be no way of probing the presence of that device using I2C
* commands. So we need to blindly believe it is there, and wait
* for interrupts to occur. */
priv = kzalloc(sizeof(*priv), GFP_KERNEL);
if (!priv) {
dev_err(&client->dev, "failed to allocate driver data\n");
goto err0;
}
mutex_init(&priv->mutex);
input = input_allocate_device();
if (!input) {
dev_err(&client->dev, "Failed to allocate input device.\n");
goto err1;
}
input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
input->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
input_set_abs_params(input, ABS_X, 0, EETI_MAXVAL, 0, 0);
input_set_abs_params(input, ABS_Y, 0, EETI_MAXVAL, 0, 0);
input_set_abs_params(input, ABS_PRESSURE, 0, 0xff, 0, 0);
input->name = client->name;
input->id.bustype = BUS_I2C;
input->dev.parent = &client->dev;
input->open = eeti_ts_open;
input->close = eeti_ts_close;
priv->client = client;
priv->input = input;
priv->irq = client->irq;
pdata = client->dev.platform_data;
if (pdata)
priv->irq_active_high = pdata->irq_active_high;
irq_flags = priv->irq_active_high ?
IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
INIT_WORK(&priv->work, eeti_ts_read);
i2c_set_clientdata(client, priv);
input_set_drvdata(input, priv);
err = input_register_device(input);
if (err)
goto err1;
err = request_irq(priv->irq, eeti_ts_isr, irq_flags,
client->name, priv);
if (err) {
dev_err(&client->dev, "Unable to request touchscreen IRQ.\n");
goto err2;
}
/* Disable the irq for now. It will be enabled once the input device
* is opened. */
disable_irq(priv->irq);
device_init_wakeup(&client->dev, 0);
return 0;
err2:
input_unregister_device(input);
input = NULL; /* so we dont try to free it below */
err1:
input_free_device(input);
i2c_set_clientdata(client, NULL);
kfree(priv);
err0:
return err;
}
static void __exit logibm_exit(void)
{
input_unregister_device(logibm_dev);
release_region(LOGIBM_BASE, LOGIBM_EXTENT);
}
static int __devinit omap_kp_probe(struct platform_device *pdev)
{
struct omap_kp *omap_kp;
struct input_dev *input_dev;
struct omap_kp_platform_data *pdata = pdev->dev.platform_data;
int i, col_idx, row_idx, irq_idx, ret;
if (!pdata->rows || !pdata->cols || !pdata->keymap) {
return -EINVAL;
}
omap_kp = kzalloc(sizeof(struct omap_kp), GFP_KERNEL);
input_dev = input_allocate_device();
if (!omap_kp || !input_dev) {
kfree(omap_kp);
input_free_device(input_dev);
return -ENOMEM;
}
if (cpu_is_omap44xx()) {
//omap_kp->cclk = clk_get(NULL, "keyboard_ck");
omap_kp->cclk = clk_get(NULL, "kbd_fck");
if (IS_ERR(omap_kp->cclk))
{
goto err0;
}
ret = clk_enable(omap_kp->cclk);
if (ret)
printk(KERN_ERR "[omap_kp:] Unable to get keyboard_ck \n");
}
platform_set_drvdata(pdev, omap_kp);
omap_kp->input = input_dev;
/* Disable the interrupt for the MPUIO keyboard */
if (!cpu_is_omap24xx() && !cpu_is_omap44xx())
omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
keymap = pdata->keymap;
if (pdata->rep)
__set_bit(EV_REP, input_dev->evbit);
if (pdata->delay)
omap_kp->delay = pdata->delay;
if (pdata->row_gpios && pdata->col_gpios) {
row_gpios = pdata->row_gpios;
col_gpios = pdata->col_gpios;
}
omap_kp->rows = pdata->rows;
omap_kp->cols = pdata->cols;
if (cpu_is_omap24xx()) {
/* Cols: outputs */
for (col_idx = 0; col_idx < omap_kp->cols; col_idx++) {
if (gpio_request(col_gpios[col_idx], "omap_kp_col") < 0) {
printk(KERN_ERR "[omap_kp:]Failed to request"
"GPIO%d for keypad\n",
col_gpios[col_idx]);
goto err1;
}
gpio_direction_output(col_gpios[col_idx], 0);
}
/* Rows: inputs */
for (row_idx = 0; row_idx < omap_kp->rows; row_idx++) {
if (gpio_request(row_gpios[row_idx], "omap_kp_row") < 0) {
printk(KERN_ERR "[omap_kp:]Failed to request"
"GPIO%d for keypad\n",
row_gpios[row_idx]);
goto err2;
}
gpio_direction_input(row_gpios[row_idx]);
}
} else {
col_idx = 0;
row_idx = 0;
}
setup_timer(&omap_kp->timer, omap_kp_timer, (unsigned long)omap_kp);
/* get the irq and init timer*/
tasklet_enable(&kp_tasklet);
kp_tasklet.data = (unsigned long) omap_kp;
ret = device_create_file(&pdev->dev, &dev_attr_enable);
if (ret < 0)
goto err2;
#ifdef FACTORY_AT_COMMAND_GKPD
ret = device_create_file(&pdev->dev, &dev_attr_key_test_mode);
if (ret) {
printk( "keypad: keypad_probe: Fail\n");
device_remove_file(&pdev->dev, &dev_attr_key_test_mode);
}
wake_lock_init(&key_wake_lock, WAKE_LOCK_SUSPEND, "omap4030_Keypad");
#endif
/* setup input device */
__set_bit(EV_KEY, input_dev->evbit);
for (i = 0; keymap[i] != 0; i++)
__set_bit(keymap[i] & KEY_MAX, input_dev->keybit);
if (cpu_is_omap44xx())
__set_bit(KEY_OK, input_dev->keybit);
input_dev->name = "omap-keypad";
input_dev->phys = "omap-keypad/input0";
input_dev->dev.parent = &pdev->dev;
input_dev->id.bustype = BUS_HOST;
input_dev->id.vendor = 0x0001;
input_dev->id.product = 0x0001;
input_dev->id.version = 0x0100;
ret = input_register_device(omap_kp->input);
if (ret < 0) {
printk(KERN_ERR "[omap_kp:]Unable to register omap-keypad input device\n");
goto err3;
}
if (pdata->dbounce) {
if (cpu_is_omap44xx())
omap_writel(0xff, OMAP4_KBDOCP_BASE +
OMAP4_KBD_DEBOUNCINGTIME);
else
omap_writew(0xff, OMAP1_MPUIO_BASE +
OMAP_MPUIO_GPIO_DEBOUNCING);
}
/* scan current status and enable interrupt */
omap_kp_scan_keypad(omap_kp, keypad_state);
/* Configuring OMAP4 keypad registers */
if (cpu_is_omap44xx()) {
omap_writel(OMAP4_KBD_SYSCONFIG_SOFTRST |
OMAP4_KBD_SYSCONFIG_ENAWKUP, OMAP4_KBDOCP_BASE
+ OMAP4_KBD_SYSCONFIG);
omap_writel(0x1E, OMAP4_KBDOCP_BASE + OMAP4_KBD_CTRL);
omap_writel(0x7, OMAP4_KBDOCP_BASE + OMAP4_KBD_DEBOUNCINGTIME);
}
if (!cpu_is_omap24xx()) {
omap_kp->irq = platform_get_irq(pdev, 0);
if (request_irq(152, omap_kp_interrupt, 0,
"omap-keypad", omap_kp) < 0)
goto err4;
if (!cpu_is_omap44xx())
omap_writel(0, OMAP1_MPUIO_BASE +
OMAP_MPUIO_KBD_MASKIT);
} else {
for (irq_idx = 0; irq_idx < omap_kp->rows; irq_idx++) {
if (request_irq(gpio_to_irq(row_gpios[irq_idx]),
omap_kp_interrupt,
IRQF_TRIGGER_FALLING,
"omap-keypad", omap_kp) < 0)
goto err5;
}
}
if (cpu_is_omap44xx()) {
omap_writel(OMAP4_KBD_IRQDISABLE,
OMAP4_KBDOCP_BASE + OMAP4_KBD_IRQSTATUS);
omap_writel(OMAP4_KBD_IRQENABLE_EVENTEN |
OMAP4_KBD_IRQENABLE_LONGKEY ,
OMAP4_KBDOCP_BASE + OMAP4_KBD_IRQENABLE);
}
return 0;
err5:
for (i = irq_idx - 1; i >=0; i--)
free_irq(row_gpios[i], 0);
err4:
input_unregister_device(omap_kp->input);
input_dev = NULL;
err3:
device_remove_file(&pdev->dev, &dev_attr_enable);
err2:
for (i = row_idx - 1; i >=0; i--)
gpio_free(row_gpios[i]);
err1:
for (i = col_idx - 1; i >=0; i--)
gpio_free(col_gpios[i]);
clk_put(omap_kp->cclk);
err0:
kfree(omap_kp);
input_free_device(input_dev);
return -EINVAL;
}
static int dock_switch_probe(struct platform_device *pdev)
{
struct gpio_switch_platform_data *pdata = pdev->dev.platform_data;
int ret = -EBUSY;
int err;
if (!pdata)
return -EBUSY;
switch_data = kzalloc(sizeof(struct dock_switch_data), GFP_KERNEL);
if (!switch_data)
return -ENOMEM;
switch_data->gpio = pdata->gpio;
switch_data->hs_gpio = DOCK_HS_GPIO;
switch_data->irq = gpio_to_irq(pdata->gpio);
switch_data->hs_irq = gpio_to_irq(DOCK_HS_GPIO);
switch_data->sdev.print_state = switch_print_state;
switch_data->sdev.name = DRIVER_NAME;
switch_data->sdev.print_name = switch_print_name;
switch_data->sdev.print_state = switch_print_state;
ret = switch_dev_register(&switch_data->sdev);
if (ret < 0)
goto err_register_switch;
INIT_WORK(&switch_data->work, dock_switch_work);
ret = request_irq(switch_data->irq, dock_interrupt,
IRQF_DISABLED | IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
DRIVER_NAME, switch_data);
if (ret) {
pr_err("dock_switch request irq failed\n");
goto err_request_irq;
}
input_dock = input_allocate_device();
if (input_dock == NULL) {
pr_err("dock input_allocate_device error!\n");
ret = -ENOMEM;
goto err_alloc_input_dev;
}
err = dock_register_input(input_dock);
if (err < 0) {
pr_err("dock register_input error\n");
goto err_register_input_dev;
}
/* Dock Headset */
INIT_WORK(&switch_data->hs_work, dock_hs_switch_work);
switch_data->hs_debounce_time = ktime_set(0, 250000000);
hrtimer_init(&switch_data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
switch_data->timer.function = detect_event_timer_func;
ret = request_irq(switch_data->hs_irq, dock_hs_interrupt,
IRQF_DISABLED | IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
"dock_hs", switch_data);
if (ret) {
pr_err("dock_switch request hs_irq failed\n");
goto err_request_hs_det_irq;
}
dock_kobj = kobject_create_and_add("dock", NULL);
if (dock_kobj == NULL)
pr_err("%s: subsystem_register failed\n", __FUNCTION__);
err = sysfs_create_group(dock_kobj, &attr_group);
if (err)
pr_err("%s: sysfs_create_group failed, %d\n", __FUNCTION__, __LINE__);
// set current status
dock_switch_work(&switch_data->work);
printk(KERN_INFO "Dock switch driver probe done!\n");
return 0;
err_request_hs_det_irq:
input_unregister_device(input_dock);
err_register_input_dev:
input_free_device(input_dock);
err_alloc_input_dev:
free_irq(switch_data->irq, switch_data);
err_request_irq:
switch_dev_unregister(&switch_data->sdev);
err_register_switch:
kfree(switch_data);
return ret;
}
static int __devinit bh1721fvc_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int err = 0;
struct bh1721fvc_data *bh1721fvc;
struct input_dev *input_dev;
struct bh1721fvc_platform_data *pdata = client->dev.platform_data;
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
return -EIO;
bh1721fvc = kzalloc(sizeof(*bh1721fvc), GFP_KERNEL);
if (!bh1721fvc) {
pr_err("%s, failed to alloc memory for module data\n",
__func__);
return -ENOMEM;
}
#if defined(CONFIG_MACH_SAMSUNG_P5)
bh1721fvc->output = pdata->output;
#endif
bh1721fvc->reset = pdata->reset;
if (!bh1721fvc->reset) {
pr_err("%s: reset callback is null\n", __func__);
err = -EIO;
goto err_reset_null;
}
err = bh1721fvc->reset();
if (err) {
pr_err("%s: Failed to reset\n", __func__);
goto err_reset_failed;
}
bh1721fvc->client = client;
i2c_set_clientdata(client, bh1721fvc);
mutex_init(&bh1721fvc->lock);
hrtimer_init(&bh1721fvc->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
bh1721fvc->light_poll_delay = ns_to_ktime(200 * NSEC_PER_MSEC);
bh1721fvc->state = POWER_DOWN;
bh1721fvc->measure_mode = AUTO_MEASURE;
bh1721fvc->timer.function = bh1721fvc_timer_func;
err = bh1721fvc_test_luxvalue(bh1721fvc);
if (err < 0) {
printk("data read fail : %d!!\n", err);
goto err_create_workqueue;
}
else
printk("Lux : %d\n", err);
bh1721fvc->wq = alloc_workqueue("bh1721fvc_wq",
WQ_UNBOUND | WQ_RESCUER, 1);
if (!bh1721fvc->wq) {
err = -ENOMEM;
pr_err("%s: could not create workqueue\n", __func__);
goto err_create_workqueue;
}
INIT_WORK(&bh1721fvc->work_light, bh1721fvc_work_func_light);
input_dev = input_allocate_device();
if (!input_dev) {
pr_err("%s: could not allocate input device\n", __func__);
err = -ENOMEM;
goto err_input_allocate_device_light;
}
input_set_drvdata(input_dev, bh1721fvc);
input_dev->name = "light_sensor";
input_set_capability(input_dev, EV_ABS, ABS_MISC);
input_set_abs_params(input_dev, ABS_MISC,
LUX_MIN_VALUE, LUX_MAX_VALUE, 0, 0);
bh1721fvc_dbmsg("registering lightsensor-level input device\n");
err = input_register_device(input_dev);
if (err < 0) {
pr_err("%s: could not register input device\n", __func__);
input_free_device(input_dev);
goto err_input_register_device_light;
}
bh1721fvc->input_dev = input_dev;
err = sysfs_create_group(&input_dev->dev.kobj,
&bh1721fvc_attribute_group);
if (err) {
pr_err("%s: could not create sysfs group\n", __func__);
goto err_sysfs_create_group_light;
}
#ifdef FACTORY_TEST
bh1721fvc->factory_class = class_create(THIS_MODULE, "lightsensor");
if (IS_ERR(bh1721fvc->factory_class)) {
pr_err("Failed to create class(lightsensor)!\n");
err = PTR_ERR(bh1721fvc->factory_class);
goto err_factory_sysfs_create;
}
bh1721fvc->factory_dev = device_create(bh1721fvc->factory_class, NULL,
0, bh1721fvc, "switch_cmd");
if (IS_ERR(bh1721fvc->factory_dev)) {
pr_err("Failed to create device(switch_cmd_dev)!\n");
err = PTR_ERR(bh1721fvc->factory_dev);
goto err_factory_device_create;
}
err = device_create_file(bh1721fvc->factory_dev,
&dev_attr_lightsensor_file_cmd);
if (err < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_lightsensor_file_cmd.attr.name);
goto err_file_cmd_attr_create;
}
err = device_create_file(bh1721fvc->factory_dev,
&dev_attr_lightsensor_file_illuminance);
if (err < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_lightsensor_file_illuminance.attr.name);
goto err_illuminance_attr_create;
}
#endif
goto done;
#ifdef FACTORY_TEST
err_illuminance_attr_create:
device_remove_file(bh1721fvc->factory_dev,
&dev_attr_lightsensor_file_cmd);
err_file_cmd_attr_create:
device_destroy(bh1721fvc->factory_class, 0);
err_factory_device_create:
class_destroy(bh1721fvc->factory_class);
err_factory_sysfs_create:
sysfs_remove_group(&bh1721fvc->input_dev->dev.kobj,
&bh1721fvc_attribute_group);
#endif
err_sysfs_create_group_light:
input_unregister_device(bh1721fvc->input_dev);
err_input_register_device_light:
err_input_allocate_device_light:
destroy_workqueue(bh1721fvc->wq);
err_create_workqueue:
mutex_destroy(&bh1721fvc->lock);
err_reset_failed:
err_reset_null:
kfree(bh1721fvc);
done:
return err;
}
static int __devinit hall_sensor_probe(struct platform_device *pdev)
{
struct hall_sensor_data *hsdata = pdev->dev.platform_data;
struct input_dev *input_dev;
int err = 0;
if (pdev->dev.of_node) {
hsdata = devm_kzalloc(&pdev->dev, sizeof(struct hall_sensor_data),
GFP_KERNEL);
if (!hsdata) {
dev_err(&pdev->dev, "[Hall] Failed to allocate memory");
return -ENOMEM;
}
err = hall_sensor_parse_dt(&pdev->dev, hsdata);
if (err)
goto err_free_mem;
}
if (!hsdata)
return -EINVAL;
hsdata->dev = &pdev->dev;
input_dev = input_allocate_device();
if (input_dev == NULL) {
dev_err(&pdev->dev, "[Hall] Failed to allocate input device\n");
goto err_free_mem;
}
input_dev->name = DRIVER_NAME;
input_dev->dev.parent = &pdev->dev;
input_dev->id.bustype = BUS_HOST;
__set_bit(EV_KEY, input_dev->evbit);
__set_bit(KEY_POWER, input_dev->keybit);
spin_lock_init(&hsdata->lock);
wake_lock_init(&hsdata->irq_wake_lock, WAKE_LOCK_SUSPEND, DRIVER_NAME);
hsdata->input_dev = input_dev;
err = input_register_device(input_dev);
if (err) {
dev_err(&pdev->dev, "[Hall] Failed to register input device\n");
goto err_free_input_dev;
}
/* GPIO irq */
err = gpio_request(hsdata->irq_gpio, "hall-irq-gpio");
if (err) {
dev_err(&pdev->dev, "[Hall] Failed to request irq gpio\n");
goto err_unregister_input;
}
err = gpio_direction_input(hsdata->irq_gpio);
if (err) {
dev_err(&pdev->dev, "[Hall] Unable to set direction for irq gpio %d\n",
hsdata->irq_gpio);
goto err_free_irq_gpio;
}
err = request_threaded_irq(hsdata->irq, NULL, hall_sensor_irq_handler,
hsdata->irq_gpio_flags, DRIVER_NAME,
hsdata);
if (err) {
dev_err(&pdev->dev, "[Hall] Failed to request irq %d\n", hsdata->irq);
goto err_free_irq_gpio;
}
hsdata->sdev.print_state = switch_print_state;
hsdata->sdev.name = SENSOR_NAME;
hsdata->sdev.print_name = switch_print_name;
err = switch_dev_register(&hsdata->sdev);
if (err) {
dev_err(&pdev->dev, "[Hall] Register switch device failed\n");
goto err_free_irq;
}
#if defined(CONFIG_FB)
hsdata->fb_notif.notifier_call = hall_fb_notifier_callback;
err = fb_register_client(&hsdata->fb_notif);
if (err) {
dev_err(&pdev->dev, "[Hall] Failed to register fb_notifier:%d\n", err);
goto err_unregister_switch;
}
#endif
err = sysfs_create_group(&hsdata->sdev.dev->kobj, &hall_sensor_attr_group);
if (err) {
dev_err(&pdev->dev, "[Hall] Failed to create sysfs group:%d\n", err);
goto err_unregister_fb;
}
dev_set_drvdata(&pdev->dev, hsdata);
INIT_DELAYED_WORK(&hsdata->state_delay_work, hall_sensor_work);
/* default enable wakeup feature */
hsdata->wakeup_enable = true;
device_init_wakeup(&pdev->dev, HALL_WAKEUP_ENABLE);
enable_irq_wake(hsdata->irq);
hsdev = hsdata;
return 0;
err_unregister_fb:
fb_unregister_client(&hsdata->fb_notif);
err_unregister_switch:
switch_dev_unregister(&hsdata->sdev);
err_free_irq:
free_irq(hsdata->irq, hsdata);
err_free_irq_gpio:
if (gpio_is_valid(hsdata->irq_gpio))
gpio_free(hsdata->irq_gpio);
err_unregister_input:
input_unregister_device(hsdata->input_dev);
err_free_input_dev:
if (input_dev)
input_free_device(input_dev);
err_free_mem:
devm_kfree(&pdev->dev, (void *)hsdata);
return err;
}
static int __devinit isl29028_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int err = 0;
struct input_dev *input_dev;
PR_DEB("isl29028_probe\n");
data = kzalloc(sizeof(struct isl29028_data), GFP_KERNEL);
if (data == NULL) {
err = -ENOMEM;
goto exit;
}
data->client = client;
i2c_set_clientdata(client, data);
dev_info(&client->dev, "support ver. %s enabled\n", DRIVER_VERSION);
/* allocate proximity input_device */
input_dev = input_allocate_device();
if (input_dev == NULL) {
err = -ENOMEM;
dev_err(&data->client->dev, "proximity input device allocate failed\n");
goto exit0;
}
input_set_drvdata(input_dev, data);
input_dev->name = "proximity";
input_set_capability(input_dev, EV_ABS, ABS_DISTANCE);
input_set_abs_params(input_dev, ABS_DISTANCE, 0, 1, 0, 0);
PR_DEB("registering proximity input device\n");
err = input_register_device(input_dev);
if (err) {
pr_err("%s: could not register input device\n", __func__);
goto exit1;
}
data->proximity_input_dev = input_dev;
/* create proximity sysfs interface */
err = sysfs_create_group(&input_dev->dev.kobj, &proximity_attribute_group);
if (err) {
pr_err("%s: could not create sysfs group\n", __func__);
goto exit2;
}
/* allocate light input_device */
input_dev = input_allocate_device();
if (input_dev == NULL) {
err = -ENOMEM;
dev_err(&data->client->dev, "light input device allocate failed\n");
goto exit2;
}
input_set_drvdata(input_dev, data);
input_dev->name = "light";
input_set_capability(input_dev, EV_ABS, ABS_MISC);
input_set_abs_params(input_dev, ABS_MISC, 0, 1, 0, 0);
PR_DEB("registering light input device\n");
err = input_register_device(input_dev);
if (err) {
pr_err("%s: could not register input device\n", __func__);
goto exit3;
}
data->light_input_dev = input_dev;
/* create proximity sysfs interface */
err = sysfs_create_group(&input_dev->dev.kobj, &light_attribute_group);
if (err) {
pr_err("%s: could not create sysfs group\n", __func__);
goto exit4;
}
wq = create_workqueue("isl29028_workqueue");
if (wq == NULL) {
PR_DEB("can't create a workqueue\n");
err = -1;
goto exit4;
}
INIT_DELAYED_WORK(&data->prox_work, prox_work_func);
INIT_DELAYED_WORK(&data->als_work, als_work_func);
/*isl29028 reset*/
isl29028_reset(client);
/*isl29028 init*/
err = isl29028_init_client(client);
if(err)
goto exit5;
/*init mutex for prox */
mutex_init(&prox_lock);
/*init mutex for als */
mutex_init(&als_lock);
wake_lock_init(&data->prox_wake_lock, WAKE_LOCK_SUSPEND, "prox_wake_lock");
/*set init state to not-working*/
atomic_set(&data->als_working,0);
atomic_set(&data->prox_working,0);
/*set init state to not-locking*/
atomic_set(&data->prox_locking,0);
/*set default interval*/
data->prox_interval = DEFAULT_PROX_INTERVAL;
data->als_interval = DEFAULT_ALS_INTERVAL;
dev_info(&client->dev, "sensor driver probe successful\n");
goto exit;
exit5:
destroy_workqueue(wq);
exit4:
sysfs_remove_group(&data->light_input_dev->dev.kobj, &light_attribute_group);
exit3:
input_unregister_device(data->light_input_dev);
input_free_device(data->light_input_dev);
exit2:
sysfs_remove_group(&data->proximity_input_dev->dev.kobj, &proximity_attribute_group);
exit1:
input_unregister_device(data->proximity_input_dev);
input_free_device(data->proximity_input_dev);
exit0:
kfree(data);
exit:
return err;
}
static int __init hdaps_init(void)
{
int ret;
/* Determine axis orientation orientation */
if (hdaps_invert == HDAPS_ORIENT_UNDEFINED) /* set by module param? */
if (dmi_check_system(hdaps_whitelist) < 1) /* in whitelist? */
hdaps_invert = 0; /* default */
/* Init timer before platform_driver_register, in case of suspend */
init_timer(&hdaps_timer);
hdaps_timer.function = hdaps_mousedev_poll;
ret = platform_driver_register(&hdaps_driver);
if (ret)
goto out;
pdev = platform_device_register_simple("hdaps", -1, NULL, 0);
if (IS_ERR(pdev)) {
ret = PTR_ERR(pdev);
goto out_driver;
}
ret = sysfs_create_group(&pdev->dev.kobj, &hdaps_attribute_group);
if (ret)
goto out_device;
hdaps_idev = input_allocate_device();
if (!hdaps_idev) {
ret = -ENOMEM;
goto out_group;
}
hdaps_idev_raw = input_allocate_device();
if (!hdaps_idev_raw) {
ret = -ENOMEM;
goto out_idev_first;
}
/* calibration for the input device (deferred to avoid delay) */
needs_calibration = 1;
/* initialize the joystick-like fuzzed input device */
hdaps_idev->name = "ThinkPad HDAPS joystick emulation";
hdaps_idev->phys = "hdaps/input0";
hdaps_idev->id.bustype = BUS_HOST;
hdaps_idev->id.vendor = HDAPS_INPUT_VENDOR;
hdaps_idev->id.product = HDAPS_INPUT_PRODUCT;
hdaps_idev->id.version = HDAPS_INPUT_JS_VERSION;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
hdaps_idev->cdev.dev = &pdev->dev;
#endif
hdaps_idev->evbit[0] = BIT(EV_ABS);
hdaps_idev->open = hdaps_mousedev_open;
hdaps_idev->close = hdaps_mousedev_close;
input_set_abs_params(hdaps_idev, ABS_X,
-256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
input_set_abs_params(hdaps_idev, ABS_Y,
-256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
ret = input_register_device(hdaps_idev);
if (ret)
goto out_idev;
/* initialize the raw data input device */
hdaps_idev_raw->name = "ThinkPad HDAPS accelerometer data";
hdaps_idev_raw->phys = "hdaps/input1";
hdaps_idev_raw->id.bustype = BUS_HOST;
hdaps_idev_raw->id.vendor = HDAPS_INPUT_VENDOR;
hdaps_idev_raw->id.product = HDAPS_INPUT_PRODUCT;
hdaps_idev_raw->id.version = HDAPS_INPUT_RAW_VERSION;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
hdaps_idev_raw->cdev.dev = &pdev->dev;
#endif
hdaps_idev_raw->evbit[0] = BIT(EV_ABS);
hdaps_idev_raw->open = hdaps_mousedev_open;
hdaps_idev_raw->close = hdaps_mousedev_close;
input_set_abs_params(hdaps_idev_raw, ABS_X, -32768, 32767, 0, 0);
input_set_abs_params(hdaps_idev_raw, ABS_Y, -32768, 32767, 0, 0);
ret = input_register_device(hdaps_idev_raw);
if (ret)
goto out_idev_reg_first;
printk(KERN_INFO "hdaps: driver successfully loaded.\n");
return 0;
out_idev_reg_first:
input_unregister_device(hdaps_idev);
out_idev:
input_free_device(hdaps_idev_raw);
out_idev_first:
input_free_device(hdaps_idev);
out_group:
sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
out_device:
platform_device_unregister(pdev);
out_driver:
platform_driver_unregister(&hdaps_driver);
hdaps_device_shutdown();
out:
printk(KERN_WARNING "hdaps: driver init failed (ret=%d)!\n", ret);
return ret;
}
static int __devinit bma250_probe(struct i2c_client *ic_dev,
const struct i2c_device_id *id)
{
struct driver_data *dd;
int rc;
struct bma250_platform_data *pdata = ic_dev->dev.platform_data;
if (!pdata || !pdata->hw_config)
return -ENODEV;
if (pdata->bypass_state && pdata->read_axis_data
&& pdata->check_sleep_status && pdata->vote_sleep_status)
slave_hw = TRUE;
else if (!pdata->bypass_state && !pdata->read_axis_data
&& !pdata->check_sleep_status && !pdata->vote_sleep_status)
slave_hw = FALSE;
else
return -ENODEV;
dd = kzalloc(sizeof(struct driver_data), GFP_KERNEL);
if (!dd) {
rc = -ENOMEM;
goto probe_exit;
}
mutex_lock(&bma250_dd_lock);
list_add_tail(&dd->next_dd, &dd_list);
mutex_unlock(&bma250_dd_lock);
dd->ic_dev = ic_dev;
INIT_DELAYED_WORK(&dd->work_data, bma250_work_f);
dd->pdata = pdata;
/* initial configuration */
dd->rate = pdata->rate;
dd->delay_jiffies = msecs_to_jiffies(dd->rate);
dd->bw_sel = pdata->reg->bw_sel;
dd->range = pdata->reg->range;
rc = bma250_power_up(dd);
if (rc)
goto probe_err_cfg;
rc = bma250_hwid(dd);
bma250_power_down(dd);
if (rc)
goto probe_err_cfg;
bma250_create_dbfs_entry(dd);
bma250_ic_set_data(ic_dev, dd);
dd->ip_dev = input_allocate_device();
if (!dd->ip_dev) {
rc = -ENOMEM;
goto probe_err_reg;
}
input_set_drvdata(dd->ip_dev, dd);
dd->ip_dev->open = bma250_open;
dd->ip_dev->close = bma250_release;
dd->ip_dev->name = BMA250_NAME;
dd->ip_dev->id.vendor = BMA250_VENDORID;
dd->ip_dev->id.product = 1;
dd->ip_dev->id.version = 1;
__set_bit(EV_ABS, dd->ip_dev->evbit);
__set_bit(ABS_X, dd->ip_dev->absbit);
__set_bit(ABS_Y, dd->ip_dev->absbit);
__set_bit(ABS_Z, dd->ip_dev->absbit);
__set_bit(ABS_MISC, dd->ip_dev->absbit);
input_set_abs_params(dd->ip_dev, ABS_X, -4096, 4095, 0, 0);
input_set_abs_params(dd->ip_dev, ABS_Y, -4096, 4095, 0, 0);
input_set_abs_params(dd->ip_dev, ABS_Z, -4096, 4095, 0, 0);
input_set_abs_params(dd->ip_dev, ABS_MISC, -80, 175, 0, 0);
rc = input_register_device(dd->ip_dev);
if (rc) {
input_free_device(dd->ip_dev);
goto probe_err_reg;
}
rc = add_sysfs_interfaces(&dd->ip_dev->dev);
if (rc)
goto probe_err_sysfs;
return rc;
probe_err_sysfs:
input_unregister_device(dd->ip_dev);
probe_err_reg:
bma250_remove_dbfs_entry(dd);
bma250_ic_set_data(ic_dev, NULL);
probe_err_cfg:
mutex_lock(&bma250_dd_lock);
list_del(&dd->next_dd);
mutex_unlock(&bma250_dd_lock);
kfree(dd);
probe_exit:
return rc;
}
static int __devinit omap_kp_probe(struct platform_device *pdev)
{
struct omap_kp *omap_kp;
struct input_dev *input_dev;
struct omap_kp_platform_data *pdata = pdev->dev.platform_data;
int i, col_idx, row_idx, irq_idx, ret;
if (!pdata->rows || !pdata->cols || !pdata->keymap) {
printk(KERN_ERR "No rows, cols or keymap from pdata\n");
return -EINVAL;
}
omap_kp = kzalloc(sizeof(struct omap_kp), GFP_KERNEL);
input_dev = input_allocate_device();
if (!omap_kp || !input_dev) {
kfree(omap_kp);
input_free_device(input_dev);
return -ENOMEM;
}
platform_set_drvdata(pdev, omap_kp);
omap_kp->input = input_dev;
/* Disable the interrupt for the MPUIO keyboard */
if (!cpu_is_omap24xx())
omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
keymap = pdata->keymap;
if (pdata->rep)
__set_bit(EV_REP, input_dev->evbit);
if (pdata->delay)
omap_kp->delay = pdata->delay;
if (pdata->row_gpios && pdata->col_gpios) {
row_gpios = pdata->row_gpios;
col_gpios = pdata->col_gpios;
}
omap_kp->rows = pdata->rows;
omap_kp->cols = pdata->cols;
if (cpu_is_omap24xx()) {
/* Cols: outputs */
for (col_idx = 0; col_idx < omap_kp->cols; col_idx++) {
if (gpio_request(col_gpios[col_idx], "omap_kp_col") < 0) {
printk(KERN_ERR "Failed to request"
"GPIO%d for keypad\n",
col_gpios[col_idx]);
goto err1;
}
gpio_direction_output(col_gpios[col_idx], 0);
}
/* Rows: inputs */
for (row_idx = 0; row_idx < omap_kp->rows; row_idx++) {
if (gpio_request(row_gpios[row_idx], "omap_kp_row") < 0) {
printk(KERN_ERR "Failed to request"
"GPIO%d for keypad\n",
row_gpios[row_idx]);
goto err2;
}
gpio_direction_input(row_gpios[row_idx]);
}
} else {
col_idx = 0;
row_idx = 0;
}
setup_timer(&omap_kp->timer, omap_kp_timer, (unsigned long)omap_kp);
/* get the irq and init timer*/
tasklet_enable(&kp_tasklet);
kp_tasklet.data = (unsigned long) omap_kp;
ret = device_create_file(&pdev->dev, &dev_attr_enable);
if (ret < 0)
goto err2;
/* setup input device */
__set_bit(EV_KEY, input_dev->evbit);
for (i = 0; keymap[i] != 0; i++)
__set_bit(keymap[i] & KEY_MAX, input_dev->keybit);
input_dev->name = "omap-keypad";
input_dev->phys = "omap-keypad/input0";
input_dev->dev.parent = &pdev->dev;
input_dev->id.bustype = BUS_HOST;
input_dev->id.vendor = 0x0001;
input_dev->id.product = 0x0001;
input_dev->id.version = 0x0100;
ret = input_register_device(omap_kp->input);
if (ret < 0) {
printk(KERN_ERR "Unable to register omap-keypad input device\n");
goto err3;
}
if (pdata->dbounce)
omap_writew(0xff, OMAP1_MPUIO_BASE + OMAP_MPUIO_GPIO_DEBOUNCING);
/* scan current status and enable interrupt */
omap_kp_scan_keypad(omap_kp, keypad_state);
if (!cpu_is_omap24xx()) {
omap_kp->irq = platform_get_irq(pdev, 0);
if (omap_kp->irq >= 0) {
if (request_irq(omap_kp->irq, omap_kp_interrupt, 0,
"omap-keypad", omap_kp) < 0)
goto err4;
}
omap_writew(0, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
} else {
for (irq_idx = 0; irq_idx < omap_kp->rows; irq_idx++) {
if (request_irq(gpio_to_irq(row_gpios[irq_idx]),
omap_kp_interrupt,
IRQF_TRIGGER_FALLING,
"omap-keypad", omap_kp) < 0)
goto err5;
}
}
return 0;
err5:
for (i = irq_idx - 1; i >=0; i--)
free_irq(row_gpios[i], 0);
err4:
input_unregister_device(omap_kp->input);
input_dev = NULL;
err3:
device_remove_file(&pdev->dev, &dev_attr_enable);
err2:
for (i = row_idx - 1; i >=0; i--)
gpio_free(row_gpios[i]);
err1:
for (i = col_idx - 1; i >=0; i--)
gpio_free(col_gpios[i]);
kfree(omap_kp);
input_free_device(input_dev);
return -EINVAL;
}
static int __devinit hs_probe(struct platform_device *pdev)
{
int rc = 0;
struct input_dev *ipdev;
hs = kzalloc(sizeof(struct msm_handset), GFP_KERNEL);
if (!hs)
return -ENOMEM;
hs->sdev.name = "h2w";
hs->sdev.print_name = msm_headset_print_name;
rc = switch_dev_register(&hs->sdev);
if (rc)
goto err_switch_dev_register;
ipdev = input_allocate_device();
if (!ipdev) {
rc = -ENOMEM;
goto err_alloc_input_dev;
}
input_set_drvdata(ipdev, hs);
hs->ipdev = ipdev;
if (pdev->dev.platform_data)
hs->hs_pdata = pdev->dev.platform_data;
if (hs->hs_pdata->hs_name)
ipdev->name = hs->hs_pdata->hs_name;
else
ipdev->name = DRIVER_NAME;
ipdev->id.vendor = 0x0001;
ipdev->id.product = 1;
ipdev->id.version = 1;
input_set_capability(ipdev, EV_KEY, KEY_MEDIA);
input_set_capability(ipdev, EV_KEY, KEY_VOLUMEUP);
input_set_capability(ipdev, EV_KEY, KEY_VOLUMEDOWN);
input_set_capability(ipdev, EV_SW, SW_HEADPHONE_INSERT);
input_set_capability(ipdev, EV_KEY, KEY_POWER);
input_set_capability(ipdev, EV_KEY, KEY_END);
#if 0
input_set_capability(ipdev, EV_KEY, KEY_HEADSETHOOK);
#endif
rc = input_register_device(ipdev);
if (rc) {
dev_err(&ipdev->dev,
"hs_probe: input_register_device rc=%d\n", rc);
goto err_reg_input_dev;
}
platform_set_drvdata(pdev, hs);
rc = hs_rpc_init();
if (rc) {
dev_err(&ipdev->dev, "rpc init failure\n");
goto err_hs_rpc_init;
}
return 0;
err_hs_rpc_init:
input_unregister_device(ipdev);
ipdev = NULL;
err_reg_input_dev:
input_free_device(ipdev);
err_alloc_input_dev:
switch_dev_unregister(&hs->sdev);
err_switch_dev_register:
kfree(hs);
return rc;
}
static int __devinit adp5520_keys_probe(struct platform_device *pdev)
{
struct adp5520_keys_platform_data *pdata = pdev->dev.platform_data;
struct input_dev *input;
struct adp5520_keys *dev;
int ret, i;
unsigned char en_mask, ctl_mask = 0;
if (pdev->id != ID_ADP5520) {
dev_err(&pdev->dev, "only ADP5520 supports Keypad\n");
return -EINVAL;
}
if (pdata == NULL) {
dev_err(&pdev->dev, "missing platform data\n");
return -EINVAL;
}
if (!(pdata->rows_en_mask && pdata->cols_en_mask))
return -EINVAL;
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
if (dev == NULL) {
dev_err(&pdev->dev, "failed to alloc memory\n");
return -ENOMEM;
}
input = input_allocate_device();
if (!input) {
ret = -ENOMEM;
goto err;
}
dev->master = pdev->dev.parent;
dev->input = input;
input->name = pdev->name;
input->phys = "adp5520-keys/input0";
input->dev.parent = &pdev->dev;
input_set_drvdata(input, dev);
input->id.bustype = BUS_I2C;
input->id.vendor = 0x0001;
input->id.product = 0x5520;
input->id.version = 0x0001;
input->keycodesize = sizeof(dev->keycode[0]);
input->keycodemax = pdata->keymapsize;
input->keycode = dev->keycode;
memcpy(dev->keycode, pdata->keymap,
pdata->keymapsize * input->keycodesize);
/* setup input device */
__set_bit(EV_KEY, input->evbit);
if (pdata->repeat)
__set_bit(EV_REP, input->evbit);
for (i = 0; i < input->keycodemax; i++)
__set_bit(dev->keycode[i], input->keybit);
__clear_bit(KEY_RESERVED, input->keybit);
ret = input_register_device(input);
if (ret) {
dev_err(&pdev->dev, "unable to register input device\n");
goto err;
}
en_mask = pdata->rows_en_mask | pdata->cols_en_mask;
ret = adp5520_set_bits(dev->master, ADP5520_GPIO_CFG_1, en_mask);
if (en_mask & ADP5520_COL_C3)
ctl_mask |= ADP5520_C3_MODE;
if (en_mask & ADP5520_ROW_R3)
ctl_mask |= ADP5520_R3_MODE;
if (ctl_mask)
ret |= adp5520_set_bits(dev->master, ADP5520_LED_CONTROL,
ctl_mask);
ret |= adp5520_set_bits(dev->master, ADP5520_GPIO_PULLUP,
pdata->rows_en_mask);
if (ret) {
dev_err(&pdev->dev, "failed to write\n");
ret = -EIO;
goto err1;
}
dev->notifier.notifier_call = adp5520_keys_notifier;
ret = adp5520_register_notifier(dev->master, &dev->notifier,
ADP5520_KP_IEN | ADP5520_KR_IEN);
if (ret) {
dev_err(&pdev->dev, "failed to register notifier\n");
goto err1;
}
platform_set_drvdata(pdev, dev);
return 0;
err1:
input_unregister_device(input);
input = NULL;
err:
input_free_device(input);
kfree(dev);
return ret;
}
static int
othc_configure_hsed(struct pm8058_othc *dd, struct platform_device *pd)
{
int rc;
struct input_dev *ipd;
struct pmic8058_othc_config_pdata *pdata = pd->dev.platform_data;
struct othc_hsed_config *hsed_config = pdata->hsed_config;
dd->othc_sdev.name = "pm8058-h2w";
dd->othc_sdev.print_name = othc_headset_print_name;
rc = switch_dev_register(&dd->othc_sdev);
if (rc) {
pr_err("Unable to register switch device\n");
return rc;
}
ipd = input_allocate_device();
if (ipd == NULL) {
pr_err("Unable to allocate memory\n");
rc = -ENOMEM;
goto fail_input_alloc;
}
/* Get the IRQ for Headset Insert-remove and Switch-press */
dd->othc_irq_sw = platform_get_irq(pd, 0);
dd->othc_irq_ir = platform_get_irq(pd, 1);
if (dd->othc_irq_ir < 0 || dd->othc_irq_sw < 0) {
pr_err("othc resource:IRQs absent\n");
rc = -ENXIO;
goto fail_micbias_config;
}
if (pdata->hsed_name != NULL)
ipd->name = pdata->hsed_name;
else
ipd->name = "pmic8058_othc";
ipd->phys = "pmic8058_othc/input0";
ipd->dev.parent = &pd->dev;
dd->othc_ipd = ipd;
dd->othc_sw_state = false;
dd->switch_debounce_ms = hsed_config->switch_debounce_ms;
dd->othc_support_n_switch = hsed_config->othc_support_n_switch;
dd->accessory_support = pdata->hsed_config->accessories_support;
dd->detection_delay_ms = pdata->hsed_config->detection_delay_ms;
if (dd->othc_support_n_switch == true)
dd->switch_config = hsed_config->switch_config;
if (dd->accessory_support == true) {
dd->accessory_info = pdata->hsed_config->accessories;
dd->num_accessories = pdata->hsed_config->othc_num_accessories;
dd->accessories_adc_support =
pdata->hsed_config->accessories_adc_support;
dd->accessories_adc_channel =
pdata->hsed_config->accessories_adc_channel;
dd->video_out_gpio = pdata->hsed_config->video_out_gpio;
}
/* Configure the MIC_BIAS line for headset detection */
rc = pm8058_configure_micbias(dd);
if (rc < 0)
goto fail_micbias_config;
/* Configure for the switch events */
rc = pm8058_configure_switch(dd);
if (rc < 0)
goto fail_micbias_config;
/* Configure the accessory */
if (dd->accessory_support == true) {
rc = pm8058_configure_accessory(dd);
if (rc < 0)
goto fail_micbias_config;
}
input_set_drvdata(ipd, dd);
spin_lock_init(&dd->lock);
rc = input_register_device(ipd);
if (rc) {
pr_err("Unable to register OTHC device\n");
goto fail_micbias_config;
}
hrtimer_init(&dd->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
dd->timer.function = pm8058_othc_timer;
INIT_DELAYED_WORK(&dd->detect_work, detect_work_f);
if (dd->othc_support_n_switch == true)
INIT_WORK(&dd->switch_work, switch_work_f);
/* Request the HEADSET IR interrupt */
rc = request_threaded_irq(dd->othc_irq_ir, NULL, pm8058_nc_ir,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_DISABLED,
"pm8058_othc_ir", dd);
if (rc < 0) {
pr_err("Unable to request pm8058_othc_ir IRQ\n");
goto fail_ir_irq;
}
/* Request the SWITCH press/release interrupt */
rc = request_threaded_irq(dd->othc_irq_sw, NULL, pm8058_no_sw,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_DISABLED,
"pm8058_othc_sw", dd);
if (rc < 0) {
pr_err("Unable to request pm8058_othc_sw IRQ\n");
goto fail_sw_irq;
}
/* Check if the accessory is already inserted during boot up */
rc = pm8058_irq_get_rt_status(dd->pm_chip, dd->othc_irq_ir);
if (rc < 0) {
pr_err("Unable to get accessory status at boot\n");
goto fail_ir_irq;
}
if (rc) {
pr_debug("Accessory inserted during boot up\n");
/* process the data and report the inserted accessory */
rc = pm8058_accessory_report(dd, 1);
if (rc)
pr_debug("Unabele to detect accessory at boot up\n");
}
device_init_wakeup(&pd->dev,
hsed_config->hsed_bias_config->othc_wakeup);
return 0;
fail_sw_irq:
free_irq(dd->othc_irq_ir, dd);
fail_ir_irq:
input_unregister_device(ipd);
dd->othc_ipd = NULL;
fail_micbias_config:
input_free_device(ipd);
fail_input_alloc:
switch_dev_unregister(&dd->othc_sdev);
return rc;
}
static void dc_mouse_disconnect(struct maple_device *dev)
{
struct input_dev *input_dev = dev->private_data;
input_unregister_device(input_dev);
}
static int gpio_event_probe(struct platform_device *pdev)
{
int err;
struct gpio_event *ip;
struct gpio_event_platform_data *event_info;
int dev_count = 1;
int i;
int registered = 0;
event_info = pdev->dev.platform_data;
if (event_info == NULL) {
pr_err("gpio_event_probe: No pdata\n");
return -ENODEV;
}
if ((!event_info->name && !event_info->names[0]) ||
!event_info->info || !event_info->info_count) {
pr_err("gpio_event_probe: Incomplete pdata\n");
return -ENODEV;
}
if (!event_info->name)
while (event_info->names[dev_count])
dev_count++;
ip = kzalloc(sizeof(*ip) +
sizeof(ip->state[0]) * event_info->info_count +
sizeof(*ip->input_devs) +
sizeof(ip->input_devs->dev[0]) * dev_count, GFP_KERNEL);
if (ip == NULL) {
err = -ENOMEM;
pr_err("gpio_event_probe: Failed to allocate private data\n");
goto err_kp_alloc_failed;
}
ip->input_devs = (void*)&ip->state[event_info->info_count];
platform_set_drvdata(pdev, ip);
for (i = 0; i < dev_count; i++) {
struct input_dev *input_dev = input_allocate_device();
if (input_dev == NULL) {
err = -ENOMEM;
pr_err("gpio_event_probe: "
"Failed to allocate input device\n");
goto err_input_dev_alloc_failed;
}
input_set_drvdata(input_dev, ip);
input_dev->name = event_info->name ?
event_info->name : event_info->names[i];
input_dev->event = gpio_input_event;
ip->input_devs->dev[i] = input_dev;
}
ip->input_devs->count = dev_count;
ip->info = event_info;
if (event_info->power)
ip->info->power(ip->info, 1);
err = gpio_event_call_all_func(ip, GPIO_EVENT_FUNC_INIT);
if (err)
goto err_call_all_func_failed;
for (i = 0; i < dev_count; i++) {
err = input_register_device(ip->input_devs->dev[i]);
if (err) {
pr_err("gpio_event_probe: Unable to register %s "
"input device\n", ip->input_devs->dev[i]->name);
goto err_input_register_device_failed;
}
registered++;
}
return 0;
err_input_register_device_failed:
gpio_event_call_all_func(ip, GPIO_EVENT_FUNC_UNINIT);
err_call_all_func_failed:
if (event_info->power)
ip->info->power(ip->info, 0);
for (i = 0; i < registered; i++)
input_unregister_device(ip->input_devs->dev[i]);
for (i = dev_count - 1; i >= registered; i--) {
input_free_device(ip->input_devs->dev[i]);
err_input_dev_alloc_failed:
;
}
kfree(ip);
err_kp_alloc_failed:
return err;
}
int ssp_sensorhub_initialize(struct ssp_data *ssp_data)
{
struct ssp_sensorhub_data *hub_data;
int ret;
/* allocate memory for sensorhub data */
hub_data = kzalloc(sizeof(*hub_data), GFP_KERNEL);
if (!hub_data) {
sensorhub_err("allocate memory for sensorhub data err");
ret = -ENOMEM;
goto exit;
}
hub_data->ssp_data = ssp_data;
ssp_data->hub_data = hub_data;
/* init wakelock, list, waitqueue, completion and spinlock */
wake_lock_init(&hub_data->sensorhub_wake_lock, WAKE_LOCK_SUSPEND,
"ssp_sensorhub_wake_lock");
init_waitqueue_head(&hub_data->sensorhub_wq);
init_completion(&hub_data->read_done);
init_completion(&hub_data->big_read_done);
init_completion(&hub_data->big_write_done);
spin_lock_init(&hub_data->sensorhub_lock);
/* allocate sensorhub input device */
hub_data->sensorhub_input_dev = input_allocate_device();
if (!hub_data->sensorhub_input_dev) {
sensorhub_err("allocate sensorhub input device err");
ret = -ENOMEM;
goto err_input_allocate_device_sensorhub;
}
/* set sensorhub input device */
input_set_drvdata(hub_data->sensorhub_input_dev, hub_data);
hub_data->sensorhub_input_dev->name = "ssp_context";
input_set_capability(hub_data->sensorhub_input_dev, EV_REL, DATA);
input_set_capability(hub_data->sensorhub_input_dev, EV_REL, BIG_DATA);
input_set_capability(hub_data->sensorhub_input_dev, EV_REL, NOTICE);
/* register sensorhub input device */
ret = input_register_device(hub_data->sensorhub_input_dev);
if (ret < 0) {
sensorhub_err("register sensorhub input device err(%d)", ret);
input_free_device(hub_data->sensorhub_input_dev);
goto err_input_register_device_sensorhub;
}
/* register sensorhub misc device */
hub_data->sensorhub_device.minor = MISC_DYNAMIC_MINOR;
hub_data->sensorhub_device.name = "ssp_sensorhub";
hub_data->sensorhub_device.fops = &ssp_sensorhub_fops;
ret = misc_register(&hub_data->sensorhub_device);
if (ret < 0) {
sensorhub_err("register sensorhub misc device err(%d)", ret);
goto err_misc_register;
}
/* allocate fifo */
ret = kfifo_alloc(&hub_data->fifo,
sizeof(void *) * LIST_SIZE, GFP_KERNEL);
if (ret) {
sensorhub_err("kfifo allocate err(%d)", ret);
goto err_kfifo_alloc;
}
/* create and run sensorhub thread */
hub_data->sensorhub_task = kthread_run(ssp_sensorhub_thread,
(void *)hub_data, "ssp_sensorhub_thread");
if (IS_ERR(hub_data->sensorhub_task)) {
ret = PTR_ERR(hub_data->sensorhub_task);
goto err_kthread_run;
}
return 0;
err_kthread_run:
kfifo_free(&hub_data->fifo);
err_kfifo_alloc:
misc_deregister(&hub_data->sensorhub_device);
err_misc_register:
input_unregister_device(hub_data->sensorhub_input_dev);
err_input_register_device_sensorhub:
err_input_allocate_device_sensorhub:
complete_all(&hub_data->big_write_done);
complete_all(&hub_data->big_read_done);
complete_all(&hub_data->read_done);
wake_lock_destroy(&hub_data->sensorhub_wake_lock);
kfree(hub_data);
exit:
return ret;
}
int __init x3_power_late_init(void)
{
int irq;
int ret;
if(is_tegra_bootmode())
{
irq = max7763_pdata.irq_base + MAX77663_IRQ_ONOFF_HRDPOWRN;
ret = request_threaded_irq(irq , NULL, max77663_irq_manualreset_warning,
IRQF_ONESHOT, "MAX77663_IRQ_ONOFF_HRDPOWRN",
NULL);
if (ret) {
pr_err("%s: Failed to request irq %d\n", __func__, irq);
return ret;
}
}
#if defined(CONFIG_PMIC_POWERKEY)
max77663_pwrkey = input_allocate_device();
if (!max77663_pwrkey) {
pr_err("%s: Failed to allocate input device for power key\n",
__func__);
return -ENOMEM;
}
max77663_pwrkey->evbit[0] = BIT_MASK(EV_KEY);
set_bit(KEY_POWER, max77663_pwrkey->keybit);
max77663_pwrkey->name = "max77663-pwrkey";
ret = input_register_device(max77663_pwrkey);
if (ret) {
pr_err("%s: Failed to register input device for power key\n",
__func__);
goto out_free_device;
}
irq = max7763_pdata.irq_base + MAX77663_IRQ_ONOFF_EN0_FALLING;
ret = request_threaded_irq(irq , NULL, max77663_irq_en0_falling,
IRQF_ONESHOT, "max77663-en0-falling",
max77663_pwrkey);
if (ret) {
pr_err("%s: Failed to request irq %d\n", __func__, irq);
goto out_unregister_device;
}
irq = max7763_pdata.irq_base + MAX77663_IRQ_ONOFF_EN0_RISING;
ret = request_threaded_irq(irq , NULL, max77663_irq_en0_rising,
IRQF_ONESHOT, "max77663-en0-rising",
max77663_pwrkey);
if (ret) {
pr_err("%s: Failed to request irq %d\n", __func__, irq);
goto out_free_irq;
}
return 0;
out_free_irq:
irq = max7763_pdata.irq_base + MAX77663_IRQ_ONOFF_EN0_FALLING;
free_irq(irq, max77663_pwrkey);
out_unregister_device:
input_unregister_device(max77663_pwrkey);
max77663_pwrkey = NULL;
out_free_device:
if (max77663_pwrkey)
input_free_device(max77663_pwrkey);
return ret;
#endif
}
void mtk_ir_mouse_unregister_input(struct input_dev *dev)
{
ASSERT(dev != NULL);
input_unregister_device(dev);
IR_LOG_ALWAYS("success\n");
}
static int wacom_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct wacom_g5_platform_data *pdata = client->dev.platform_data;
struct wacom_i2c *wac_i2c;
struct input_dev *input;
int ret = 0;
if (pdata == NULL) {
printk(KERN_ERR "%s: no pdata\n", __func__);
ret = -ENODEV;
goto err_i2c_fail;
}
/*Check I2C functionality */
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
printk(KERN_ERR "[E-PEN] No I2C functionality found\n");
ret = -ENODEV;
goto err_i2c_fail;
}
/*Obtain kernel memory space for wacom i2c */
wac_i2c = kzalloc(sizeof(struct wacom_i2c), GFP_KERNEL);
if (NULL == wac_i2c) {
printk(KERN_ERR "[E-PEN] failed to allocate wac_i2c.\n");
ret = -ENOMEM;
goto err_freemem;
}
input = input_allocate_device();
if (NULL == input) {
printk(KERN_ERR "[E-PEN] failed to allocate input device.\n");
ret = -ENOMEM;
goto err_input_allocate_device;
} else
wacom_i2c_set_input_values(client, wac_i2c, input);
wac_i2c->wac_feature = &wacom_feature_EMR;
wac_i2c->wac_pdata = pdata;
wac_i2c->input_dev = input;
wac_i2c->client = client;
wac_i2c->irq = client->irq;
/*Change below if irq is needed */
wac_i2c->irq_flag = 1;
/*Register callbacks */
wac_i2c->callbacks.check_prox = wacom_check_emr_prox;
if (wac_i2c->wac_pdata->register_cb)
wac_i2c->wac_pdata->register_cb(&wac_i2c->callbacks);
/* Firmware Feature */
wacom_i2c_init_firm_data();
#if defined(CONFIG_MACH_Q1_BD)
/* Change Origin offset by rev */
if (system_rev < 6) {
origin_offset[0] = origin_offset_48[0];
origin_offset[1] = origin_offset_48[1];
}
/* Reset IC */
wacom_i2c_reset_hw(wac_i2c->wac_pdata);
#endif
ret = wacom_i2c_query(wac_i2c);
if (ret < 0)
epen_reset_result = false;
else
epen_reset_result = true;
INIT_WORK(&wac_i2c->update_work, update_work_func);
#if defined(CONFIG_MACH_P4)
if (pdata->xy_switch) {
input_set_abs_params(input, ABS_X, WACOM_POSY_OFFSET,
wac_i2c->wac_feature->y_max, 4, 0);
input_set_abs_params(input, ABS_Y, WACOM_POSX_OFFSET,
wac_i2c->wac_feature->x_max, 4, 0);
} else {
input_set_abs_params(input, ABS_X, WACOM_POSX_OFFSET,
wac_i2c->wac_feature->x_max, 4, 0);
input_set_abs_params(input, ABS_Y, WACOM_POSY_OFFSET,
wac_i2c->wac_feature->y_max, 4, 0);
}
input_set_abs_params(input, ABS_PRESSURE, 0,
wac_i2c->wac_feature->pressure_max, 0, 0);
#else
input_set_abs_params(wac_i2c->input_dev, ABS_X, pdata->min_x,
pdata->max_x, 4, 0);
input_set_abs_params(wac_i2c->input_dev, ABS_Y, pdata->min_y,
pdata->max_y, 4, 0);
input_set_abs_params(wac_i2c->input_dev, ABS_PRESSURE,
pdata->min_pressure, pdata->max_pressure, 0, 0);
#endif
input_set_drvdata(input, wac_i2c);
/*Before registering input device, data in each input_dev must be set */
ret = input_register_device(input);
if (ret) {
pr_err("[E-PEN] failed to register input device.\n");
goto err_register_device;
}
/*Change below if irq is needed */
wac_i2c->irq_flag = 1;
/*Set client data */
i2c_set_clientdata(client, wac_i2c);
/*Initializing for semaphor */
mutex_init(&wac_i2c->lock);
INIT_DELAYED_WORK(&wac_i2c->resume_work, wacom_i2c_resume_work);
/*Request IRQ */
if (wac_i2c->irq_flag) {
ret =
request_threaded_irq(wac_i2c->irq, NULL, wacom_interrupt,
IRQF_DISABLED | IRQF_TRIGGER_RISING |
IRQF_ONESHOT, wac_i2c->name, wac_i2c);
if (ret < 0) {
printk(KERN_ERR
"[E-PEN]: failed to request irq(%d) - %d\n",
wac_i2c->irq, ret);
goto err_request_irq;
}
}
#ifdef CONFIG_HAS_EARLYSUSPEND
wac_i2c->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
wac_i2c->early_suspend.suspend = wacom_i2c_early_suspend;
wac_i2c->early_suspend.resume = wacom_i2c_late_resume;
register_early_suspend(&wac_i2c->early_suspend);
#endif
wac_i2c->dev = device_create(sec_class, NULL, 0, NULL, "sec_epen");
if (IS_ERR(wac_i2c->dev))
printk(KERN_ERR "Failed to create device(wac_i2c->dev)!\n");
else {
dev_set_drvdata(wac_i2c->dev, wac_i2c);
ret = sysfs_create_group(&wac_i2c->dev->kobj, &epen_attr_group);
if (ret) {
printk(KERN_ERR
"[E-PEN]: failed to create sysfs group\n");
goto err_sysfs_create_group;
}
}
#if defined(CONFIG_MACH_P4)
if (Firmware_version_of_file > wac_i2c->wac_feature->fw_version) {
/* the firmware should be updated only 4.8pitch panel */
if (0x107 != wac_i2c->wac_feature->fw_version)
schedule_work(&wac_i2c->update_work);
}
#elif defined(CONFIG_MACH_Q1_BD)
/* firmware info */
printk(KERN_NOTICE "[E-PEN] wacom fw ver : 0x%x, new fw ver : 0x%x\n",
wac_i2c->wac_feature->fw_version, Firmware_version_of_file);
#endif
#ifdef CONFIG_SEC_TOUCHSCREEN_DVFS_LOCK
INIT_DELAYED_WORK(&wac_i2c->dvfs_work, free_dvfs_lock);
if (exynos_cpufreq_get_level(800000, &wac_i2c->cpufreq_level))
printk(KERN_ERR "[E-PEN] exynos_cpufreq_get_level Error\n");
#ifdef SEC_BUS_LOCK
wac_i2c->bus_dev = dev_get("exynos-busfreq");
#endif
#endif
return 0;
err_sysfs_create_group:
free_irq(wac_i2c->irq, wac_i2c);
err_request_irq:
err_register_device:
input_unregister_device(input);
input = NULL;
err_input_allocate_device:
input_free_device(input);
err_freemem:
kfree(wac_i2c);
err_i2c_fail:
return ret;
}
static int gpio_event_probe(struct platform_device *pdev)
{
int err;
struct gpio_event *ip;
struct gpio_event_platform_data *event_info;
int dev_count = 1;
int i;
int registered = 0;
event_info = pdev->dev.platform_data;
if (event_info == NULL) {
pr_err("gpio_event_probe: No pdata\n");
return -ENODEV;
}
if ((!event_info->name && !event_info->names[0]) ||
!event_info->info || !event_info->info_count) {
pr_err("gpio_event_probe: Incomplete pdata\n");
return -ENODEV;
}
if (!event_info->name)
while (event_info->names[dev_count])
dev_count++;
ip = kzalloc(sizeof(*ip) +
sizeof(ip->state[0]) * event_info->info_count +
sizeof(*ip->input_devs) +
sizeof(ip->input_devs->dev[0]) * dev_count, GFP_KERNEL);
if (ip == NULL) {
err = -ENOMEM;
pr_err("gpio_event_probe: Failed to allocate private data\n");
goto err_kp_alloc_failed;
}
ip->input_devs = (void*)&ip->state[event_info->info_count];
platform_set_drvdata(pdev, ip);
for (i = 0; i < dev_count; i++) {
struct input_dev *input_dev = input_allocate_device();
if (input_dev == NULL) {
err = -ENOMEM;
pr_err("gpio_event_probe: "
"Failed to allocate input device\n");
goto err_input_dev_alloc_failed;
}
input_set_drvdata(input_dev, ip);
input_dev->name = event_info->name ?
event_info->name : event_info->names[i];
input_dev->event = gpio_input_event;
ip->input_devs->dev[i] = input_dev;
#ifdef CONFIG_TOUCHSCREEN_SYNAPTICS_SWEEP2WAKE
if (!strcmp(input_dev->name, "keypad_8960")) {
sweep2wake_setdev(input_dev);
printk(KERN_INFO "[sweep2wake]: set device %s\n", input_dev->name);
}
#endif
}
ip->input_devs->count = dev_count;
ip->info = event_info;
if (event_info->power) {
#ifdef CONFIG_HAS_EARLYSUSPEND
ip->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
ip->early_suspend.suspend = gpio_event_suspend;
ip->early_suspend.resume = gpio_event_resume;
register_early_suspend(&ip->early_suspend);
#endif
ip->info->power(ip->info, 1);
}
err = gpio_event_call_all_func(ip, GPIO_EVENT_FUNC_INIT);
if (err)
goto err_call_all_func_failed;
for (i = 0; i < dev_count; i++) {
err = input_register_device(ip->input_devs->dev[i]);
if (err) {
pr_err("gpio_event_probe: Unable to register %s "
"input device\n", ip->input_devs->dev[i]->name);
goto err_input_register_device_failed;
}
registered++;
}
return 0;
err_input_register_device_failed:
gpio_event_call_all_func(ip, GPIO_EVENT_FUNC_UNINIT);
err_call_all_func_failed:
if (event_info->power) {
#ifdef CONFIG_HAS_EARLYSUSPEND
unregister_early_suspend(&ip->early_suspend);
#endif
ip->info->power(ip->info, 0);
}
for (i = 0; i < registered; i++)
input_unregister_device(ip->input_devs->dev[i]);
for (i = dev_count - 1; i >= registered; i--) {
input_free_device(ip->input_devs->dev[i]);
err_input_dev_alloc_failed:
;
}
kfree(ip);
err_kp_alloc_failed:
return err;
}
static int mma7660_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
struct mma7660_data *mma7660;
int err;
dprint("l=%d,%s:\n",__LINE__, __func__);
Xaverage = Yaverage = Zaverage = RawDataNum = 0;
mma7660 = kzalloc(sizeof(struct mma7660_data), GFP_KERNEL);
if (!mma7660) {
rk28printk("[mma7660]:alloc data failed.\n");
err = -ENOMEM;
goto exit_alloc_data_failed;
}
INIT_WORK(&mma7660->work, mma7660_work_func);
INIT_DELAYED_WORK(&mma7660->delaywork, mma7660_delaywork_func);
mma7660->client = client;
//mma7660->swap_xy =
i2c_set_clientdata(client, mma7660);
this_client = client;
err = mma7660_init_client(client);
if (err < 0) {
rk28printk(KERN_ERR
"mma7660_probe: mma7660_init_client failed\n");
goto exit_request_gpio_irq_failed;
}
mma7660->input_dev = input_allocate_device();
if (!mma7660->input_dev) {
err = -ENOMEM;
rk28printk(KERN_ERR
"mma7660_probe: Failed to allocate input device\n");
goto exit_input_allocate_device_failed;
}
set_bit(EV_ABS, mma7660->input_dev->evbit);
/* x-axis acceleration */
input_set_abs_params(mma7660->input_dev, ABS_X, -1500, 1500, 0, 0);
/* y-axis acceleration */
input_set_abs_params(mma7660->input_dev, ABS_Y, -1500, 1500, 0, 0);
/* z-axis acceleration */
input_set_abs_params(mma7660->input_dev, ABS_Z, -1500, 1500, 0, 0);
mma7660->input_dev->name = "gsensor";
mma7660->input_dev->dev.parent = &client->dev;
err = input_register_device(mma7660->input_dev);
if (err < 0) {
rk28printk(KERN_ERR
"mma7660_probe: Unable to register input device: %s\n",
mma7660->input_dev->name);
goto exit_input_register_device_failed;
}
mma7660_device.parent = &client->dev;
err = misc_register(&mma7660_device);
if (err < 0) {
rk28printk(KERN_ERR
"mma7660_probe: mmad_device register failed\n");
goto exit_misc_device_register_mma7660_device_failed;
}
err = gsensor_sysfs_init();
if (err < 0) {
rk28printk(KERN_ERR
"mma7660_probe: gsensor sysfs init failed\n");
goto exit_gsensor_sysfs_init_failed;
}
#ifdef CONFIG_ANDROID_POWER
mma7660_early_suspend.suspend = mma7660_suspend;
mma7660_early_suspend.resume = mma7660_resume;
mma7660_early_suspend.level = 0x2;
android_register_early_suspend(&mma7660_early_suspend);
#endif
rk28printk(KERN_INFO "mma7660 probe ok\n");
mma7660->status = -1;
#if 0
mma7660_start(client, MMA7660_RATE_32);
#endif
dprint("l=%d,%s:loaded successfully.\n",__LINE__, __func__);
return 0;
exit_gsensor_sysfs_init_failed:
misc_deregister(&mma7660_device);
exit_misc_device_register_mma7660_device_failed:
input_unregister_device(mma7660->input_dev);
exit_input_register_device_failed:
input_free_device(mma7660->input_dev);
exit_input_allocate_device_failed:
free_irq(client->irq, mma7660);
exit_request_gpio_irq_failed:
kfree(mma7660);
exit_alloc_data_failed:
;
return err;
}
static int gpio_shortlong_key_probe(struct platform_device *pdev)
{
struct gpio_shortlong_key_ctx *ctx;
struct gpio_shortlong_key_platform_data *pdata = pdev->dev.platform_data;
if (pdata == NULL) {
dev_err(&pdev->dev,"no platform data\n");
return -EINVAL;
}
ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
if (ctx == NULL) {
dev_err(&pdev->dev, "can't allocate context\n");
return -ENOMEM;
}
ctx->master = pdev->dev.parent;
ctx->gpio = pdata->gpio; /* gpio to use to detect long presses */
ctx->active_low = pdata->active_low; /* if key is active low */
ctx->short_press_keycode = pdata->short_press_keycode; /* short press key code */
ctx->long_press_keycode = pdata->long_press_keycode; /* long press key code */
ctx->debounce_time = (pdata->debounce_time < 20) ? 1 : (pdata->debounce_time / 20); /* time to recognize at least a short press in ticks*/
ctx->long_press_time = (pdata->long_press_time < 20) ? 1 : (pdata->long_press_time / 20); /* time to recognize a long press in ticks */
ctx->button_dev = input_allocate_device();
if (!ctx->button_dev) {
kfree(ctx);
dev_err(&pdev->dev, "can't allocate input device\n");
return -ENOMEM;
}
set_bit(EV_KEY,ctx->button_dev->evbit) ;
set_bit(ctx->short_press_keycode,ctx->button_dev->keybit) ;
set_bit(ctx->long_press_keycode,ctx->button_dev->keybit) ;
input_set_drvdata(ctx->button_dev, ctx);
ctx->button_dev->name = pdev->name;
ctx->button_dev->phys = "gpio-shortlong-keys/input0";
ctx->button_dev->dev.parent = &pdev->dev;
ctx->button_dev->id.bustype = BUS_HOST;
ctx->button_dev->id.vendor = 0x0001;
ctx->button_dev->id.product = 0x0001;
ctx->button_dev->id.version = 0x0100;
if (input_register_device(ctx->button_dev)) {
dev_err(&pdev->dev, "Failed to register input device\n");
input_free_device(ctx->button_dev);
kfree(ctx);
return -ENOMEM;
}
gpio_request(ctx->gpio, "short-long-press key") ;
gpio_direction_input(ctx->gpio) ;
init_timer(&ctx->timer) ;
ctx->timer.function = &gpio_shortlong_key_timerhandler;
ctx->timer.expires = jiffies - 1;
ctx->timer.data = (unsigned long) ctx;
add_timer(&ctx->timer) ;
if (request_irq( gpio_to_irq(ctx->gpio),
gpio_shortlong_key_isr,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
"short-long-press key",
ctx))
{
dev_err(&pdev->dev, "Failed to get interrupt\n");
gpio_free(ctx->gpio);
input_unregister_device(ctx->button_dev) ;
free_irq(gpio_to_irq(ctx->gpio), NULL);
kfree(ctx);
return -ENXIO;
}
platform_set_drvdata(pdev, ctx);
dev_info(&pdev->dev, "Started\n");
return 0;
}
static int htc_headset_mgr_probe(struct platform_device *pdev)
{
int ret;
struct htc_headset_mgr_platform_data *pdata = pdev->dev.platform_data;
HS_LOG("++++++++++++++++++++");
hi = kzalloc(sizeof(struct htc_headset_mgr_info), GFP_KERNEL);
if (!hi)
return -ENOMEM;
hi->pdata.driver_flag = pdata->driver_flag;
hi->pdata.headset_devices_num = pdata->headset_devices_num;
hi->pdata.headset_devices = pdata->headset_devices;
hi->pdata.hptv_det_hp_gpio = pdata->hptv_det_hp_gpio;
hi->pdata.hptv_det_tv_gpio = pdata->hptv_det_tv_gpio;
hi->pdata.hptv_sel_gpio = pdata->hptv_sel_gpio;
hi->driver_init_seq = 0;
wake_lock_init(&hi->hs_wake_lock, WAKE_LOCK_SUSPEND, DRIVER_NAME);
hi->hpin_jiffies = jiffies;
hi->usb_headset.type = USB_NO_HEADSET;
hi->usb_headset.status = STATUS_DISCONNECTED;
hi->ext_35mm_status = HTC_35MM_UNPLUG;
hi->h2w_35mm_status = HTC_35MM_UNPLUG;
hi->is_ext_insert = 0;
hi->mic_bias_state = 0;
hi->mic_detect_counter = 0;
hi->key_level_flag = -1;
atomic_set(&hi->btn_state, 0);
hi->tty_enable_flag = 0;
hi->fm_flag = 0;
hi->debug_flag = 0;
mutex_init(&hi->mutex_lock);
hi->sdev.name = "h2w";
hi->sdev.print_name = h2w_print_name;
ret = switch_dev_register(&hi->sdev);
if (ret < 0)
goto err_switch_dev_register;
detect_wq = create_workqueue("detect");
if (detect_wq == NULL) {
ret = -ENOMEM;
HS_ERR("Failed to create detect workqueue");
goto err_create_detect_work_queue;
}
button_wq = create_workqueue("button");
if (button_wq == NULL) {
ret = -ENOMEM;
HS_ERR("Failed to create button workqueue");
goto err_create_button_work_queue;
}
hi->input = input_allocate_device();
if (!hi->input) {
ret = -ENOMEM;
goto err_request_input_dev;
}
hi->input->name = "h2w headset";
set_bit(EV_SYN, hi->input->evbit);
set_bit(EV_KEY, hi->input->evbit);
set_bit(KEY_END, hi->input->keybit);
set_bit(KEY_MUTE, hi->input->keybit);
set_bit(KEY_VOLUMEDOWN, hi->input->keybit);
set_bit(KEY_VOLUMEUP, hi->input->keybit);
set_bit(KEY_NEXTSONG, hi->input->keybit);
set_bit(KEY_PLAYPAUSE, hi->input->keybit);
set_bit(KEY_PREVIOUSSONG, hi->input->keybit);
set_bit(KEY_MEDIA, hi->input->keybit);
set_bit(KEY_SEND, hi->input->keybit);
ret = input_register_device(hi->input);
if (ret < 0)
goto err_register_input_dev;
ret = register_attributes();
if (ret)
goto err_register_attributes;
if (hi->pdata.driver_flag & DRIVER_HS_MGR_RPC_SERVER) {
/* Create RPC server */
ret = msm_rpc_create_server(&hs_rpc_server);
if (ret < 0) {
HS_ERR("Failed to create RPC server");
goto err_create_rpc_server;
}
HS_LOG("Create RPC server successfully");
}
headset_mgr_init();
hs_notify_driver_ready(DRIVER_NAME);
HS_LOG("--------------------");
return 0;
err_create_rpc_server:
err_register_attributes:
input_unregister_device(hi->input);
err_register_input_dev:
input_free_device(hi->input);
err_request_input_dev:
destroy_workqueue(button_wq);
err_create_button_work_queue:
destroy_workqueue(detect_wq);
err_create_detect_work_queue:
switch_dev_unregister(&hi->sdev);
err_switch_dev_register:
mutex_destroy(&hi->mutex_lock);
wake_lock_destroy(&hi->hs_wake_lock);
kfree(hi);
HS_ERR("Failed to register %s driver", DRIVER_NAME);
return ret;
}
static int bma2x2_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int err = 0;
int tempvalue;
unsigned char tmp_chip_id;
#if defined(BMA2X2_ENABLE_INT1) || defined(BMA2X2_ENABLE_INT2)
unsigned int irq_gpio_flags;
#endif
struct bma2x2_data *data;
struct input_dev *dev;
struct bst_dev *dev_acc;
struct bma2x2_regulator_data *regdata = &bma2x2_regu_data;
dev_info(&client->dev, "%s: BMA2x2 start probing.\n", __func__);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
dev_info(&client->dev, "i2c_check_functionality error\n");
goto exit;
}
data = kzalloc(sizeof(struct bma2x2_data), GFP_KERNEL);
if (!data) {
err = -ENOMEM;
goto exit;
}
#if defined(BMA2X2_ENABLE_INT1) || defined(BMA2X2_ENABLE_INT2)
data->irq_gpio = of_get_named_gpio_flags(client->dev.of_node,
"bma2x2,irq_gpio", 0, &irq_gpio_flags);
if (data->irq_gpio < 0) {
dev_err(&client->dev,
"%s: negative gpio number ", __func__);
err = -EIO;
goto kfree_exit;
}
err = gpio_request(data->irq_gpio, SENSOR_NAME);
if (err) {
dev_err(&client->dev, "%s: gpio_request failed, err=%d\n",
__func__, err);
goto kfree_exit;
}
#endif
/* init regulator */
regdata->reg_vdd = NULL;
regdata->reg_vio = NULL;
regdata->id_vdd = "bma2x2_vdd";
regdata->id_vio = "bma2x2_vio";
bma2x2_regulator_init(&client->dev);
/* power on */
bma2x2_regulator_control(1, &client->dev);
/* read chip id */
tempvalue = i2c_smbus_read_word_data(client, BMA2X2_CHIP_ID_REG);
tmp_chip_id = tempvalue&0x00ff;
switch (tmp_chip_id) {
case BMA255_CHIP_ID:
data->sensor_type = BMA255_TYPE;
break;
case BMA250E_CHIP_ID:
data->sensor_type = BMA250E_TYPE;
break;
case BMA222E_CHIP_ID:
data->sensor_type = BMA222E_TYPE;
break;
case BMA280_CHIP_ID:
data->sensor_type = BMA280_TYPE;
break;
default:
data->sensor_type = -1;
}
if (data->sensor_type != -1) {
data->chip_id = tmp_chip_id;
dev_info(&client->dev, "Bosch Sensortec Device detected!\n" \
"%s registered I2C driver!\n", \
sensor_name[data->sensor_type]);
} else{
dev_info(&client->dev, "Bosch Sensortec Device not found" \
"i2c error %d\n", tempvalue);
err = -ENODEV;
goto kfree_exit;
}
i2c_set_clientdata(client, data);
data->bma2x2_client = client;
mutex_init(&data->value_mutex);
mutex_init(&data->mode_mutex);
mutex_init(&data->enable_mutex);
bma2x2_set_bandwidth(client, BMA2X2_BW_SET);
if (bma2x2_set_range(client, BMA2X2_RANGE_SET) < 0)
dev_err(&client->dev, "%s: bma2x2_set_range failed\n",
__func__);
#if defined(BMA2X2_ENABLE_INT1) || defined(BMA2X2_ENABLE_INT2)
#ifdef BMA2X2_ENABLE_INT1
/* maps interrupt to INT1 pin */
#ifdef CONFIG_BMA_ENABLE_NEWDATA_INT
bma2x2_set_newdata(client, BMA2X2_INT1_NDATA, 1);
bma2x2_set_newdata(client, BMA2X2_INT2_NDATA, 0);
#endif
#endif
#ifdef BMA2X2_ENABLE_INT2
/* maps interrupt to INT2 pin */
#ifdef CONFIG_BMA_ENABLE_NEWDATA_INT
bma2x2_set_newdata(client, BMA2X2_INT1_NDATA, 0);
bma2x2_set_newdata(client, BMA2X2_INT2_NDATA, 1);
#endif
#endif
bma2x2_set_Int_Mode(client, 1);/*latch interrupt 250ms*/
data->IRQ = client->irq;
err = request_threaded_irq(data->IRQ, NULL, bma2x2_interrupt_thread,
IRQF_TRIGGER_RISING, "bma_int", data);
if (err)
dev_err(&client->dev, "could not request irq\n");
disable_irq(data->IRQ);
#endif
#ifndef CONFIG_BMA_ENABLE_NEWDATA_INT
INIT_DELAYED_WORK(&data->work, bma2x2_work_func);
#endif
atomic_set(&data->delay, BMA2X2_MAX_DELAY);
atomic_set(&data->enable, 0);
bma2x2_set_mode(client, BMA2X2_MODE_SUSPEND);
dev = input_allocate_device();
if (!dev) {
err = -ENOMEM;
goto kfree_exit;
}
dev->name = SENSOR_NAME;
dev->id.bustype = BUS_I2C;
input_set_capability(dev, EV_MSC, ABS_MISC);
input_set_capability(dev, EV_MSC, MSC_RX);
input_set_capability(dev, EV_MSC, MSC_RY);
input_set_capability(dev, EV_MSC, MSC_RZ);
input_set_drvdata(dev, data);
err = input_register_device(dev);
if (err < 0) {
input_free_device(dev);
goto kfree_exit;
}
data->input = dev;
dev_acc = bst_allocate_device();
if (!dev_acc) {
err = -ENOMEM;
goto error_sysfs;
}
dev_acc->name = ACC_NAME;
bst_set_drvdata(dev_acc, data);
err = bst_register_device(dev_acc);
if (err < 0)
goto bst_free_acc_exit;
data->bst_acc = dev_acc;
err = sysfs_create_group(&data->bst_acc->dev.kobj,
&bma2x2_attribute_group);
if (err < 0)
goto bst_free_exit;
return 0;
bst_free_exit:
(void)bst_unregister_device(dev_acc);
bst_free_acc_exit:
bst_free_device(dev_acc);
error_sysfs:
input_unregister_device(data->input);
kfree_exit:
#if defined(BMA2X2_ENABLE_INT1) || defined(BMA2X2_ENABLE_INT2)
if (NULL != data)
gpio_free(data->irq_gpio);
#endif
if ((NULL != data) && (NULL != data->bst_pd)) {
kfree(data->bst_pd);
data->bst_pd = NULL;
}
kfree(data);
exit:
return err;
}
void fdtv_unregister_rc(struct firedtv *fdtv)
{
cancel_work_sync(&fdtv->remote_ctrl_work);
kfree(fdtv->remote_ctrl_dev->keycode);
input_unregister_device(fdtv->remote_ctrl_dev);
}
static int __init tegra_onetouch_probe(struct platform_device *pdev)
{
struct tegra_onetouch_driver_data *onetouch = NULL;
struct input_dev *input_dev = NULL;
int err;
// NvOdmTouchCapabilities *caps;
printk("[ONETOUCH] tegra_onetouch_probe start\n");
onetouch = kzalloc(sizeof(struct tegra_onetouch_driver_data), GFP_KERNEL);
input_dev = input_allocate_device();
if (input_dev == NULL || onetouch == NULL) {
input_free_device(input_dev);
kfree(onetouch);
err = -ENOMEM;
pr_err("tegra_onetouch_probe: Failed to allocate input device\n");
return err;
}
onetouch->semaphore = NvOdmOsSemaphoreCreate(0);
if (!onetouch->semaphore) {
err = -1;
pr_err("tegra_onetouch_probe: Semaphore creation failed\n");
goto err_semaphore_create_failed;
}
// 20100423 [email protected] for Touch Interrupt Issue at booting [START]
#ifdef FEATURE_LGE_TOUCH_CUSTOMIZE
onetouch->bPollingMode = NV_FALSE;
if (!NvOdmOneTouchDeviceOpen(&onetouch->hOneTouchDevice, &onetouch->semaphore)) {
err = -1;
pr_err("tegra_onetouch_probe: NvOdmOneTouchDeviceOpen failed\n");
goto err_open_failed;
}
#else
if (!NvOdmOneTouchDeviceOpen(&onetouch->hOneTouchDevice)) {
err = -1;
pr_err("tegra_onetouch_probe: NvOdmOneTouchDeviceOpen failed\n");
goto err_open_failed;
}
onetouch->bPollingMode = NV_FALSE;
if (!NvOdmTouchEnableInterrupt(onetouch->hOneTouchDevice, onetouch->semaphore)) {
err = -1;
pr_err("tegra_onetouch_probe: Interrupt failed, polling mode\n");
onetouch->bPollingMode = NV_TRUE;
onetouch->pollingIntervalMS = 10;
}
#endif /* FEATURE_LGE_TOUCH_CUSTOMIZE */
// 20100423 [email protected] for Touch Interrupt Issue at booting [END]
onetouch->task =
kthread_create(tegra_onetouch_thread, onetouch, "tegra_onetouch_thread");
if(onetouch->task == NULL) {
err = -1;
goto err_kthread_create_failed;
}
wake_up_process( onetouch->task );
onetouch->input_dev = input_dev;
onetouch->input_dev->name = NVODM_TOUCH_NAME;
/* Will generate sync at the end of all input */
set_bit(EV_SYN, onetouch->input_dev->evbit);
/* Event is key input type */
set_bit(EV_KEY, onetouch->input_dev->evbit);
/* virtual key is BTN_TOUCH */
set_bit(BTN_TOUCH, onetouch->input_dev->keybit);
set_bit(KEY_MENU, onetouch->input_dev->keybit);
// set_bit(KEY_HOME, onetouch->input_dev->keybit);
set_bit(KEY_BACK, onetouch->input_dev->keybit);
// set_bit(KEY_SEARCH, onetouch->input_dev->keybit);
set_bit(KEY_REJECT, onetouch->input_dev->keybit);
platform_set_drvdata(pdev, onetouch);
err = input_register_device(input_dev);
if (err)
{
pr_err("tegra_onetouch_probe: Unable to register input device\n");
goto err_input_register_device_failed;
}
#ifdef CONFIG_HAS_EARLYSUSPEND
onetouch->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
onetouch->early_suspend.suspend = tegra_onetouch_early_suspend;
onetouch->early_suspend.resume = tegra_onetouch_late_resume;
register_early_suspend(&onetouch->early_suspend);
#endif
printk(KERN_INFO NVODM_TOUCH_NAME ": Successfully registered the ODM onetouch driver %x\n", (NvU32)onetouch->hOneTouchDevice);
return 0;
input_unregister_device(input_dev);
err_input_register_device_failed:
NvOdmOneTouchDeviceClose(onetouch->hOneTouchDevice);
err_kthread_create_failed:
/* FIXME How to destroy the thread? Maybe we should use workqueues? */
err_open_failed:
NvOdmOsSemaphoreDestroy(onetouch->semaphore);
err_semaphore_create_failed:
kfree(onetouch);
input_free_device(input_dev);
return err;
}
static void __exit hp680_ts_exit(void)
{
free_irq(HP680_TS_IRQ, NULL);
cancel_delayed_work_sync(&work);
input_unregister_device(hp680_ts_dev);
}
static void __exit gzsd_input_exit(void)
{
input_unregister_device(input);
misc_deregister(&misc);
}
