static int __init iforce_init(void)
{
int err = 0;
#ifdef CONFIG_JOYSTICK_IFORCE_USB
err = usb_register(&iforce_usb_driver);
if (err)
return err;
#endif
#ifdef CONFIG_JOYSTICK_IFORCE_232
err = serio_register_driver(&iforce_serio_drv);
#ifdef CONFIG_JOYSTICK_IFORCE_USB
if (err)
usb_deregister(&iforce_usb_driver);
#endif
#endif
return err;
}
static int __init inexio_init(void)
{
return serio_register_driver(&inexio_drv);
}
static int __init tsc_ser_init(void)
{
return serio_register_driver(&tsc_drv);
}
static int __init vsxxxaa_init(void)
{
return serio_register_driver(&vsxxxaa_drv);
}
static int __init sunkbd_init(void)
{
return serio_register_driver(&sunkbd_drv);
}
static int __init fujitsu_init(void)
{
return serio_register_driver(&fujitsu_drv);
}
static int __init pm_init(void)
{
return serio_register_driver(&pm_drv);
}
static int __init spaceball_init(void)
{
return serio_register_driver(&spaceball_drv);
}
static int __init dynapro_init(void)
{
return serio_register_driver(&dynapro_drv);
}
static int __init elo_init(void)
{
return serio_register_driver(&elo_drv);
}
static int __init taos_init(void)
{
return serio_register_driver(&taos_drv);
}
static int __init gunze_init(void)
{
return serio_register_driver(&gunze_drv);
}
static int __devinit dock_keyboard_probe(struct platform_device *pdev)
{
struct dock_keyboard_platform_data *pdata = pdev->dev.platform_data;
struct dock_keyboard_data *data;
struct input_dev *input;
int i;
int ret;
pr_debug("kbd: probe\n");
data = kzalloc(sizeof(struct dock_keyboard_data), GFP_KERNEL);
if (unlikely(IS_ERR(data))) {
ret = -ENOMEM;
goto err_alloc_mem;
}
sec_dock_kbd_driver.private_data = data;
INIT_WORK(&data->work_msg, key_event_work);
platform_set_drvdata(pdev, data);
input = input_allocate_device();
if (unlikely(IS_ERR(input))) {
pr_err("kbd: failed to allocate input device.\n");
ret = -ENOMEM;
goto err_alloc_input_dev;
}
data->input_dev = input;
input_set_drvdata(data->input_dev, data);
data->kl = UNKNOWN_KEYLAYOUT;
input->name = pdev->name;
input->dev.parent = &pdev->dev;
input->id.bustype = BUS_RS232;
input->event = dock_keyboard_event;
set_bit(EV_SYN, input->evbit);
set_bit(EV_KEY, input->evbit);
set_bit(EV_LED, input->evbit);
set_bit(LED_CAPSL, input->ledbit);
for (i = 0; i < KEYBOARD_SIZE; i++) {
if (KEY_RESERVED != dock_keycodes[i].keycode) {
input_set_capability(input, EV_KEY,
dock_keycodes[i].keycode);
}
}
/* for the UK keyboard */
input_set_capability(input, EV_KEY, KEY_NUMERIC_POUND);
/* for the remaped keys */
input_set_capability(input, EV_KEY, KEY_NEXTSONG);
input_set_capability(input, EV_KEY, KEY_PREVIOUSSONG);
ret = input_register_device(data->input_dev);
if (unlikely(ret)) {
pr_err("kbd: failed to register input device.\n");
goto err_reg_input_dev;
}
data->dock_irq_gpio = pdata->dock_irq_gpio;
data->power = pdata->power;
if (pdata->register_cb)
pdata->register_cb(input, dock_keyboard_cb);
#ifdef CONFIG_HAS_EARLYSUSPEND
data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
data->early_suspend.suspend = dock_keyboard_early_suspend;
data->early_suspend.resume = dock_keyboard_late_resume;
register_early_suspend(&data->early_suspend);
#endif /* CONFIG_HAS_EARLYSUSPEND */
init_timer(&data->key_timer);
data->key_timer.data = (unsigned long)data;
data->key_timer.expires = jiffies + HZ / 3;
data->key_timer.function = remapkey_timer;
init_timer(&data->off_timer);
data->off_timer.data = (unsigned long)data;
data->off_timer.expires = jiffies + HZ * 2 / 3;
data->off_timer.function = power_off_timer;
ret = serio_register_driver(&sec_dock_kbd_driver.serio_drv);
if (unlikely(ret)) {
pr_err("kbd: failed to register serio driver!\n");
goto err_reg_serio_drv;
}
return 0;
err_reg_serio_drv:
#ifdef CONFIG_HAS_EARLYSUSPEND
unregister_early_suspend(&data->early_suspend);
#endif
if (pdata->register_cb)
pdata->register_cb(NULL, NULL);
input_unregister_device(input);
err_reg_input_dev:
input_free_device(input);
input_set_drvdata(input, NULL);
err_alloc_input_dev:
kfree(data);
err_alloc_mem:
return ret;
}
static int __init magellan_init(void)
{
return serio_register_driver(&magellan_drv);
}
static int __init mtouch_init(void)
{
return serio_register_driver(&mtouch_drv);
}
static int __init h3600ts_init(void)
{
return serio_register_driver(&h3600ts_drv);
}
static int __devinit sec_keyboard_probe(struct platform_device *pdev)
{
struct sec_keyboard_platform_data *pdata = pdev->dev.platform_data;
struct sec_keyboard_drvdata *ddata;
struct input_dev *input;
int i, error;
if (pdata == NULL) {
printk(KERN_ERR "%s: no pdata\n", __func__);
return -ENODEV;
}
ddata = kzalloc(sizeof(struct sec_keyboard_drvdata), GFP_KERNEL);
if (NULL == ddata) {
error = -ENOMEM;
goto err_free_mem;
}
input = input_allocate_device();
if (NULL == input) {
printk(KERN_ERR "[Keyboard] failed to allocate input device.\n");
error = -ENOMEM;
goto err_free_mem;
}
ddata->input_dev = input;
ddata->acc_power = pdata->acc_power;
ddata->check_uart_path = pdata->check_uart_path;
ddata->acc_int_gpio = pdata->accessory_irq_gpio;
ddata->led_on = false;
ddata->dockconnected = false;
ddata->pre_connected = false;
ddata->univ_kbd_dock = false;
ddata->remap_key = 0;
ddata->kl = UNKOWN_KEYLAYOUT;
ddata->callbacks.check_keyboard_dock = check_keyboard_dock;
if (pdata->register_cb)
pdata->register_cb(&ddata->callbacks);
ddata->noti_univ_kbd_dock = pdata->noti_univ_kbd_dock;
memcpy(ddata->keycode, sec_keycodes, sizeof(sec_keycodes));
INIT_DELAYED_WORK(&ddata->remap_dwork, sec_keyboard_remapkey);
INIT_DELAYED_WORK(&ddata->power_dwork, sec_keyboard_power);
INIT_DELAYED_WORK(&ddata->ack_dwork, sec_keyboard_ack);
platform_set_drvdata(pdev, ddata);
input_set_drvdata(input, ddata);
input->name = pdev->name;
input->dev.parent = &pdev->dev;
input->id.bustype = BUS_RS232;
input->event = sec_keyboard_event;
__set_bit(EV_KEY, input->evbit);
__set_bit(EV_LED, input->evbit);
__set_bit(LED_CAPSL, input->ledbit);
/* framework doesn't use repeat event */
/* __set_bit(EV_REP, input->evbit); */
for (i = 0; i < KEYBOARD_SIZE; i++) {
if (KEY_RESERVED != ddata->keycode[i])
input_set_capability(input, EV_KEY, ddata->keycode[i]);
}
/* for the UK keyboard */
input_set_capability(input, EV_KEY, KEY_NUMERIC_POUND);
/* for the remaped keys */
input_set_capability(input, EV_KEY, KEY_NEXTSONG);
input_set_capability(input, EV_KEY, KEY_PREVIOUSSONG);
/* for the wakeup key */
input_set_capability(input, EV_KEY, KEY_WAKEUP);
error = input_register_device(input);
if (error < 0) {
printk(KERN_ERR "[Keyboard] failed to register input device.\n");
error = -ENOMEM;
goto err_input_allocate_device;
}
ddata->serio_driver.driver.name = pdev->name;
ddata->serio_driver.id_table = sec_serio_ids;
ddata->serio_driver.interrupt = sec_keyboard_interrupt,
ddata->serio_driver.connect = sec_keyboard_connect,
ddata->serio_driver.disconnect = sec_keyboard_disconnect,
error = serio_register_driver(&ddata->serio_driver);
if (error < 0) {
printk(KERN_ERR "[Keyboard] failed to register serio\n");
error = -ENOMEM;
goto err_reg_serio;
}
#ifdef CONFIG_HAS_EARLYSUSPEND
ddata->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
ddata->early_suspend.suspend = keyboard_early_suspend;
ddata->early_suspend.resume = keyboard_late_resume;
register_early_suspend(&ddata->early_suspend);
#endif /* CONFIG_HAS_EARLYSUSPEND */
ddata->keyboard_dev = device_create(sec_class, NULL, 0,
ddata, "sec_keyboard");
if (IS_ERR(ddata->keyboard_dev)) {
printk(KERN_ERR "[Keyboard] failed to create device for the sysfs\n");
error = -ENODEV;
goto err_sysfs_create_group;
}
error = sysfs_create_group(&ddata->keyboard_dev->kobj, &attr_group);
if (error) {
printk(KERN_ERR "[Keyboard] failed to create sysfs group\n");
goto err_sysfs_create_group;
}
return 0;
err_sysfs_create_group:
#ifdef CONFIG_HAS_EARLYSUSPEND
unregister_early_suspend(&ddata->early_suspend);
#endif
serio_unregister_driver(&ddata->serio_driver);
err_reg_serio:
err_input_allocate_device:
input_free_device(input);
del_timer_sync(&ddata->remap_dwork.timer);
del_timer_sync(&ddata->power_dwork.timer);
del_timer_sync(&ddata->ack_dwork.timer);
err_free_mem:
kfree(ddata);
return error;
}
static int __init touchit213_init(void)
{
return serio_register_driver(&touchit213_drv);
}
