iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge master.kernel.org:/pub/scm/linux/kernel/git/dtor/input

Browse Source
This commit is contained in:
Linus Torvalds 2005-07-29 09:48:34 -07:00
commit e0d7ff168a
34 changed files with 542 additions and 532 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
drivers/char/keyboard.c
View File

@ -198,10 +198,10 @@ int setkeycode(unsigned int scancode, unsigned int keycode)
if (scancode >= dev->keycodemax) if (scancode >= dev->keycodemax)
return -EINVAL; return -EINVAL;
if (keycode > KEY_MAX)
return -EINVAL;
if (keycode < 0 || keycode > KEY_MAX) if (keycode < 0 || keycode > KEY_MAX)
return -EINVAL; return -EINVAL;
if (keycode >> (dev->keycodesize * 8))
return -EINVAL;
oldkey = SET_INPUT_KEYCODE(dev, scancode, keycode); oldkey = SET_INPUT_KEYCODE(dev, scancode, keycode);

146
drivers/char/sonypi.c
View File

@ -439,6 +439,11 @@ static struct {
{ 0, 0 }, { 0, 0 },
}; };
struct sonypi_keypress {
struct input_dev *dev;
int key;
};
static struct sonypi_device { static struct sonypi_device {
struct pci_dev *dev; struct pci_dev *dev;
struct platform_device *pdev; struct platform_device *pdev;
@ -710,22 +715,61 @@ static void sonypi_setbluetoothpower(u8 state)
static void input_keyrelease(void *data) static void input_keyrelease(void *data)
{ {
struct input_dev *input_dev; struct sonypi_keypress kp;
int key;
while (1) {
if (kfifo_get(sonypi_device.input_fifo,
(unsigned char *)&input_dev,
sizeof(input_dev)) != sizeof(input_dev))
return;
if (kfifo_get(sonypi_device.input_fifo,
(unsigned char *)&key,
sizeof(key)) != sizeof(key))
return;
while (kfifo_get(sonypi_device.input_fifo, (unsigned char *)&kp,
sizeof(kp)) == sizeof(kp)) {
msleep(10); msleep(10);
input_report_key(input_dev, key, 0); input_report_key(kp.dev, kp.key, 0);
input_sync(input_dev); input_sync(kp.dev);
}
}
static void sonypi_report_input_event(u8 event)
{
struct input_dev *jog_dev = &sonypi_device.input_jog_dev;
struct input_dev *key_dev = &sonypi_device.input_key_dev;
struct sonypi_keypress kp = { NULL };
int i;
switch (event) {
case SONYPI_EVENT_JOGDIAL_UP:
case SONYPI_EVENT_JOGDIAL_UP_PRESSED:
input_report_rel(jog_dev, REL_WHEEL, 1);
input_sync(jog_dev);
break;
case SONYPI_EVENT_JOGDIAL_DOWN:
case SONYPI_EVENT_JOGDIAL_DOWN_PRESSED:
input_report_rel(jog_dev, REL_WHEEL, -1);
input_sync(jog_dev);
break;
case SONYPI_EVENT_JOGDIAL_PRESSED:
kp.key = BTN_MIDDLE;
kp.dev = jog_dev;
break;
case SONYPI_EVENT_FNKEY_RELEASED:
/* Nothing, not all VAIOs generate this event */
break;
default:
for (i = 0; sonypi_inputkeys[i].sonypiev; i++)
if (event == sonypi_inputkeys[i].sonypiev) {
kp.dev = key_dev;
kp.key = sonypi_inputkeys[i].inputev;
break;
}
break;
}
if (kp.dev) {
input_report_key(kp.dev, kp.key, 1);
input_sync(kp.dev);
kfifo_put(sonypi_device.input_fifo,
(unsigned char *)&kp, sizeof(kp));
schedule_work(&sonypi_device.input_work);
} }
} }
@ -768,51 +812,8 @@ found:
printk(KERN_INFO printk(KERN_INFO
"sonypi: event port1=0x%02x,port2=0x%02x\n", v1, v2); "sonypi: event port1=0x%02x,port2=0x%02x\n", v1, v2);
if (useinput) { if (useinput)
struct input_dev *input_jog_dev = &sonypi_device.input_jog_dev; sonypi_report_input_event(event);
struct input_dev *input_key_dev = &sonypi_device.input_key_dev;
switch (event) {
case SONYPI_EVENT_JOGDIAL_UP:
case SONYPI_EVENT_JOGDIAL_UP_PRESSED:
input_report_rel(input_jog_dev, REL_WHEEL, 1);
break;
case SONYPI_EVENT_JOGDIAL_DOWN:
case SONYPI_EVENT_JOGDIAL_DOWN_PRESSED:
input_report_rel(input_jog_dev, REL_WHEEL, -1);
break;
case SONYPI_EVENT_JOGDIAL_PRESSED: {
int key = BTN_MIDDLE;
input_report_key(input_jog_dev, key, 1);
kfifo_put(sonypi_device.input_fifo,
(unsigned char *)&input_jog_dev,
sizeof(input_jog_dev));
kfifo_put(sonypi_device.input_fifo,
(unsigned char *)&key, sizeof(key));
break;
}
case SONYPI_EVENT_FNKEY_RELEASED:
/* Nothing, not all VAIOs generate this event */
break;
}
input_sync(input_jog_dev);
for (i = 0; sonypi_inputkeys[i].sonypiev; i++) {
int key;
if (event != sonypi_inputkeys[i].sonypiev)
continue;
key = sonypi_inputkeys[i].inputev;
input_report_key(input_key_dev, key, 1);
kfifo_put(sonypi_device.input_fifo,
(unsigned char *)&input_key_dev,
sizeof(input_key_dev));
kfifo_put(sonypi_device.input_fifo,
(unsigned char *)&key, sizeof(key));
}
input_sync(input_key_dev);
schedule_work(&sonypi_device.input_work);
}
kfifo_put(sonypi_device.fifo, (unsigned char *)&event, sizeof(event)); kfifo_put(sonypi_device.fifo, (unsigned char *)&event, sizeof(event));
kill_fasync(&sonypi_device.fifo_async, SIGIO, POLL_IN); kill_fasync(&sonypi_device.fifo_async, SIGIO, POLL_IN);
@ -1227,14 +1228,7 @@ static int __devinit sonypi_probe(void)
sonypi_device.input_jog_dev.keybit[LONG(BTN_MOUSE)] = sonypi_device.input_jog_dev.keybit[LONG(BTN_MOUSE)] =
BIT(BTN_MIDDLE); BIT(BTN_MIDDLE);
sonypi_device.input_jog_dev.relbit[0] = BIT(REL_WHEEL); sonypi_device.input_jog_dev.relbit[0] = BIT(REL_WHEEL);
sonypi_device.input_jog_dev.name = sonypi_device.input_jog_dev.name = SONYPI_JOG_INPUTNAME;
kmalloc(sizeof(SONYPI_JOG_INPUTNAME), GFP_KERNEL);
if (!sonypi_device.input_jog_dev.name) {
printk(KERN_ERR "sonypi: kmalloc failed\n");
ret = -ENOMEM;
goto out_inkmallocinput1;
}
sprintf(sonypi_device.input_jog_dev.name, SONYPI_JOG_INPUTNAME);
sonypi_device.input_jog_dev.id.bustype = BUS_ISA; sonypi_device.input_jog_dev.id.bustype = BUS_ISA;
sonypi_device.input_jog_dev.id.vendor = PCI_VENDOR_ID_SONY; sonypi_device.input_jog_dev.id.vendor = PCI_VENDOR_ID_SONY;
@ -1248,14 +1242,7 @@ static int __devinit sonypi_probe(void)
if (sonypi_inputkeys[i].inputev) if (sonypi_inputkeys[i].inputev)
set_bit(sonypi_inputkeys[i].inputev, set_bit(sonypi_inputkeys[i].inputev,
sonypi_device.input_key_dev.keybit); sonypi_device.input_key_dev.keybit);
sonypi_device.input_key_dev.name = sonypi_device.input_key_dev.name = SONYPI_KEY_INPUTNAME;
kmalloc(sizeof(SONYPI_KEY_INPUTNAME), GFP_KERNEL);
if (!sonypi_device.input_key_dev.name) {
printk(KERN_ERR "sonypi: kmalloc failed\n");
ret = -ENOMEM;
goto out_inkmallocinput2;
}
sprintf(sonypi_device.input_key_dev.name, SONYPI_KEY_INPUTNAME);
sonypi_device.input_key_dev.id.bustype = BUS_ISA; sonypi_device.input_key_dev.id.bustype = BUS_ISA;
sonypi_device.input_key_dev.id.vendor = PCI_VENDOR_ID_SONY; sonypi_device.input_key_dev.id.vendor = PCI_VENDOR_ID_SONY;
@ -1313,11 +1300,7 @@ out_platformdev:
kfifo_free(sonypi_device.input_fifo); kfifo_free(sonypi_device.input_fifo);
out_infifo: out_infifo:
input_unregister_device(&sonypi_device.input_key_dev); input_unregister_device(&sonypi_device.input_key_dev);
kfree(sonypi_device.input_key_dev.name);
out_inkmallocinput2:
input_unregister_device(&sonypi_device.input_jog_dev); input_unregister_device(&sonypi_device.input_jog_dev);
kfree(sonypi_device.input_jog_dev.name);
out_inkmallocinput1:
free_irq(sonypi_device.irq, sonypi_irq); free_irq(sonypi_device.irq, sonypi_irq);
out_reqirq: out_reqirq:
release_region(sonypi_device.ioport1, sonypi_device.region_size); release_region(sonypi_device.ioport1, sonypi_device.region_size);
@ -1337,13 +1320,14 @@ static void __devexit sonypi_remove(void)
{ {
sonypi_disable(); sonypi_disable();
synchronize_sched(); /* Allow sonypi interrupt to complete. */
flush_scheduled_work();
platform_device_unregister(sonypi_device.pdev); platform_device_unregister(sonypi_device.pdev);
if (useinput) { if (useinput) {
input_unregister_device(&sonypi_device.input_key_dev); input_unregister_device(&sonypi_device.input_key_dev);
kfree(sonypi_device.input_key_dev.name);
input_unregister_device(&sonypi_device.input_jog_dev); input_unregister_device(&sonypi_device.input_jog_dev);
kfree(sonypi_device.input_jog_dev.name);
kfifo_free(sonypi_device.input_fifo); kfifo_free(sonypi_device.input_fifo);
} }

1
drivers/input/evdev.c
View File

@ -320,6 +320,7 @@ static long evdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
if (t < 0 || t >= dev->keycodemax || !dev->keycodesize) return -EINVAL; if (t < 0 || t >= dev->keycodemax || !dev->keycodesize) return -EINVAL;
if (get_user(v, ip + 1)) return -EFAULT; if (get_user(v, ip + 1)) return -EFAULT;
if (v < 0 || v > KEY_MAX) return -EINVAL; if (v < 0 || v > KEY_MAX) return -EINVAL;
if (v >> (dev->keycodesize * 8)) return -EINVAL;
u = SET_INPUT_KEYCODE(dev, t, v); u = SET_INPUT_KEYCODE(dev, t, v);
clear_bit(u, dev->keybit); clear_bit(u, dev->keybit);
set_bit(v, dev->keybit); set_bit(v, dev->keybit);

401
drivers/input/input.c
View File

@ -48,12 +48,6 @@ static LIST_HEAD(input_handler_list);
static struct input_handler *input_table[8]; static struct input_handler *input_table[8];
#ifdef CONFIG_PROC_FS
static struct proc_dir_entry *proc_bus_input_dir;
static DECLARE_WAIT_QUEUE_HEAD(input_devices_poll_wait);
static int input_devices_state;
#endif
void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{ {
struct input_handle *handle; struct input_handle *handle;
@ -312,6 +306,7 @@ static struct input_device_id *input_match_device(struct input_device_id *id, st
return NULL; return NULL;
} }
/* /*
* Input hotplugging interface - loading event handlers based on * Input hotplugging interface - loading event handlers based on
* device bitfields. * device bitfields.
@ -428,162 +423,27 @@ static void input_call_hotplug(char *verb, struct input_dev *dev)
#endif #endif
void input_register_device(struct input_dev *dev)
{
struct input_handle *handle;
struct input_handler *handler;
struct input_device_id *id;
set_bit(EV_SYN, dev->evbit);
init_MUTEX(&dev->sem);
/*
* If delay and period are pre-set by the driver, then autorepeating
* is handled by the driver itself and we don't do it in input.c.
*/
init_timer(&dev->timer);
if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
dev->timer.data = (long) dev;
dev->timer.function = input_repeat_key;
dev->rep[REP_DELAY] = 250;
dev->rep[REP_PERIOD] = 33;
}
INIT_LIST_HEAD(&dev->h_list);
list_add_tail(&dev->node, &input_dev_list);
list_for_each_entry(handler, &input_handler_list, node)
if (!handler->blacklist || !input_match_device(handler->blacklist, dev))
if ((id = input_match_device(handler->id_table, dev)))
if ((handle = handler->connect(handler, dev, id)))
input_link_handle(handle);
#ifdef CONFIG_HOTPLUG
input_call_hotplug("add", dev);
#endif
#ifdef CONFIG_PROC_FS #ifdef CONFIG_PROC_FS
static struct proc_dir_entry *proc_bus_input_dir;
static DECLARE_WAIT_QUEUE_HEAD(input_devices_poll_wait);
static int input_devices_state;
static inline void input_wakeup_procfs_readers(void)
{
input_devices_state++; input_devices_state++;
wake_up(&input_devices_poll_wait); wake_up(&input_devices_poll_wait);
#endif
} }
void input_unregister_device(struct input_dev *dev) static unsigned int input_devices_poll(struct file *file, poll_table *wait)
{ {
struct list_head * node, * next; int state = input_devices_state;
poll_wait(file, &input_devices_poll_wait, wait);
if (!dev) return; if (state != input_devices_state)
return POLLIN | POLLRDNORM;
del_timer_sync(&dev->timer); return 0;
list_for_each_safe(node, next, &dev->h_list) {
struct input_handle * handle = to_handle(node);
list_del_init(&handle->d_node);
list_del_init(&handle->h_node);
handle->handler->disconnect(handle);
}
#ifdef CONFIG_HOTPLUG
input_call_hotplug("remove", dev);
#endif
list_del_init(&dev->node);
#ifdef CONFIG_PROC_FS
input_devices_state++;
wake_up(&input_devices_poll_wait);
#endif
} }
void input_register_handler(struct input_handler *handler)
{
struct input_dev *dev;
struct input_handle *handle;
struct input_device_id *id;
if (!handler) return;
INIT_LIST_HEAD(&handler->h_list);
if (handler->fops != NULL)
input_table[handler->minor >> 5] = handler;
list_add_tail(&handler->node, &input_handler_list);
list_for_each_entry(dev, &input_dev_list, node)
if (!handler->blacklist || !input_match_device(handler->blacklist, dev))
if ((id = input_match_device(handler->id_table, dev)))
if ((handle = handler->connect(handler, dev, id)))
input_link_handle(handle);
#ifdef CONFIG_PROC_FS
input_devices_state++;
wake_up(&input_devices_poll_wait);
#endif
}
void input_unregister_handler(struct input_handler *handler)
{
struct list_head * node, * next;
list_for_each_safe(node, next, &handler->h_list) {
struct input_handle * handle = to_handle_h(node);
list_del_init(&handle->h_node);
list_del_init(&handle->d_node);
handler->disconnect(handle);
}
list_del_init(&handler->node);
if (handler->fops != NULL)
input_table[handler->minor >> 5] = NULL;
#ifdef CONFIG_PROC_FS
input_devices_state++;
wake_up(&input_devices_poll_wait);
#endif
}
static int input_open_file(struct inode *inode, struct file *file)
{
struct input_handler *handler = input_table[iminor(inode) >> 5];
struct file_operations *old_fops, *new_fops = NULL;
int err;
/* No load-on-demand here? */
if (!handler || !(new_fops = fops_get(handler->fops)))
return -ENODEV;
/*
* That's _really_ odd. Usually NULL ->open means "nothing special",
* not "no device". Oh, well...
*/
if (!new_fops->open) {
fops_put(new_fops);
return -ENODEV;
}
old_fops = file->f_op;
file->f_op = new_fops;
err = new_fops->open(inode, file);
if (err) {
fops_put(file->f_op);
file->f_op = fops_get(old_fops);
}
fops_put(old_fops);
return err;
}
static struct file_operations input_fops = {
.owner = THIS_MODULE,
.open = input_open_file,
};
#ifdef CONFIG_PROC_FS
#define SPRINTF_BIT_B(bit, name, max) \ #define SPRINTF_BIT_B(bit, name, max) \
do { \ do { \
len += sprintf(buf + len, "B: %s", name); \ len += sprintf(buf + len, "B: %s", name); \
@ -600,16 +460,6 @@ static struct file_operations input_fops = {
SPRINTF_BIT_B(bit, name, max); \ SPRINTF_BIT_B(bit, name, max); \
} while (0) } while (0)
static unsigned int input_devices_poll(struct file *file, poll_table *wait)
{
int state = input_devices_state;
poll_wait(file, &input_devices_poll_wait, wait);
if (state != input_devices_state)
return POLLIN | POLLRDNORM;
return 0;
}
static int input_devices_read(char *buf, char **start, off_t pos, int count, int *eof, void *data) static int input_devices_read(char *buf, char **start, off_t pos, int count, int *eof, void *data)
{ {
struct input_dev *dev; struct input_dev *dev;
@ -704,68 +554,225 @@ static int __init input_proc_init(void)
struct proc_dir_entry *entry; struct proc_dir_entry *entry;
proc_bus_input_dir = proc_mkdir("input", proc_bus); proc_bus_input_dir = proc_mkdir("input", proc_bus);
if (proc_bus_input_dir == NULL) if (!proc_bus_input_dir)
return -ENOMEM; return -ENOMEM;
proc_bus_input_dir->owner = THIS_MODULE; proc_bus_input_dir->owner = THIS_MODULE;
entry = create_proc_read_entry("devices", 0, proc_bus_input_dir, input_devices_read, NULL); entry = create_proc_read_entry("devices", 0, proc_bus_input_dir, input_devices_read, NULL);
if (entry == NULL) { if (!entry)
remove_proc_entry("input", proc_bus); goto fail1;
return -ENOMEM;
}
entry->owner = THIS_MODULE; entry->owner = THIS_MODULE;
input_fileops = *entry->proc_fops; input_fileops = *entry->proc_fops;
entry->proc_fops = &input_fileops; entry->proc_fops = &input_fileops;
entry->proc_fops->poll = input_devices_poll; entry->proc_fops->poll = input_devices_poll;
entry = create_proc_read_entry("handlers", 0, proc_bus_input_dir, input_handlers_read, NULL); entry = create_proc_read_entry("handlers", 0, proc_bus_input_dir, input_handlers_read, NULL);
if (entry == NULL) { if (!entry)
remove_proc_entry("devices", proc_bus_input_dir); goto fail2;
remove_proc_entry("input", proc_bus);
return -ENOMEM;
}
entry->owner = THIS_MODULE; entry->owner = THIS_MODULE;
return 0; return 0;
fail2: remove_proc_entry("devices", proc_bus_input_dir);
fail1: remove_proc_entry("input", proc_bus);
return -ENOMEM;
} }
static void input_proc_exit(void)
{
remove_proc_entry("devices", proc_bus_input_dir);
remove_proc_entry("handlers", proc_bus_input_dir);
remove_proc_entry("input", proc_bus);
}
#else /* !CONFIG_PROC_FS */ #else /* !CONFIG_PROC_FS */
static inline void input_wakeup_procfs_readers(void) { }
static inline int input_proc_init(void) { return 0; } static inline int input_proc_init(void) { return 0; }
static inline void input_proc_exit(void) { }
#endif #endif
void input_register_device(struct input_dev *dev)
{
struct input_handle *handle;
struct input_handler *handler;
struct input_device_id *id;
set_bit(EV_SYN, dev->evbit);
init_MUTEX(&dev->sem);
/*
* If delay and period are pre-set by the driver, then autorepeating
* is handled by the driver itself and we don't do it in input.c.
*/
init_timer(&dev->timer);
if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
dev->timer.data = (long) dev;
dev->timer.function = input_repeat_key;
dev->rep[REP_DELAY] = 250;
dev->rep[REP_PERIOD] = 33;
}
INIT_LIST_HEAD(&dev->h_list);
list_add_tail(&dev->node, &input_dev_list);
list_for_each_entry(handler, &input_handler_list, node)
if (!handler->blacklist || !input_match_device(handler->blacklist, dev))
if ((id = input_match_device(handler->id_table, dev)))
if ((handle = handler->connect(handler, dev, id)))
input_link_handle(handle);
#ifdef CONFIG_HOTPLUG
input_call_hotplug("add", dev);
#endif
input_wakeup_procfs_readers();
}
void input_unregister_device(struct input_dev *dev)
{
struct list_head * node, * next;
if (!dev) return;
del_timer_sync(&dev->timer);
list_for_each_safe(node, next, &dev->h_list) {
struct input_handle * handle = to_handle(node);
list_del_init(&handle->d_node);
list_del_init(&handle->h_node);
handle->handler->disconnect(handle);
}
#ifdef CONFIG_HOTPLUG
input_call_hotplug("remove", dev);
#endif
list_del_init(&dev->node);
input_wakeup_procfs_readers();
}
void input_register_handler(struct input_handler *handler)
{
struct input_dev *dev;
struct input_handle *handle;
struct input_device_id *id;
if (!handler) return;
INIT_LIST_HEAD(&handler->h_list);
if (handler->fops != NULL)
input_table[handler->minor >> 5] = handler;
list_add_tail(&handler->node, &input_handler_list);
list_for_each_entry(dev, &input_dev_list, node)
if (!handler->blacklist || !input_match_device(handler->blacklist, dev))
if ((id = input_match_device(handler->id_table, dev)))
if ((handle = handler->connect(handler, dev, id)))
input_link_handle(handle);
input_wakeup_procfs_readers();
}
void input_unregister_handler(struct input_handler *handler)
{
struct list_head * node, * next;
list_for_each_safe(node, next, &handler->h_list) {
struct input_handle * handle = to_handle_h(node);
list_del_init(&handle->h_node);
list_del_init(&handle->d_node);
handler->disconnect(handle);
}
list_del_init(&handler->node);
if (handler->fops != NULL)
input_table[handler->minor >> 5] = NULL;
input_wakeup_procfs_readers();
}
static int input_open_file(struct inode *inode, struct file *file)
{
struct input_handler *handler = input_table[iminor(inode) >> 5];
struct file_operations *old_fops, *new_fops = NULL;
int err;
/* No load-on-demand here? */
if (!handler || !(new_fops = fops_get(handler->fops)))
return -ENODEV;
/*
* That's _really_ odd. Usually NULL ->open means "nothing special",
* not "no device". Oh, well...
*/
if (!new_fops->open) {
fops_put(new_fops);
return -ENODEV;
}
old_fops = file->f_op;
file->f_op = new_fops;
err = new_fops->open(inode, file);
if (err) {
fops_put(file->f_op);
file->f_op = fops_get(old_fops);
}
fops_put(old_fops);
return err;
}
static struct file_operations input_fops = {
.owner = THIS_MODULE,
.open = input_open_file,
};
struct class *input_class; struct class *input_class;
static int __init input_init(void) static int __init input_init(void)
{ {
int retval = -ENOMEM; int err;
input_class = class_create(THIS_MODULE, "input"); input_class = class_create(THIS_MODULE, "input");
if (IS_ERR(input_class)) if (IS_ERR(input_class)) {
printk(KERN_ERR "input: unable to register input class\n");
return PTR_ERR(input_class); return PTR_ERR(input_class);
input_proc_init();
retval = register_chrdev(INPUT_MAJOR, "input", &input_fops);
if (retval) {
printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);
remove_proc_entry("devices", proc_bus_input_dir);
remove_proc_entry("handlers", proc_bus_input_dir);
remove_proc_entry("input", proc_bus);
class_destroy(input_class);
return retval;
} }
retval = devfs_mk_dir("input"); err = input_proc_init();
if (retval) { if (err)
remove_proc_entry("devices", proc_bus_input_dir); goto fail1;
remove_proc_entry("handlers", proc_bus_input_dir);
remove_proc_entry("input", proc_bus); err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
unregister_chrdev(INPUT_MAJOR, "input"); if (err) {
class_destroy(input_class); printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);
goto fail2;
} }
return retval;
err = devfs_mk_dir("input");
if (err)
goto fail3;
return 0;
fail3: unregister_chrdev(INPUT_MAJOR, "input");
fail2: input_proc_exit();
fail1: class_destroy(input_class);
return err;
} }
static void __exit input_exit(void) static void __exit input_exit(void)
{ {
remove_proc_entry("devices", proc_bus_input_dir); input_proc_exit();
remove_proc_entry("handlers", proc_bus_input_dir);
remove_proc_entry("input", proc_bus);
devfs_remove("input"); devfs_remove("input");
unregister_chrdev(INPUT_MAJOR, "input"); unregister_chrdev(INPUT_MAJOR, "input");
class_destroy(input_class); class_destroy(input_class);

6
drivers/input/joydev.c
View File

@ -37,8 +37,6 @@ MODULE_LICENSE("GPL");
#define JOYDEV_MINORS 16 #define JOYDEV_MINORS 16
#define JOYDEV_BUFFER_SIZE 64 #define JOYDEV_BUFFER_SIZE 64
#define MSECS(t) (1000 * ((t) / HZ) + 1000 * ((t) % HZ) / HZ)
struct joydev { struct joydev {
int exist; int exist;
int open; int open;
@ -117,7 +115,7 @@ static void joydev_event(struct input_handle *handle, unsigned int type, unsigne
return; return;
} }
event.time = MSECS(jiffies); event.time = jiffies_to_msecs(jiffies);
list_for_each_entry(list, &joydev->list, node) { list_for_each_entry(list, &joydev->list, node) {
@ -245,7 +243,7 @@ static ssize_t joydev_read(struct file *file, char __user *buf, size_t count, lo
struct js_event event; struct js_event event;
event.time = MSECS(jiffies); event.time = jiffies_to_msecs(jiffies);
if (list->startup < joydev->nkey) { if (list->startup < joydev->nkey) {
event.type = JS_EVENT_BUTTON | JS_EVENT_INIT; event.type = JS_EVENT_BUTTON | JS_EVENT_INIT;

185
drivers/input/misc/uinput.c
View File

@ -36,16 +36,6 @@
#include <linux/miscdevice.h> #include <linux/miscdevice.h>
#include <linux/uinput.h> #include <linux/uinput.h>
static int uinput_dev_open(struct input_dev *dev)
{
return 0;
}
static void uinput_dev_close(struct input_dev *dev)
{
}
static int uinput_dev_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) static int uinput_dev_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{ {
struct uinput_device *udev; struct uinput_device *udev;
@ -63,22 +53,24 @@ static int uinput_dev_event(struct input_dev *dev, unsigned int type, unsigned i
return 0; return 0;
} }
static int uinput_request_alloc_id(struct input_dev *dev, struct uinput_request *request) static int uinput_request_alloc_id(struct uinput_device *udev, struct uinput_request *request)
{ {
/* Atomically allocate an ID for the given request. Returns 0 on success. */ /* Atomically allocate an ID for the given request. Returns 0 on success. */
struct uinput_device *udev = dev->private;
int id; int id;
int err = -1;
down(&udev->requests_sem); spin_lock(&udev->requests_lock);
for (id=0; id<UINPUT_NUM_REQUESTS; id++)
for (id = 0; id < UINPUT_NUM_REQUESTS; id++)
if (!udev->requests[id]) { if (!udev->requests[id]) {
udev->requests[id] = request;
request->id = id; request->id = id;
up(&udev->requests_sem); udev->requests[id] = request;
return 0; err = 0;
break;
} }
up(&udev->requests_sem);
return -1; spin_unlock(&udev->requests_lock);
return err;
} }
static struct uinput_request* uinput_request_find(struct uinput_device *udev, int id) static struct uinput_request* uinput_request_find(struct uinput_device *udev, int id)
@ -86,70 +78,78 @@ static struct uinput_request* uinput_request_find(struct uinput_device *udev, in
/* Find an input request, by ID. Returns NULL if the ID isn't valid. */ /* Find an input request, by ID. Returns NULL if the ID isn't valid. */
if (id >= UINPUT_NUM_REQUESTS || id < 0) if (id >= UINPUT_NUM_REQUESTS || id < 0)
return NULL; return NULL;
if (udev->requests[id]->completed)
return NULL;
return udev->requests[id]; return udev->requests[id];
} }
static void uinput_request_init(struct input_dev *dev, struct uinput_request *request, int code) static inline int uinput_request_reserve_slot(struct uinput_device *udev, struct uinput_request *request)
{ {
struct uinput_device *udev = dev->private; /* Allocate slot. If none are available right away, wait. */
return wait_event_interruptible(udev->requests_waitq,
memset(request, 0, sizeof(struct uinput_request)); !uinput_request_alloc_id(udev, request));
request->code = code;
init_waitqueue_head(&request->waitq);
/* Allocate an ID. If none are available right away, wait. */
request->retval = wait_event_interruptible(udev->requests_waitq,
!uinput_request_alloc_id(dev, request));
} }
static void uinput_request_submit(struct input_dev *dev, struct uinput_request *request) static void uinput_request_done(struct uinput_device *udev, struct uinput_request *request)
{
complete(&request->done);
/* Mark slot as available */
udev->requests[request->id] = NULL;
wake_up_interruptible(&udev->requests_waitq);
}
static int uinput_request_submit(struct input_dev *dev, struct uinput_request *request)
{ {
struct uinput_device *udev = dev->private;
int retval; int retval;
/* Tell our userspace app about this new request by queueing an input event */ /* Tell our userspace app about this new request by queueing an input event */
uinput_dev_event(dev, EV_UINPUT, request->code, request->id); uinput_dev_event(dev, EV_UINPUT, request->code, request->id);
/* Wait for the request to complete */ /* Wait for the request to complete */
retval = wait_event_interruptible(request->waitq, request->completed); retval = wait_for_completion_interruptible(&request->done);
if (retval) if (!retval)
request->retval = retval; retval = request->retval;
/* Release this request's ID, let others know it's available */ return retval;
udev->requests[request->id] = NULL;
wake_up_interruptible(&udev->requests_waitq);
} }
static int uinput_dev_upload_effect(struct input_dev *dev, struct ff_effect *effect) static int uinput_dev_upload_effect(struct input_dev *dev, struct ff_effect *effect)
{ {
struct uinput_request request; struct uinput_request request;
int retval;
if (!test_bit(EV_FF, dev->evbit)) if (!test_bit(EV_FF, dev->evbit))
return -ENOSYS; return -ENOSYS;
uinput_request_init(dev, &request, UI_FF_UPLOAD); request.id = -1;
if (request.retval) init_completion(&request.done);
return request.retval; request.code = UI_FF_UPLOAD;
request.u.effect = effect; request.u.effect = effect;
uinput_request_submit(dev, &request);
return request.retval; retval = uinput_request_reserve_slot(dev->private, &request);
if (!retval)
retval = uinput_request_submit(dev, &request);
return retval;
} }
static int uinput_dev_erase_effect(struct input_dev *dev, int effect_id) static int uinput_dev_erase_effect(struct input_dev *dev, int effect_id)
{ {
struct uinput_request request; struct uinput_request request;
int retval;
if (!test_bit(EV_FF, dev->evbit)) if (!test_bit(EV_FF, dev->evbit))
return -ENOSYS; return -ENOSYS;
uinput_request_init(dev, &request, UI_FF_ERASE); request.id = -1;
if (request.retval) init_completion(&request.done);
return request.retval; request.code = UI_FF_ERASE;
request.u.effect_id = effect_id; request.u.effect_id = effect_id;
uinput_request_submit(dev, &request);
return request.retval; retval = uinput_request_reserve_slot(dev->private, &request);
if (!retval)
retval = uinput_request_submit(dev, &request);
return retval;
} }
static int uinput_create_device(struct uinput_device *udev) static int uinput_create_device(struct uinput_device *udev)
@ -159,32 +159,30 @@ static int uinput_create_device(struct uinput_device *udev)
return -EINVAL; return -EINVAL;
} }
udev->dev->open = uinput_dev_open;
udev->dev->close = uinput_dev_close;
udev->dev->event = uinput_dev_event; udev->dev->event = uinput_dev_event;
udev->dev->upload_effect = uinput_dev_upload_effect; udev->dev->upload_effect = uinput_dev_upload_effect;
udev->dev->erase_effect = uinput_dev_erase_effect; udev->dev->erase_effect = uinput_dev_erase_effect;
udev->dev->private = udev; udev->dev->private = udev;
init_waitqueue_head(&(udev->waitq)); init_waitqueue_head(&udev->waitq);
input_register_device(udev->dev); input_register_device(udev->dev);
set_bit(UIST_CREATED, &(udev->state)); set_bit(UIST_CREATED, &udev->state);
return 0; return 0;
} }
static int uinput_destroy_device(struct uinput_device *udev) static int uinput_destroy_device(struct uinput_device *udev)
{ {
if (!test_bit(UIST_CREATED, &(udev->state))) { if (!test_bit(UIST_CREATED, &udev->state)) {
printk(KERN_WARNING "%s: create the device first\n", UINPUT_NAME); printk(KERN_WARNING "%s: create the device first\n", UINPUT_NAME);
return -EINVAL; return -EINVAL;
} }
input_unregister_device(udev->dev); input_unregister_device(udev->dev);
clear_bit(UIST_CREATED, &(udev->state)); clear_bit(UIST_CREATED, &udev->state);
return 0; return 0;
} }
@ -198,7 +196,7 @@ static int uinput_open(struct inode *inode, struct file *file)
if (!newdev) if (!newdev)
goto error; goto error;
memset(newdev, 0, sizeof(struct uinput_device)); memset(newdev, 0, sizeof(struct uinput_device));
init_MUTEX(&newdev->requests_sem); spin_lock_init(&newdev->requests_lock);
init_waitqueue_head(&newdev->requests_waitq); init_waitqueue_head(&newdev->requests_waitq);
newinput = kmalloc(sizeof(struct input_dev), GFP_KERNEL); newinput = kmalloc(sizeof(struct input_dev), GFP_KERNEL);
@ -253,15 +251,16 @@ static int uinput_alloc_device(struct file *file, const char __user *buffer, siz
struct uinput_user_dev *user_dev; struct uinput_user_dev *user_dev;
struct input_dev *dev; struct input_dev *dev;
struct uinput_device *udev; struct uinput_device *udev;
int size, char *name;
retval; int size;
int retval;
retval = count; retval = count;
udev = file->private_data; udev = file->private_data;
dev = udev->dev; dev = udev->dev;
user_dev = kmalloc(sizeof(*user_dev), GFP_KERNEL); user_dev = kmalloc(sizeof(struct uinput_user_dev), GFP_KERNEL);
if (!user_dev) { if (!user_dev) {
retval = -ENOMEM; retval = -ENOMEM;
goto exit; goto exit;
@ -272,17 +271,17 @@ static int uinput_alloc_device(struct file *file, const char __user *buffer, siz
goto exit; goto exit;
} }
if (NULL != dev->name) if (dev->name)
kfree(dev->name); kfree(dev->name);
size = strnlen(user_dev->name, UINPUT_MAX_NAME_SIZE) + 1; size = strnlen(user_dev->name, UINPUT_MAX_NAME_SIZE) + 1;
dev->name = kmalloc(size, GFP_KERNEL); dev->name = name = kmalloc(size, GFP_KERNEL);
if (!dev->name) { if (!name) {
retval = -ENOMEM; retval = -ENOMEM;
goto exit; goto exit;
} }
strlcpy(name, user_dev->name, size);
strlcpy(dev->name, user_dev->name, size);
dev->id.bustype = user_dev->id.bustype; dev->id.bustype = user_dev->id.bustype;
dev->id.vendor = user_dev->id.vendor; dev->id.vendor = user_dev->id.vendor;
dev->id.product = user_dev->id.product; dev->id.product = user_dev->id.product;
@ -314,14 +313,13 @@ static ssize_t uinput_write(struct file *file, const char __user *buffer, size_t
{ {
struct uinput_device *udev = file->private_data; struct uinput_device *udev = file->private_data;
if (test_bit(UIST_CREATED, &(udev->state))) { if (test_bit(UIST_CREATED, &udev->state)) {
struct input_event ev; struct input_event ev;
if (copy_from_user(&ev, buffer, sizeof(struct input_event))) if (copy_from_user(&ev, buffer, sizeof(struct input_event)))
return -EFAULT; return -EFAULT;
input_event(udev->dev, ev.type, ev.code, ev.value); input_event(udev->dev, ev.type, ev.code, ev.value);
} } else
else
count = uinput_alloc_device(file, buffer, count); count = uinput_alloc_device(file, buffer, count);
return count; return count;
@ -332,26 +330,24 @@ static ssize_t uinput_read(struct file *file, char __user *buffer, size_t count,
struct uinput_device *udev = file->private_data; struct uinput_device *udev = file->private_data;
int retval = 0; int retval = 0;
if (!test_bit(UIST_CREATED, &(udev->state))) if (!test_bit(UIST_CREATED, &udev->state))
return -ENODEV; return -ENODEV;
if ((udev->head == udev->tail) && (file->f_flags & O_NONBLOCK)) if (udev->head == udev->tail && (file->f_flags & O_NONBLOCK))
return -EAGAIN; return -EAGAIN;
retval = wait_event_interruptible(udev->waitq, retval = wait_event_interruptible(udev->waitq,
(udev->head != udev->tail) || udev->head != udev->tail || !test_bit(UIST_CREATED, &udev->state));
!test_bit(UIST_CREATED, &(udev->state)));
if (retval) if (retval)
return retval; return retval;
if (!test_bit(UIST_CREATED, &(udev->state))) if (!test_bit(UIST_CREATED, &udev->state))
return -ENODEV; return -ENODEV;
while ((udev->head != udev->tail) && while ((udev->head != udev->tail) &&
(retval + sizeof(struct input_event) <= count)) { (retval + sizeof(struct input_event) <= count)) {
if (copy_to_user(buffer + retval, &(udev->buff[udev->tail]), if (copy_to_user(buffer + retval, &udev->buff[udev->tail], sizeof(struct input_event)))
sizeof(struct input_event))) return -EFAULT; return -EFAULT;
udev->tail = (udev->tail + 1) % UINPUT_BUFFER_SIZE; udev->tail = (udev->tail + 1) % UINPUT_BUFFER_SIZE;
retval += sizeof(struct input_event); retval += sizeof(struct input_event);
} }
@ -373,12 +369,12 @@ static unsigned int uinput_poll(struct file *file, poll_table *wait)
static int uinput_burn_device(struct uinput_device *udev) static int uinput_burn_device(struct uinput_device *udev)
{ {
if (test_bit(UIST_CREATED, &(udev->state))) if (test_bit(UIST_CREATED, &udev->state))
uinput_destroy_device(udev); uinput_destroy_device(udev);
if (NULL != udev->dev->name) if (udev->dev->name)
kfree(udev->dev->name); kfree(udev->dev->name);
if (NULL != udev->dev->phys) if (udev->dev->phys)
kfree(udev->dev->phys); kfree(udev->dev->phys);
kfree(udev->dev); kfree(udev->dev);
@ -389,7 +385,8 @@ static int uinput_burn_device(struct uinput_device *udev)
static int uinput_close(struct inode *inode, struct file *file) static int uinput_close(struct inode *inode, struct file *file)
{ {
return uinput_burn_device(file->private_data); uinput_burn_device(file->private_data);
return 0;
} }
static int uinput_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) static int uinput_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
@ -401,6 +398,7 @@ static int uinput_ioctl(struct inode *inode, struct file *file, unsigned int cmd
struct uinput_ff_erase ff_erase; struct uinput_ff_erase ff_erase;
struct uinput_request *req; struct uinput_request *req;
int length; int length;
char *phys;
udev = file->private_data; udev = file->private_data;
@ -415,7 +413,7 @@ static int uinput_ioctl(struct inode *inode, struct file *file, unsigned int cmd
case UI_SET_SNDBIT: case UI_SET_SNDBIT:
case UI_SET_FFBIT: case UI_SET_FFBIT:
case UI_SET_PHYS: case UI_SET_PHYS:
if (test_bit(UIST_CREATED, &(udev->state))) if (test_bit(UIST_CREATED, &udev->state))
return -EINVAL; return -EINVAL;
} }
@ -498,20 +496,19 @@ static int uinput_ioctl(struct inode *inode, struct file *file, unsigned int cmd
retval = -EFAULT; retval = -EFAULT;
break; break;
} }
if (NULL != udev->dev->phys) kfree(udev->dev->phys);
kfree(udev->dev->phys); udev->dev->phys = phys = kmalloc(length, GFP_KERNEL);
udev->dev->phys = kmalloc(length, GFP_KERNEL); if (!phys) {
if (!udev->dev->phys) {
retval = -ENOMEM; retval = -ENOMEM;
break; break;
} }
if (copy_from_user(udev->dev->phys, p, length)) { if (copy_from_user(phys, p, length)) {
retval = -EFAULT;
kfree(udev->dev->phys);
udev->dev->phys = NULL; udev->dev->phys = NULL;
kfree(phys);
retval = -EFAULT;
break; break;
} }
udev->dev->phys[length-1] = '\0'; phys[length - 1] = '\0';
break; break;
case UI_BEGIN_FF_UPLOAD: case UI_BEGIN_FF_UPLOAD:
@ -520,7 +517,7 @@ static int uinput_ioctl(struct inode *inode, struct file *file, unsigned int cmd
break; break;
} }
req = uinput_request_find(udev, ff_up.request_id); req = uinput_request_find(udev, ff_up.request_id);
if (!(req && req->code==UI_FF_UPLOAD && req->u.effect)) { if (!(req && req->code == UI_FF_UPLOAD && req->u.effect)) {
retval = -EINVAL; retval = -EINVAL;
break; break;
} }
@ -538,7 +535,7 @@ static int uinput_ioctl(struct inode *inode, struct file *file, unsigned int cmd
break; break;
} }
req = uinput_request_find(udev, ff_erase.request_id); req = uinput_request_find(udev, ff_erase.request_id);
if (!(req && req->code==UI_FF_ERASE)) { if (!(req && req->code == UI_FF_ERASE)) {
retval = -EINVAL; retval = -EINVAL;
break; break;
} }
@ -556,14 +553,13 @@ static int uinput_ioctl(struct inode *inode, struct file *file, unsigned int cmd
break; break;
} }
req = uinput_request_find(udev, ff_up.request_id); req = uinput_request_find(udev, ff_up.request_id);
if (!(req && req->code==UI_FF_UPLOAD && req->u.effect)) { if (!(req && req->code == UI_FF_UPLOAD && req->u.effect)) {
retval = -EINVAL; retval = -EINVAL;
break; break;
} }
req->retval = ff_up.retval; req->retval = ff_up.retval;
memcpy(req->u.effect, &ff_up.effect, sizeof(struct ff_effect)); memcpy(req->u.effect, &ff_up.effect, sizeof(struct ff_effect));
req->completed = 1; uinput_request_done(udev, req);
wake_up_interruptible(&req->waitq);
break; break;
case UI_END_FF_ERASE: case UI_END_FF_ERASE:
@ -572,13 +568,12 @@ static int uinput_ioctl(struct inode *inode, struct file *file, unsigned int cmd
break; break;
} }
req = uinput_request_find(udev, ff_erase.request_id); req = uinput_request_find(udev, ff_erase.request_id);
if (!(req && req->code==UI_FF_ERASE)) { if (!(req && req->code == UI_FF_ERASE)) {
retval = -EINVAL; retval = -EINVAL;
break; break;
} }
req->retval = ff_erase.retval; req->retval = ff_erase.retval;
req->completed = 1; uinput_request_done(udev, req);
wake_up_interruptible(&req->waitq);
break; break;
default: default:

35
drivers/input/mouse/alps.c
View File

@ -2,7 +2,7 @@
* ALPS touchpad PS/2 mouse driver * ALPS touchpad PS/2 mouse driver
* *
* Copyright (c) 2003 Neil Brown <neilb@cse.unsw.edu.au> * Copyright (c) 2003 Neil Brown <neilb@cse.unsw.edu.au>
* Copyright (c) 2003 Peter Osterlund <petero2@telia.com> * Copyright (c) 2003-2005 Peter Osterlund <petero2@telia.com>
* Copyright (c) 2004 Dmitry Torokhov <dtor@mail.ru> * Copyright (c) 2004 Dmitry Torokhov <dtor@mail.ru>
* Copyright (c) 2005 Vojtech Pavlik <vojtech@suse.cz> * Copyright (c) 2005 Vojtech Pavlik <vojtech@suse.cz>
* *
@ -350,7 +350,6 @@ static int alps_tap_mode(struct psmouse *psmouse, int enable)
static int alps_reconnect(struct psmouse *psmouse) static int alps_reconnect(struct psmouse *psmouse)
{ {
struct alps_data *priv = psmouse->private; struct alps_data *priv = psmouse->private;
unsigned char param[4];
int version; int version;
psmouse_reset(psmouse); psmouse_reset(psmouse);
@ -358,21 +357,20 @@ static int alps_reconnect(struct psmouse *psmouse)
if (!(priv->i = alps_get_model(psmouse, &version))) if (!(priv->i = alps_get_model(psmouse, &version)))
return -1; return -1;
if (priv->i->flags & ALPS_PASS && alps_passthrough_mode(psmouse, 1)) if ((priv->i->flags & ALPS_PASS) && alps_passthrough_mode(psmouse, 1))
return -1; return -1;
if (alps_get_status(psmouse, param)) if (alps_tap_mode(psmouse, 1)) {
return -1; printk(KERN_WARNING "alps.c: Failed to reenable hardware tapping\n");
if (!(param[0] & 0x04))
alps_tap_mode(psmouse, 1);
if (alps_absolute_mode(psmouse)) {
printk(KERN_ERR "alps.c: Failed to enable absolute mode\n");
return -1; return -1;
} }
if (priv->i->flags == ALPS_PASS && alps_passthrough_mode(psmouse, 0)) if (alps_absolute_mode(psmouse)) {
printk(KERN_ERR "alps.c: Failed to reenable absolute mode\n");
return -1;
}
if ((priv->i->flags & ALPS_PASS) && alps_passthrough_mode(psmouse, 0))
return -1; return -1;
return 0; return 0;
@ -389,7 +387,6 @@ static void alps_disconnect(struct psmouse *psmouse)
int alps_init(struct psmouse *psmouse) int alps_init(struct psmouse *psmouse)
{ {
struct alps_data *priv; struct alps_data *priv;
unsigned char param[4];
int version; int version;
psmouse->private = priv = kmalloc(sizeof(struct alps_data), GFP_KERNEL); psmouse->private = priv = kmalloc(sizeof(struct alps_data), GFP_KERNEL);
@ -403,16 +400,8 @@ int alps_init(struct psmouse *psmouse)
if ((priv->i->flags & ALPS_PASS) && alps_passthrough_mode(psmouse, 1)) if ((priv->i->flags & ALPS_PASS) && alps_passthrough_mode(psmouse, 1))
goto init_fail; goto init_fail;
if (alps_get_status(psmouse, param)) { if (alps_tap_mode(psmouse, 1))
printk(KERN_ERR "alps.c: touchpad status report request failed\n"); printk(KERN_WARNING "alps.c: Failed to enable hardware tapping\n");
goto init_fail;
}
if (param[0] & 0x04) {
printk(KERN_INFO "alps.c: Enabling hardware tapping\n");
if (alps_tap_mode(psmouse, 1))
printk(KERN_WARNING "alps.c: Failed to enable hardware tapping\n");
}
if (alps_absolute_mode(psmouse)) { if (alps_absolute_mode(psmouse)) {
printk(KERN_ERR "alps.c: Failed to enable absolute mode\n"); printk(KERN_ERR "alps.c: Failed to enable absolute mode\n");

2
drivers/input/mouse/logips2pp.c
View File

@ -385,8 +385,6 @@ int ps2pp_init(struct psmouse *psmouse, int set_properties)
if (buttons < 3) if (buttons < 3)
clear_bit(BTN_MIDDLE, psmouse->dev.keybit); clear_bit(BTN_MIDDLE, psmouse->dev.keybit);
if (buttons < 2)
clear_bit(BTN_RIGHT, psmouse->dev.keybit);
if (model_info) if (model_info)
ps2pp_set_model_properties(psmouse, model_info, use_ps2pp); ps2pp_set_model_properties(psmouse, model_info, use_ps2pp);

2
drivers/input/mouse/psmouse-base.c
View File

@ -344,6 +344,7 @@ static int intellimouse_detect(struct psmouse *psmouse, int set_properties)
return -1; return -1;
if (set_properties) { if (set_properties) {
set_bit(BTN_MIDDLE, psmouse->dev.keybit);
set_bit(REL_WHEEL, psmouse->dev.relbit); set_bit(REL_WHEEL, psmouse->dev.relbit);
if (!psmouse->vendor) psmouse->vendor = "Generic"; if (!psmouse->vendor) psmouse->vendor = "Generic";
@ -376,6 +377,7 @@ static int im_explorer_detect(struct psmouse *psmouse, int set_properties)
return -1; return -1;
if (set_properties) { if (set_properties) {
set_bit(BTN_MIDDLE, psmouse->dev.keybit);
set_bit(REL_WHEEL, psmouse->dev.relbit); set_bit(REL_WHEEL, psmouse->dev.relbit);
set_bit(BTN_SIDE, psmouse->dev.keybit); set_bit(BTN_SIDE, psmouse->dev.keybit);
set_bit(BTN_EXTRA, psmouse->dev.keybit); set_bit(BTN_EXTRA, psmouse->dev.keybit);

14
drivers/input/mouse/synaptics.c
View File

@ -219,7 +219,7 @@ static void synaptics_pass_pt_packet(struct serio *ptport, unsigned char *packet
serio_interrupt(ptport, packet[1], 0, NULL); serio_interrupt(ptport, packet[1], 0, NULL);
serio_interrupt(ptport, packet[4], 0, NULL); serio_interrupt(ptport, packet[4], 0, NULL);
serio_interrupt(ptport, packet[5], 0, NULL); serio_interrupt(ptport, packet[5], 0, NULL);
if (child->type >= PSMOUSE_GENPS) if (child->pktsize == 4)
serio_interrupt(ptport, packet[2], 0, NULL); serio_interrupt(ptport, packet[2], 0, NULL);
} else } else
serio_interrupt(ptport, packet[1], 0, NULL); serio_interrupt(ptport, packet[1], 0, NULL);
@ -233,7 +233,7 @@ static void synaptics_pt_activate(struct psmouse *psmouse)
/* adjust the touchpad to child's choice of protocol */ /* adjust the touchpad to child's choice of protocol */
if (child) { if (child) {
if (child->type >= PSMOUSE_GENPS) if (child->pktsize == 4)
priv->mode |= SYN_BIT_FOUR_BYTE_CLIENT; priv->mode |= SYN_BIT_FOUR_BYTE_CLIENT;
else else
priv->mode &= ~SYN_BIT_FOUR_BYTE_CLIENT; priv->mode &= ~SYN_BIT_FOUR_BYTE_CLIENT;
@ -608,6 +608,13 @@ static struct dmi_system_id toshiba_dmi_table[] = {
DMI_MATCH(DMI_PRODUCT_NAME , "Satellite"), DMI_MATCH(DMI_PRODUCT_NAME , "Satellite"),
}, },
}, },
{
.ident = "Toshiba Dynabook",
.matches = {
DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
DMI_MATCH(DMI_PRODUCT_NAME , "dynabook"),
},
},
{ } { }
}; };
#endif #endif
@ -656,7 +663,8 @@ int synaptics_init(struct psmouse *psmouse)
* thye same as rate of standard PS/2 mouse. * thye same as rate of standard PS/2 mouse.
*/ */
if (psmouse->rate >= 80 && dmi_check_system(toshiba_dmi_table)) { if (psmouse->rate >= 80 && dmi_check_system(toshiba_dmi_table)) {
printk(KERN_INFO "synaptics: Toshiba Satellite detected, limiting rate to 40pps.\n"); printk(KERN_INFO "synaptics: Toshiba %s detected, limiting rate to 40pps.\n",
dmi_get_system_info(DMI_PRODUCT_NAME));
psmouse->rate = 40; psmouse->rate = 40;
} }
#endif #endif

2
drivers/input/serio/Kconfig
View File

@ -175,7 +175,7 @@ config SERIO_RAW
allocating minor 1 (that historically corresponds to /dev/psaux) allocating minor 1 (that historically corresponds to /dev/psaux)
first. To bind this driver to a serio port use sysfs interface: first. To bind this driver to a serio port use sysfs interface:
echo -n "serio_raw" > /sys/bus/serio/devices/serioX/driver echo -n "serio_raw" > /sys/bus/serio/devices/serioX/drvctl
To compile this driver as a module, choose M here: the To compile this driver as a module, choose M here: the
module will be called serio_raw. module will be called serio_raw.

14
drivers/input/serio/i8042-x86ia64io.h
View File

@ -130,6 +130,13 @@ static struct dmi_system_id __initdata i8042_dmi_nomux_table[] = {
DMI_MATCH(DMI_PRODUCT_NAME, "FMVLT70H"), DMI_MATCH(DMI_PRODUCT_NAME, "FMVLT70H"),
}, },
}, },
{
.ident = "Fujitsu-Siemens Lifebook T3010",
.matches = {
DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK T3010"),
},
},
{ {
.ident = "Toshiba P10", .ident = "Toshiba P10",
.matches = { .matches = {
@ -137,6 +144,13 @@ static struct dmi_system_id __initdata i8042_dmi_nomux_table[] = {
DMI_MATCH(DMI_PRODUCT_NAME, "Satellite P10"), DMI_MATCH(DMI_PRODUCT_NAME, "Satellite P10"),
}, },
}, },
{
.ident = "Alienware Sentia",
.matches = {
DMI_MATCH(DMI_SYS_VENDOR, "ALIENWARE"),
DMI_MATCH(DMI_PRODUCT_NAME, "Sentia"),
},
},
{ } { }
}; };

62
drivers/input/serio/i8042.c
View File

@ -100,7 +100,7 @@ struct i8042_port {
static struct i8042_port i8042_ports[I8042_NUM_PORTS] = { static struct i8042_port i8042_ports[I8042_NUM_PORTS] = {
{ {
.disable = I8042_CTR_KBDDIS, .disable = I8042_CTR_KBDDIS,
.irqen = I8042_CTR_KBDINT, .irqen = I8042_CTR_KBDINT,
.mux = -1, .mux = -1,
.name = "KBD", .name = "KBD",
}, },
@ -191,41 +191,45 @@ static int i8042_flush(void)
static int i8042_command(unsigned char *param, int command) static int i8042_command(unsigned char *param, int command)
{ {
unsigned long flags; unsigned long flags;
int retval = 0, i = 0; int i, retval, auxerr = 0;
if (i8042_noloop && command == I8042_CMD_AUX_LOOP) if (i8042_noloop && command == I8042_CMD_AUX_LOOP)
return -1; return -1;
spin_lock_irqsave(&i8042_lock, flags); spin_lock_irqsave(&i8042_lock, flags);
retval = i8042_wait_write(); if ((retval = i8042_wait_write()))
if (!retval) { goto out;
dbg("%02x -> i8042 (command)", command & 0xff);
i8042_write_command(command & 0xff); dbg("%02x -> i8042 (command)", command & 0xff);
i8042_write_command(command & 0xff);
for (i = 0; i < ((command >> 12) & 0xf); i++) {
if ((retval = i8042_wait_write()))
goto out;
dbg("%02x -> i8042 (parameter)", param[i]);
i8042_write_data(param[i]);
} }
if (!retval) for (i = 0; i < ((command >> 8) & 0xf); i++) {
for (i = 0; i < ((command >> 12) & 0xf); i++) { if ((retval = i8042_wait_read()))
if ((retval = i8042_wait_write())) break; goto out;
dbg("%02x -> i8042 (parameter)", param[i]);
i8042_write_data(param[i]); if (command == I8042_CMD_AUX_LOOP &&
!(i8042_read_status() & I8042_STR_AUXDATA)) {
retval = auxerr = -1;
goto out;
} }
if (!retval) param[i] = i8042_read_data();
for (i = 0; i < ((command >> 8) & 0xf); i++) { dbg("%02x <- i8042 (return)", param[i]);
if ((retval = i8042_wait_read())) break; }
if (i8042_read_status() & I8042_STR_AUXDATA)
param[i] = ~i8042_read_data();
else
param[i] = i8042_read_data();
dbg("%02x <- i8042 (return)", param[i]);
}
spin_unlock_irqrestore(&i8042_lock, flags);
if (retval) if (retval)
dbg(" -- i8042 (timeout)"); dbg(" -- i8042 (%s)", auxerr ? "auxerr" : "timeout");
out:
spin_unlock_irqrestore(&i8042_lock, flags);
return retval; return retval;
} }
@ -507,17 +511,17 @@ static int i8042_set_mux_mode(unsigned int mode, unsigned char *mux_version)
*/ */
param = 0xf0; param = 0xf0;
if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param != 0x0f) if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param != 0xf0)
return -1; return -1;
param = mode ? 0x56 : 0xf6; param = mode ? 0x56 : 0xf6;
if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param != (mode ? 0xa9 : 0x09)) if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param != (mode ? 0x56 : 0xf6))
return -1; return -1;
param = mode ? 0xa4 : 0xa5; param = mode ? 0xa4 : 0xa5;
if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param == (mode ? 0x5b : 0x5a)) if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param == (mode ? 0xa4 : 0xa5))
return -1; return -1;
if (mux_version) if (mux_version)
*mux_version = ~param; *mux_version = param;
return 0; return 0;
} }
@ -619,7 +623,7 @@ static int __init i8042_check_aux(void)
*/ */
param = 0x5a; param = 0x5a;
if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param != 0xa5) { if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param != 0x5a) {
/* /*
* External connection test - filters out AT-soldered PS/2 i8042's * External connection test - filters out AT-soldered PS/2 i8042's
@ -630,7 +634,7 @@ static int __init i8042_check_aux(void)
*/ */
if (i8042_command(&param, I8042_CMD_AUX_TEST) if (i8042_command(&param, I8042_CMD_AUX_TEST)
|| (param && param != 0xfa && param != 0xff)) || (param && param != 0xfa && param != 0xff))
return -1; return -1;
} }

42
drivers/input/serio/serio.c
View File

@ -389,6 +389,14 @@ static ssize_t serio_show_description(struct device *dev, struct device_attribut
return sprintf(buf, "%s\n", serio->name); return sprintf(buf, "%s\n", serio->name);
} }
static ssize_t serio_show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
{
struct serio *serio = to_serio_port(dev);
return sprintf(buf, "serio:ty%02Xpr%02Xid%02Xex%02X\n",
serio->id.type, serio->id.proto, serio->id.id, serio->id.extra);
}
static ssize_t serio_show_id_type(struct device *dev, struct device_attribute *attr, char *buf) static ssize_t serio_show_id_type(struct device *dev, struct device_attribute *attr, char *buf)
{ {
struct serio *serio = to_serio_port(dev); struct serio *serio = to_serio_port(dev);
@ -487,6 +495,7 @@ static ssize_t serio_set_bind_mode(struct device *dev, struct device_attribute *
static struct device_attribute serio_device_attrs[] = { static struct device_attribute serio_device_attrs[] = {
__ATTR(description, S_IRUGO, serio_show_description, NULL), __ATTR(description, S_IRUGO, serio_show_description, NULL),
__ATTR(modalias, S_IRUGO, serio_show_modalias, NULL),
__ATTR(drvctl, S_IWUSR, NULL, serio_rebind_driver), __ATTR(drvctl, S_IWUSR, NULL, serio_rebind_driver),
__ATTR(bind_mode, S_IWUSR | S_IRUGO, serio_show_bind_mode, serio_set_bind_mode), __ATTR(bind_mode, S_IWUSR | S_IRUGO, serio_show_bind_mode, serio_set_bind_mode),
__ATTR_NULL __ATTR_NULL
@ -785,36 +794,37 @@ static int serio_bus_match(struct device *dev, struct device_driver *drv)
#ifdef CONFIG_HOTPLUG #ifdef CONFIG_HOTPLUG
#define PUT_ENVP(fmt, val) \ #define SERIO_ADD_HOTPLUG_VAR(fmt, val...) \
do { \ do { \
envp[i++] = buffer; \ int err = add_hotplug_env_var(envp, num_envp, &i, \
length += snprintf(buffer, buffer_size - length, fmt, val); \ buffer, buffer_size, &len, \
if (buffer_size - length <= 0 || i >= num_envp) \ fmt, val); \
return -ENOMEM; \ if (err) \
length++; \ return err; \
buffer += length; \ } while (0)
} while (0)
static int serio_hotplug(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size) static int serio_hotplug(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size)
{ {
struct serio *serio; struct serio *serio;
int i = 0; int i = 0;
int length = 0; int len = 0;
if (!dev) if (!dev)
return -ENODEV; return -ENODEV;
serio = to_serio_port(dev); serio = to_serio_port(dev);
PUT_ENVP("SERIO_TYPE=%02x", serio->id.type); SERIO_ADD_HOTPLUG_VAR("SERIO_TYPE=%02x", serio->id.type);
PUT_ENVP("SERIO_PROTO=%02x", serio->id.proto); SERIO_ADD_HOTPLUG_VAR("SERIO_PROTO=%02x", serio->id.proto);
PUT_ENVP("SERIO_ID=%02x", serio->id.id); SERIO_ADD_HOTPLUG_VAR("SERIO_ID=%02x", serio->id.id);
PUT_ENVP("SERIO_EXTRA=%02x", serio->id.extra); SERIO_ADD_HOTPLUG_VAR("SERIO_EXTRA=%02x", serio->id.extra);
SERIO_ADD_HOTPLUG_VAR("MODALIAS=serio:ty%02Xpr%02Xid%02Xex%02X",
serio->id.type, serio->id.proto, serio->id.id, serio->id.extra);
envp[i] = NULL; envp[i] = NULL;
return 0; return 0;
} }
#undef PUT_ENVP #undef SERIO_ADD_HOTPLUG_VAR
#else #else

1
drivers/input/serio/serio_raw.c
View File

@ -299,6 +299,7 @@ static int serio_raw_connect(struct serio *serio, struct serio_driver *drv)
serio_raw->dev.minor = PSMOUSE_MINOR; serio_raw->dev.minor = PSMOUSE_MINOR;
serio_raw->dev.name = serio_raw->name; serio_raw->dev.name = serio_raw->name;
serio_raw->dev.dev = &serio->dev;
serio_raw->dev.fops = &serio_raw_fops; serio_raw->dev.fops = &serio_raw_fops;
err = misc_register(&serio_raw->dev); err = misc_register(&serio_raw->dev);

2
drivers/input/touchscreen/Kconfig
View File

@ -58,7 +58,7 @@ config TOUCHSCREEN_ELO
If unsure, say N. If unsure, say N.
To compile this driver as a module, choose M here: the To compile this driver as a module, choose M here: the
module will be called gunze. module will be called elo.
config TOUCHSCREEN_MTOUCH config TOUCHSCREEN_MTOUCH
tristate "MicroTouch serial touchscreens" tristate "MicroTouch serial touchscreens"

14
drivers/usb/input/acecad.c
View File

@ -31,6 +31,7 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/usb.h> #include <linux/usb.h>
#include <linux/usb_input.h>
/* /*
* Version Information * Version Information
@ -87,8 +88,8 @@ static void usb_acecad_irq(struct urb *urb, struct pt_regs *regs)
if (prox) { if (prox) {
int x = data[1] | (data[2] << 8); int x = data[1] | (data[2] << 8);
int y = data[3] | (data[4] << 8); int y = data[3] | (data[4] << 8);
/*Pressure should compute the same way for flair and 302*/ /* Pressure should compute the same way for flair and 302 */
int pressure = data[5] | ((int)data[6] << 8); int pressure = data[5] | (data[6] << 8);
int touch = data[0] & 0x01; int touch = data[0] & 0x01;
int stylus = (data[0] & 0x10) >> 4; int stylus = (data[0] & 0x10) >> 4;
int stylus2 = (data[0] & 0x20) >> 5; int stylus2 = (data[0] & 0x20) >> 5;
@ -104,9 +105,9 @@ static void usb_acecad_irq(struct urb *urb, struct pt_regs *regs)
input_sync(dev); input_sync(dev);
resubmit: resubmit:
status = usb_submit_urb (urb, GFP_ATOMIC); status = usb_submit_urb(urb, GFP_ATOMIC);
if (status) if (status)
err ("can't resubmit intr, %s-%s/input0, status %d", err("can't resubmit intr, %s-%s/input0, status %d",
acecad->usbdev->bus->bus_name, acecad->usbdev->devpath, status); acecad->usbdev->bus->bus_name, acecad->usbdev->devpath, status);
} }
@ -212,10 +213,7 @@ static int usb_acecad_probe(struct usb_interface *intf, const struct usb_device_
acecad->dev.name = acecad->name; acecad->dev.name = acecad->name;
acecad->dev.phys = acecad->phys; acecad->dev.phys = acecad->phys;
acecad->dev.id.bustype = BUS_USB; usb_to_input_id(dev, &acecad->dev.id);
acecad->dev.id.vendor = le16_to_cpu(dev->descriptor.idVendor);
acecad->dev.id.product = le16_to_cpu(dev->descriptor.idProduct);
acecad->dev.id.version = le16_to_cpu(dev->descriptor.bcdDevice);
acecad->dev.dev = &intf->dev; acecad->dev.dev = &intf->dev;
usb_fill_int_urb(acecad->irq, dev, pipe, usb_fill_int_urb(acecad->irq, dev, pipe,

6
drivers/usb/input/aiptek.c
View File

@ -77,6 +77,7 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/usb.h> #include <linux/usb.h>
#include <linux/usb_input.h>
#include <linux/sched.h> #include <linux/sched.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
#include <asm/unaligned.h> #include <asm/unaligned.h>
@ -2125,10 +2126,7 @@ aiptek_probe(struct usb_interface *intf, const struct usb_device_id *id)
aiptek->inputdev.absflat[ABS_WHEEL] = 0; aiptek->inputdev.absflat[ABS_WHEEL] = 0;
aiptek->inputdev.name = "Aiptek"; aiptek->inputdev.name = "Aiptek";
aiptek->inputdev.phys = aiptek->features.usbPath; aiptek->inputdev.phys = aiptek->features.usbPath;
aiptek->inputdev.id.bustype = BUS_USB; usb_to_input_id(usbdev, &aiptek->inputdev.id);
aiptek->inputdev.id.vendor = le16_to_cpu(usbdev->descriptor.idVendor);
aiptek->inputdev.id.product = le16_to_cpu(usbdev->descriptor.idProduct);
aiptek->inputdev.id.version = le16_to_cpu(usbdev->descriptor.bcdDevice);
aiptek->inputdev.dev = &intf->dev; aiptek->inputdev.dev = &intf->dev;
aiptek->usbdev = usbdev; aiptek->usbdev = usbdev;

8
drivers/usb/input/ati_remote.c
View File

@ -94,6 +94,7 @@
#include <linux/moduleparam.h> #include <linux/moduleparam.h>
#include <linux/input.h> #include <linux/input.h>
#include <linux/usb.h> #include <linux/usb.h>
#include <linux/usb_input.h>
#include <linux/wait.h> #include <linux/wait.h>
/* /*
@ -635,11 +636,8 @@ static void ati_remote_input_init(struct ati_remote *ati_remote)
idev->name = ati_remote->name; idev->name = ati_remote->name;
idev->phys = ati_remote->phys; idev->phys = ati_remote->phys;
idev->id.bustype = BUS_USB; usb_to_input_id(ati_remote->udev, &idev->id);
idev->id.vendor = le16_to_cpu(ati_remote->udev->descriptor.idVendor); idev->dev = &ati_remote->udev->dev;
idev->id.product = le16_to_cpu(ati_remote->udev->descriptor.idProduct);
idev->id.version = le16_to_cpu(ati_remote->udev->descriptor.bcdDevice);
idev->dev = &(ati_remote->udev->dev);
} }
static int ati_remote_initialize(struct ati_remote *ati_remote) static int ati_remote_initialize(struct ati_remote *ati_remote)

24
drivers/usb/input/hid-core.c
View File

@ -789,12 +789,12 @@ static __inline__ int search(__s32 *array, __s32 value, unsigned n)
return -1; return -1;
} }
static void hid_process_event(struct hid_device *hid, struct hid_field *field, struct hid_usage *usage, __s32 value, struct pt_regs *regs) static void hid_process_event(struct hid_device *hid, struct hid_field *field, struct hid_usage *usage, __s32 value, int interrupt, struct pt_regs *regs)
{ {
hid_dump_input(usage, value); hid_dump_input(usage, value);
if (hid->claimed & HID_CLAIMED_INPUT) if (hid->claimed & HID_CLAIMED_INPUT)
hidinput_hid_event(hid, field, usage, value, regs); hidinput_hid_event(hid, field, usage, value, regs);
if (hid->claimed & HID_CLAIMED_HIDDEV) if (hid->claimed & HID_CLAIMED_HIDDEV && interrupt)
hiddev_hid_event(hid, field, usage, value, regs); hiddev_hid_event(hid, field, usage, value, regs);
} }
@ -804,7 +804,7 @@ static void hid_process_event(struct hid_device *hid, struct hid_field *field, s
* reporting to the layer). * reporting to the layer).
*/ */
static void hid_input_field(struct hid_device *hid, struct hid_field *field, __u8 *data, struct pt_regs *regs) static void hid_input_field(struct hid_device *hid, struct hid_field *field, __u8 *data, int interrupt, struct pt_regs *regs)
{ {
unsigned n; unsigned n;
unsigned count = field->report_count; unsigned count = field->report_count;
@ -831,19 +831,19 @@ static void hid_input_field(struct hid_device *hid, struct hid_field *field, __u
for (n = 0; n < count; n++) { for (n = 0; n < count; n++) {
if (HID_MAIN_ITEM_VARIABLE & field->flags) { if (HID_MAIN_ITEM_VARIABLE & field->flags) {
hid_process_event(hid, field, &field->usage[n], value[n], regs); hid_process_event(hid, field, &field->usage[n], value[n], interrupt, regs);
continue; continue;
} }
if (field->value[n] >= min && field->value[n] <= max if (field->value[n] >= min && field->value[n] <= max
&& field->usage[field->value[n] - min].hid && field->usage[field->value[n] - min].hid
&& search(value, field->value[n], count)) && search(value, field->value[n], count))
hid_process_event(hid, field, &field->usage[field->value[n] - min], 0, regs); hid_process_event(hid, field, &field->usage[field->value[n] - min], 0, interrupt, regs);
if (value[n] >= min && value[n] <= max if (value[n] >= min && value[n] <= max
&& field->usage[value[n] - min].hid && field->usage[value[n] - min].hid
&& search(field->value, value[n], count)) && search(field->value, value[n], count))
hid_process_event(hid, field, &field->usage[value[n] - min], 1, regs); hid_process_event(hid, field, &field->usage[value[n] - min], 1, interrupt, regs);
} }
memcpy(field->value, value, count * sizeof(__s32)); memcpy(field->value, value, count * sizeof(__s32));
@ -851,7 +851,7 @@ exit:
kfree(value); kfree(value);
} }
static int hid_input_report(int type, struct urb *urb, struct pt_regs *regs) static int hid_input_report(int type, struct urb *urb, int interrupt, struct pt_regs *regs)
{ {
struct hid_device *hid = urb->context; struct hid_device *hid = urb->context;
struct hid_report_enum *report_enum = hid->report_enum + type; struct hid_report_enum *report_enum = hid->report_enum + type;
@ -899,7 +899,7 @@ static int hid_input_report(int type, struct urb *urb, struct pt_regs *regs)
hiddev_report_event(hid, report); hiddev_report_event(hid, report);
for (n = 0; n < report->maxfield; n++) for (n = 0; n < report->maxfield; n++)
hid_input_field(hid, report->field[n], data, regs); hid_input_field(hid, report->field[n], data, interrupt, regs);
if (hid->claimed & HID_CLAIMED_INPUT) if (hid->claimed & HID_CLAIMED_INPUT)
hidinput_report_event(hid, report); hidinput_report_event(hid, report);
@ -918,7 +918,7 @@ static void hid_irq_in(struct urb *urb, struct pt_regs *regs)
switch (urb->status) { switch (urb->status) {
case 0: /* success */ case 0: /* success */
hid_input_report(HID_INPUT_REPORT, urb, regs); hid_input_report(HID_INPUT_REPORT, urb, 1, regs);
break; break;
case -ECONNRESET: /* unlink */ case -ECONNRESET: /* unlink */
case -ENOENT: case -ENOENT:
@ -1142,7 +1142,7 @@ static void hid_ctrl(struct urb *urb, struct pt_regs *regs)
switch (urb->status) { switch (urb->status) {
case 0: /* success */ case 0: /* success */
if (hid->ctrl[hid->ctrltail].dir == USB_DIR_IN) if (hid->ctrl[hid->ctrltail].dir == USB_DIR_IN)
hid_input_report(hid->ctrl[hid->ctrltail].report->type, urb, regs); hid_input_report(hid->ctrl[hid->ctrltail].report->type, urb, 0, regs);
case -ESHUTDOWN: /* unplug */ case -ESHUTDOWN: /* unplug */
case -EILSEQ: /* unplug timectrl on uhci */ case -EILSEQ: /* unplug timectrl on uhci */
unplug = 1; unplug = 1;
@ -1372,6 +1372,9 @@ void hid_init_reports(struct hid_device *hid)
#define USB_VENDOR_ID_A4TECH 0x09da #define USB_VENDOR_ID_A4TECH 0x09da
#define USB_DEVICE_ID_A4TECH_WCP32PU 0x0006 #define USB_DEVICE_ID_A4TECH_WCP32PU 0x0006
#define USB_VENDOR_ID_AASHIMA 0x06D6
#define USB_DEVICE_ID_AASHIMA_GAMEPAD 0x0025
#define USB_VENDOR_ID_CYPRESS 0x04b4 #define USB_VENDOR_ID_CYPRESS 0x04b4
#define USB_DEVICE_ID_CYPRESS_MOUSE 0x0001 #define USB_DEVICE_ID_CYPRESS_MOUSE 0x0001
#define USB_DEVICE_ID_CYPRESS_HIDCOM 0x5500 #define USB_DEVICE_ID_CYPRESS_HIDCOM 0x5500
@ -1548,6 +1551,7 @@ static struct hid_blacklist {
{ USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_WCP32PU, HID_QUIRK_2WHEEL_MOUSE_HACK_7 }, { USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_WCP32PU, HID_QUIRK_2WHEEL_MOUSE_HACK_7 },
{ USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE, HID_QUIRK_2WHEEL_MOUSE_HACK_5 }, { USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE, HID_QUIRK_2WHEEL_MOUSE_HACK_5 },
{ USB_VENDOR_ID_AASHIMA, USB_DEVICE_ID_AASHIMA_GAMEPAD, HID_QUIRK_BADPAD },
{ USB_VENDOR_ID_ALPS, USB_DEVICE_ID_IBM_GAMEPAD, HID_QUIRK_BADPAD }, { USB_VENDOR_ID_ALPS, USB_DEVICE_ID_IBM_GAMEPAD, HID_QUIRK_BADPAD },
{ USB_VENDOR_ID_CHIC, USB_DEVICE_ID_CHIC_GAMEPAD, HID_QUIRK_BADPAD }, { USB_VENDOR_ID_CHIC, USB_DEVICE_ID_CHIC_GAMEPAD, HID_QUIRK_BADPAD },
{ USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_DRIVING, HID_QUIRK_BADPAD | HID_QUIRK_MULTI_INPUT }, { USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_DRIVING, HID_QUIRK_BADPAD | HID_QUIRK_MULTI_INPUT },

6
drivers/usb/input/hid-input.c
View File

@ -31,6 +31,7 @@
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/input.h> #include <linux/input.h>
#include <linux/usb.h> #include <linux/usb.h>
#include <linux/usb_input.h>
#undef DEBUG #undef DEBUG
@ -581,10 +582,7 @@ int hidinput_connect(struct hid_device *hid)
hidinput->input.name = hid->name; hidinput->input.name = hid->name;
hidinput->input.phys = hid->phys; hidinput->input.phys = hid->phys;
hidinput->input.uniq = hid->uniq; hidinput->input.uniq = hid->uniq;
hidinput->input.id.bustype = BUS_USB; usb_to_input_id(dev, &hidinput->input.id);
hidinput->input.id.vendor = le16_to_cpu(dev->descriptor.idVendor);
hidinput->input.id.product = le16_to_cpu(dev->descriptor.idProduct);
hidinput->input.id.version = le16_to_cpu(dev->descriptor.bcdDevice);
hidinput->input.dev = &hid->intf->dev; hidinput->input.dev = &hid->intf->dev;
} }

6
drivers/usb/input/itmtouch.c
View File

@ -53,6 +53,7 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/usb.h> #include <linux/usb.h>
#include <linux/usb_input.h>
/* only an 8 byte buffer necessary for a single packet */ /* only an 8 byte buffer necessary for a single packet */
#define ITM_BUFSIZE 8 #define ITM_BUFSIZE 8
@ -184,10 +185,7 @@ static int itmtouch_probe(struct usb_interface *intf, const struct usb_device_id
itmtouch->inputdev.name = itmtouch->name; itmtouch->inputdev.name = itmtouch->name;
itmtouch->inputdev.phys = itmtouch->phys; itmtouch->inputdev.phys = itmtouch->phys;
itmtouch->inputdev.id.bustype = BUS_USB; usb_to_input_id(udev, &itmtouch->inputdev.id);
itmtouch->inputdev.id.vendor = udev->descriptor.idVendor;
itmtouch->inputdev.id.product = udev->descriptor.idProduct;
itmtouch->inputdev.id.version = udev->descriptor.bcdDevice;
itmtouch->inputdev.dev = &intf->dev; itmtouch->inputdev.dev = &intf->dev;
if (!strlen(itmtouch->name)) if (!strlen(itmtouch->name))

6
drivers/usb/input/kbtab.c
View File

@ -4,6 +4,7 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/usb.h> #include <linux/usb.h>
#include <linux/usb_input.h>
#include <asm/unaligned.h> #include <asm/unaligned.h>
#include <asm/byteorder.h> #include <asm/byteorder.h>
@ -167,10 +168,7 @@ static int kbtab_probe(struct usb_interface *intf, const struct usb_device_id *i
kbtab->dev.name = "KB Gear Tablet"; kbtab->dev.name = "KB Gear Tablet";
kbtab->dev.phys = kbtab->phys; kbtab->dev.phys = kbtab->phys;
kbtab->dev.id.bustype = BUS_USB; usb_to_input_id(dev, &kbtab->dev.id);
kbtab->dev.id.vendor = le16_to_cpu(dev->descriptor.idVendor);
kbtab->dev.id.product = le16_to_cpu(dev->descriptor.idProduct);
kbtab->dev.id.version = le16_to_cpu(dev->descriptor.bcdDevice);
kbtab->dev.dev = &intf->dev; kbtab->dev.dev = &intf->dev;
kbtab->usbdev = dev; kbtab->usbdev = dev;

6
drivers/usb/input/mtouchusb.c
View File

@ -53,6 +53,7 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/usb.h> #include <linux/usb.h>
#include <linux/usb_input.h>
#define MTOUCHUSB_MIN_XC 0x0 #define MTOUCHUSB_MIN_XC 0x0
#define MTOUCHUSB_MAX_RAW_XC 0x4000 #define MTOUCHUSB_MAX_RAW_XC 0x4000
@ -232,10 +233,7 @@ static int mtouchusb_probe(struct usb_interface *intf, const struct usb_device_i
mtouch->input.name = mtouch->name; mtouch->input.name = mtouch->name;
mtouch->input.phys = mtouch->phys; mtouch->input.phys = mtouch->phys;
mtouch->input.id.bustype = BUS_USB; usb_to_input_id(udev, &mtouch->input.id);
mtouch->input.id.vendor = le16_to_cpu(udev->descriptor.idVendor);
mtouch->input.id.product = le16_to_cpu(udev->descriptor.idProduct);
mtouch->input.id.version = le16_to_cpu(udev->descriptor.bcdDevice);
mtouch->input.dev = &intf->dev; mtouch->input.dev = &intf->dev;
mtouch->input.evbit[0] = BIT(EV_KEY) | BIT(EV_ABS); mtouch->input.evbit[0] = BIT(EV_KEY) | BIT(EV_ABS);

6
drivers/usb/input/powermate.c
View File

@ -35,6 +35,7 @@
#include <linux/init.h> #include <linux/init.h>
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <linux/usb.h> #include <linux/usb.h>
#include <linux/usb_input.h>
#define POWERMATE_VENDOR 0x077d /* Griffin Technology, Inc. */ #define POWERMATE_VENDOR 0x077d /* Griffin Technology, Inc. */
#define POWERMATE_PRODUCT_NEW 0x0410 /* Griffin PowerMate */ #define POWERMATE_PRODUCT_NEW 0x0410 /* Griffin PowerMate */
@ -389,10 +390,7 @@ static int powermate_probe(struct usb_interface *intf, const struct usb_device_i
pm->input.keybit[LONG(BTN_0)] = BIT(BTN_0); pm->input.keybit[LONG(BTN_0)] = BIT(BTN_0);
pm->input.relbit[LONG(REL_DIAL)] = BIT(REL_DIAL); pm->input.relbit[LONG(REL_DIAL)] = BIT(REL_DIAL);
pm->input.mscbit[LONG(MSC_PULSELED)] = BIT(MSC_PULSELED); pm->input.mscbit[LONG(MSC_PULSELED)] = BIT(MSC_PULSELED);
pm->input.id.bustype = BUS_USB; usb_to_input_id(udev, &pm->input.id);
pm->input.id.vendor = le16_to_cpu(udev->descriptor.idVendor);
pm->input.id.product = le16_to_cpu(udev->descriptor.idProduct);
pm->input.id.version = le16_to_cpu(udev->descriptor.bcdDevice);
pm->input.event = powermate_input_event; pm->input.event = powermate_input_event;
pm->input.dev = &intf->dev; pm->input.dev = &intf->dev;
pm->input.phys = pm->phys; pm->input.phys = pm->phys;

7
drivers/usb/input/touchkitusb.c
View File

@ -35,7 +35,7 @@
#define DEBUG #define DEBUG
#endif #endif
#include <linux/usb.h> #include <linux/usb.h>
#include <linux/usb_input.h>
#define TOUCHKIT_MIN_XC 0x0 #define TOUCHKIT_MIN_XC 0x0
#define TOUCHKIT_MAX_XC 0x07ff #define TOUCHKIT_MAX_XC 0x07ff
@ -202,10 +202,7 @@ static int touchkit_probe(struct usb_interface *intf,
touchkit->input.name = touchkit->name; touchkit->input.name = touchkit->name;
touchkit->input.phys = touchkit->phys; touchkit->input.phys = touchkit->phys;
touchkit->input.id.bustype = BUS_USB; usb_to_input_id(udev, &touchkit->input.id);
touchkit->input.id.vendor = le16_to_cpu(udev->descriptor.idVendor);
touchkit->input.id.product = le16_to_cpu(udev->descriptor.idProduct);
touchkit->input.id.version = le16_to_cpu(udev->descriptor.bcdDevice);
touchkit->input.dev = &intf->dev; touchkit->input.dev = &intf->dev;
touchkit->input.evbit[0] = BIT(EV_KEY) | BIT(EV_ABS); touchkit->input.evbit[0] = BIT(EV_KEY) | BIT(EV_ABS);

6
drivers/usb/input/usbkbd.c
View File

@ -32,6 +32,7 @@
#include <linux/input.h> #include <linux/input.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/usb.h> #include <linux/usb.h>
#include <linux/usb_input.h>
/* /*
* Version Information * Version Information
@ -288,10 +289,7 @@ static int usb_kbd_probe(struct usb_interface *iface,
kbd->dev.name = kbd->name; kbd->dev.name = kbd->name;
kbd->dev.phys = kbd->phys; kbd->dev.phys = kbd->phys;
kbd->dev.id.bustype = BUS_USB; usb_to_input_id(dev, &kbd->dev.id);
kbd->dev.id.vendor = le16_to_cpu(dev->descriptor.idVendor);
kbd->dev.id.product = le16_to_cpu(dev->descriptor.idProduct);
kbd->dev.id.version = le16_to_cpu(dev->descriptor.bcdDevice);
kbd->dev.dev = &iface->dev; kbd->dev.dev = &iface->dev;
if (dev->manufacturer) if (dev->manufacturer)

6
drivers/usb/input/usbmouse.c
View File

@ -32,6 +32,7 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/usb.h> #include <linux/usb.h>
#include <linux/usb_input.h>
/* /*
* Version Information * Version Information
@ -171,10 +172,7 @@ static int usb_mouse_probe(struct usb_interface * intf, const struct usb_device_
mouse->dev.name = mouse->name; mouse->dev.name = mouse->name;
mouse->dev.phys = mouse->phys; mouse->dev.phys = mouse->phys;
mouse->dev.id.bustype = BUS_USB; usb_to_input_id(dev, &mouse->dev.id);
mouse->dev.id.vendor = le16_to_cpu(dev->descriptor.idVendor);
mouse->dev.id.product = le16_to_cpu(dev->descriptor.idProduct);
mouse->dev.id.version = le16_to_cpu(dev->descriptor.bcdDevice);
mouse->dev.dev = &intf->dev; mouse->dev.dev = &intf->dev;
if (dev->manufacturer) if (dev->manufacturer)

6
drivers/usb/input/wacom.c
View File

@ -69,6 +69,7 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/usb.h> #include <linux/usb.h>
#include <linux/usb_input.h>
#include <asm/unaligned.h> #include <asm/unaligned.h>
#include <asm/byteorder.h> #include <asm/byteorder.h>
@ -823,10 +824,7 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
wacom->dev.name = wacom->features->name; wacom->dev.name = wacom->features->name;
wacom->dev.phys = wacom->phys; wacom->dev.phys = wacom->phys;
wacom->dev.id.bustype = BUS_USB; usb_to_input_id(dev, &wacom->dev.id);
wacom->dev.id.vendor = le16_to_cpu(dev->descriptor.idVendor);
wacom->dev.id.product = le16_to_cpu(dev->descriptor.idProduct);
wacom->dev.id.version = le16_to_cpu(dev->descriptor.bcdDevice);
wacom->dev.dev = &intf->dev; wacom->dev.dev = &intf->dev;
wacom->usbdev = dev; wacom->usbdev = dev;

6
drivers/usb/input/xpad.c
View File

@ -62,6 +62,7 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/smp_lock.h> #include <linux/smp_lock.h>
#include <linux/usb.h> #include <linux/usb.h>
#include <linux/usb_input.h>
#define DRIVER_VERSION "v0.0.5" #define DRIVER_VERSION "v0.0.5"
#define DRIVER_AUTHOR "Marko Friedemann <mfr@bmx-chemnitz.de>" #define DRIVER_AUTHOR "Marko Friedemann <mfr@bmx-chemnitz.de>"
@ -256,10 +257,7 @@ static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id
xpad->udev = udev; xpad->udev = udev;
xpad->dev.id.bustype = BUS_USB; usb_to_input_id(udev, &xpad->dev.id);
xpad->dev.id.vendor = le16_to_cpu(udev->descriptor.idVendor);
xpad->dev.id.product = le16_to_cpu(udev->descriptor.idProduct);
xpad->dev.id.version = le16_to_cpu(udev->descriptor.bcdDevice);
xpad->dev.dev = &intf->dev; xpad->dev.dev = &intf->dev;
xpad->dev.private = xpad; xpad->dev.private = xpad;
xpad->dev.name = xpad_device[i].name; xpad->dev.name = xpad_device[i].name;

6
drivers/usb/media/konicawc.c
View File

@ -16,6 +16,7 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/input.h> #include <linux/input.h>
#include <linux/usb_input.h>
#include "usbvideo.h" #include "usbvideo.h"
@ -845,10 +846,7 @@ static int konicawc_probe(struct usb_interface *intf, const struct usb_device_id
cam->input.private = cam; cam->input.private = cam;
cam->input.evbit[0] = BIT(EV_KEY); cam->input.evbit[0] = BIT(EV_KEY);
cam->input.keybit[LONG(BTN_0)] = BIT(BTN_0); cam->input.keybit[LONG(BTN_0)] = BIT(BTN_0);
cam->input.id.bustype = BUS_USB; usb_to_input_id(dev, &cam->input.id);
cam->input.id.vendor = le16_to_cpu(dev->descriptor.idVendor);
cam->input.id.product = le16_to_cpu(dev->descriptor.idProduct);
cam->input.id.version = le16_to_cpu(dev->descriptor.bcdDevice);
input_register_device(&cam->input); input_register_device(&cam->input);
usb_make_path(dev, cam->input_physname, 56); usb_make_path(dev, cam->input_physname, 56);

6
include/linux/input.h
View File

@ -811,9 +811,9 @@ struct input_dev {
void *private; void *private;
char *name; const char *name;
char *phys; const char *phys;
char *uniq; const char *uniq;
struct input_id id; struct input_id id;
unsigned long evbit[NBITS(EV_MAX)]; unsigned long evbit[NBITS(EV_MAX)];

5
include/linux/uinput.h
View File

@ -42,8 +42,7 @@ struct uinput_request {
int code; /* UI_FF_UPLOAD, UI_FF_ERASE */ int code; /* UI_FF_UPLOAD, UI_FF_ERASE */
int retval; int retval;
wait_queue_head_t waitq; struct completion done;
int completed;
union { union {
int effect_id; int effect_id;
@ -62,7 +61,7 @@ struct uinput_device {
struct uinput_request *requests[UINPUT_NUM_REQUESTS]; struct uinput_request *requests[UINPUT_NUM_REQUESTS];
wait_queue_head_t requests_waitq; wait_queue_head_t requests_waitq;
struct semaphore requests_sem; spinlock_t requests_lock;
}; };
#endif /* __KERNEL__ */ #endif /* __KERNEL__ */

25
include/linux/usb_input.h Normal file
View File

@ -0,0 +1,25 @@
#ifndef __USB_INPUT_H
#define __USB_INPUT_H
/*
* Copyright (C) 2005 Dmitry Torokhov
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 as published by
* the Free Software Foundation.
*/
#include <linux/usb.h>
#include <linux/input.h>
#include <asm/byteorder.h>
static inline void
usb_to_input_id(const struct usb_device *dev, struct input_id *id)
{
id->bustype = BUS_USB;
id->vendor = le16_to_cpu(dev->descriptor.idVendor);
id->product = le16_to_cpu(dev->descriptor.idProduct);
id->version = le16_to_cpu(dev->descriptor.bcdDevice);
}
#endif