]> nv-tegra.nvidia Code Review - linux-3.10.git/commitdiff
Merge master.kernel.org:/pub/scm/linux/kernel/git/dtor/input
authorLinus Torvalds <torvalds@g5.osdl.org>
Fri, 29 Jul 2005 16:48:34 +0000 (09:48 -0700)
committerLinus Torvalds <torvalds@g5.osdl.org>
Fri, 29 Jul 2005 16:48:34 +0000 (09:48 -0700)
34 files changed:
drivers/char/keyboard.c
drivers/char/sonypi.c
drivers/input/evdev.c
drivers/input/input.c
drivers/input/joydev.c
drivers/input/misc/uinput.c
drivers/input/mouse/alps.c
drivers/input/mouse/logips2pp.c
drivers/input/mouse/psmouse-base.c
drivers/input/mouse/synaptics.c
drivers/input/serio/Kconfig
drivers/input/serio/i8042-x86ia64io.h
drivers/input/serio/i8042.c
drivers/input/serio/serio.c
drivers/input/serio/serio_raw.c
drivers/input/touchscreen/Kconfig
drivers/usb/input/acecad.c
drivers/usb/input/aiptek.c
drivers/usb/input/ati_remote.c
drivers/usb/input/hid-core.c
drivers/usb/input/hid-input.c
drivers/usb/input/itmtouch.c
drivers/usb/input/kbtab.c
drivers/usb/input/mtouchusb.c
drivers/usb/input/powermate.c
drivers/usb/input/touchkitusb.c
drivers/usb/input/usbkbd.c
drivers/usb/input/usbmouse.c
drivers/usb/input/wacom.c
drivers/usb/input/xpad.c
drivers/usb/media/konicawc.c
include/linux/input.h
include/linux/uinput.h
include/linux/usb_input.h [new file with mode: 0644]

index 7b19e02f112fd585d02fe48e4eb1eb8c2a0001cc..523fd3c8bbaa75dd345224799990ec0c4f4e5e93 100644 (file)
@@ -198,10 +198,10 @@ int setkeycode(unsigned int scancode, unsigned int keycode)
 
        if (scancode >= dev->keycodemax)
                return -EINVAL;
-       if (keycode > KEY_MAX)
-               return -EINVAL;
        if (keycode < 0 || keycode > KEY_MAX)
                return -EINVAL;
+       if (keycode >> (dev->keycodesize * 8))
+               return -EINVAL;
 
        oldkey = SET_INPUT_KEYCODE(dev, scancode, keycode);
 
index fd042060809a3b5572183f6874219d890261a09b..cefbe985e55cf57e94f07f52d7bc57e6e11834f3 100644 (file)
@@ -439,6 +439,11 @@ static struct {
        { 0, 0 },
 };
 
+struct sonypi_keypress {
+       struct input_dev *dev;
+       int key;
+};
+
 static struct sonypi_device {
        struct pci_dev *dev;
        struct platform_device *pdev;
@@ -710,22 +715,61 @@ static void sonypi_setbluetoothpower(u8 state)
 
 static void input_keyrelease(void *data)
 {
-       struct input_dev *input_dev;
-       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;
+       struct sonypi_keypress kp;
 
+       while (kfifo_get(sonypi_device.input_fifo, (unsigned char *)&kp,
+                        sizeof(kp)) == sizeof(kp)) {
                msleep(10);
-               input_report_key(input_dev, key, 0);
-               input_sync(input_dev);
+               input_report_key(kp.dev, kp.key, 0);
+               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
                       "sonypi: event port1=0x%02x,port2=0x%02x\n", v1, v2);
 
-       if (useinput) {
-               struct input_dev *input_jog_dev = &sonypi_device.input_jog_dev;
-               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);
-       }
+       if (useinput)
+               sonypi_report_input_event(event);
 
        kfifo_put(sonypi_device.fifo, (unsigned char *)&event, sizeof(event));
        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)] =
                        BIT(BTN_MIDDLE);
                sonypi_device.input_jog_dev.relbit[0] = BIT(REL_WHEEL);
-               sonypi_device.input_jog_dev.name =
-                       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.name = SONYPI_JOG_INPUTNAME;
                sonypi_device.input_jog_dev.id.bustype = BUS_ISA;
                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)
                                set_bit(sonypi_inputkeys[i].inputev,
                                        sonypi_device.input_key_dev.keybit);
-               sonypi_device.input_key_dev.name =
-                       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.name = SONYPI_KEY_INPUTNAME;
                sonypi_device.input_key_dev.id.bustype = BUS_ISA;
                sonypi_device.input_key_dev.id.vendor = PCI_VENDOR_ID_SONY;
 
@@ -1313,11 +1300,7 @@ out_platformdev:
        kfifo_free(sonypi_device.input_fifo);
 out_infifo:
        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);
-       kfree(sonypi_device.input_jog_dev.name);
-out_inkmallocinput1:
        free_irq(sonypi_device.irq, sonypi_irq);
 out_reqirq:
        release_region(sonypi_device.ioport1, sonypi_device.region_size);
@@ -1337,13 +1320,14 @@ static void __devexit sonypi_remove(void)
 {
        sonypi_disable();
 
+       synchronize_sched();  /* Allow sonypi interrupt to complete. */
+       flush_scheduled_work();
+
        platform_device_unregister(sonypi_device.pdev);
 
        if (useinput) {
                input_unregister_device(&sonypi_device.input_key_dev);
-               kfree(sonypi_device.input_key_dev.name);
                input_unregister_device(&sonypi_device.input_jog_dev);
-               kfree(sonypi_device.input_jog_dev.name);
                kfifo_free(sonypi_device.input_fifo);
        }
 
index 374f404e81da32592596953b4403fc6571ca9f41..20e3a165989fb943b0ce29a2009120ce86b57f0b 100644 (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 (get_user(v, ip + 1)) return -EFAULT;
                        if (v < 0 || v > KEY_MAX) return -EINVAL;
+                       if (v >> (dev->keycodesize * 8)) return -EINVAL;
                        u = SET_INPUT_KEYCODE(dev, t, v);
                        clear_bit(u, dev->keybit);
                        set_bit(v, dev->keybit);
index 7c4b4d37b3e657698808baf1e8366f056bc64065..a275211c8e1e3434a2788771b63b68077807892f 100644 (file)
@@ -48,12 +48,6 @@ static LIST_HEAD(input_handler_list);
 
 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)
 {
        struct input_handle *handle;
@@ -312,6 +306,7 @@ static struct input_device_id *input_match_device(struct input_device_id *id, st
        return NULL;
 }
 
+
 /*
  * Input hotplugging interface - loading event handlers based on
  * device bitfields.
@@ -428,6 +423,177 @@ static void input_call_hotplug(char *verb, struct input_dev *dev)
 
 #endif
 
+#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++;
+       wake_up(&input_devices_poll_wait);
+}
+
+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;
+}
+
+#define SPRINTF_BIT_B(bit, name, max) \
+       do { \
+               len += sprintf(buf + len, "B: %s", name); \
+               for (i = NBITS(max) - 1; i >= 0; i--) \
+                       if (dev->bit[i]) break; \
+               for (; i >= 0; i--) \
+                       len += sprintf(buf + len, "%lx ", dev->bit[i]); \
+               len += sprintf(buf + len, "\n"); \
+       } while (0)
+
+#define SPRINTF_BIT_B2(bit, name, max, ev) \
+       do { \
+               if (test_bit(ev, dev->evbit)) \
+                       SPRINTF_BIT_B(bit, name, max); \
+       } while (0)
+
+static int input_devices_read(char *buf, char **start, off_t pos, int count, int *eof, void *data)
+{
+       struct input_dev *dev;
+       struct input_handle *handle;
+
+       off_t at = 0;
+       int i, len, cnt = 0;
+
+       list_for_each_entry(dev, &input_dev_list, node) {
+
+               len = sprintf(buf, "I: Bus=%04x Vendor=%04x Product=%04x Version=%04x\n",
+                       dev->id.bustype, dev->id.vendor, dev->id.product, dev->id.version);
+
+               len += sprintf(buf + len, "N: Name=\"%s\"\n", dev->name ? dev->name : "");
+               len += sprintf(buf + len, "P: Phys=%s\n", dev->phys ? dev->phys : "");
+               len += sprintf(buf + len, "H: Handlers=");
+
+               list_for_each_entry(handle, &dev->h_list, d_node)
+                       len += sprintf(buf + len, "%s ", handle->name);
+
+               len += sprintf(buf + len, "\n");
+
+               SPRINTF_BIT_B(evbit, "EV=", EV_MAX);
+               SPRINTF_BIT_B2(keybit, "KEY=", KEY_MAX, EV_KEY);
+               SPRINTF_BIT_B2(relbit, "REL=", REL_MAX, EV_REL);
+               SPRINTF_BIT_B2(absbit, "ABS=", ABS_MAX, EV_ABS);
+               SPRINTF_BIT_B2(mscbit, "MSC=", MSC_MAX, EV_MSC);
+               SPRINTF_BIT_B2(ledbit, "LED=", LED_MAX, EV_LED);
+               SPRINTF_BIT_B2(sndbit, "SND=", SND_MAX, EV_SND);
+               SPRINTF_BIT_B2(ffbit,  "FF=",  FF_MAX, EV_FF);
+
+               len += sprintf(buf + len, "\n");
+
+               at += len;
+
+               if (at >= pos) {
+                       if (!*start) {
+                               *start = buf + (pos - (at - len));
+                               cnt = at - pos;
+                       } else  cnt += len;
+                       buf += len;
+                       if (cnt >= count)
+                               break;
+               }
+       }
+
+       if (&dev->node == &input_dev_list)
+               *eof = 1;
+
+       return (count > cnt) ? cnt : count;
+}
+
+static int input_handlers_read(char *buf, char **start, off_t pos, int count, int *eof, void *data)
+{
+       struct input_handler *handler;
+
+       off_t at = 0;
+       int len = 0, cnt = 0;
+       int i = 0;
+
+       list_for_each_entry(handler, &input_handler_list, node) {
+
+               if (handler->fops)
+                       len = sprintf(buf, "N: Number=%d Name=%s Minor=%d\n",
+                               i++, handler->name, handler->minor);
+               else
+                       len = sprintf(buf, "N: Number=%d Name=%s\n",
+                               i++, handler->name);
+
+               at += len;
+
+               if (at >= pos) {
+                       if (!*start) {
+                               *start = buf + (pos - (at - len));
+                               cnt = at - pos;
+                       } else  cnt += len;
+                       buf += len;
+                       if (cnt >= count)
+                               break;
+               }
+       }
+       if (&handler->node == &input_handler_list)
+               *eof = 1;
+
+       return (count > cnt) ? cnt : count;
+}
+
+static struct file_operations input_fileops;
+
+static int __init input_proc_init(void)
+{
+       struct proc_dir_entry *entry;
+
+       proc_bus_input_dir = proc_mkdir("input", proc_bus);
+       if (!proc_bus_input_dir)
+               return -ENOMEM;
+
+       proc_bus_input_dir->owner = THIS_MODULE;
+
+       entry = create_proc_read_entry("devices", 0, proc_bus_input_dir, input_devices_read, NULL);
+       if (!entry)
+               goto fail1;
+
+       entry->owner = THIS_MODULE;
+       input_fileops = *entry->proc_fops;
+       entry->proc_fops = &input_fileops;
+       entry->proc_fops->poll = input_devices_poll;
+
+       entry = create_proc_read_entry("handlers", 0, proc_bus_input_dir, input_handlers_read, NULL);
+       if (!entry)
+               goto fail2;
+
+       entry->owner = THIS_MODULE;
+
+       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 */
+static inline void input_wakeup_procfs_readers(void) { }
+static inline int input_proc_init(void) { return 0; }
+static inline void input_proc_exit(void) { }
+#endif
+
 void input_register_device(struct input_dev *dev)
 {
        struct input_handle *handle;
@@ -464,10 +630,7 @@ void input_register_device(struct input_dev *dev)
        input_call_hotplug("add", dev);
 #endif
 
-#ifdef CONFIG_PROC_FS
-       input_devices_state++;
-       wake_up(&input_devices_poll_wait);
-#endif
+       input_wakeup_procfs_readers();
 }
 
 void input_unregister_device(struct input_dev *dev)
@@ -491,10 +654,7 @@ void input_unregister_device(struct input_dev *dev)
 
        list_del_init(&dev->node);
 
-#ifdef CONFIG_PROC_FS
-       input_devices_state++;
-       wake_up(&input_devices_poll_wait);
-#endif
+       input_wakeup_procfs_readers();
 }
 
 void input_register_handler(struct input_handler *handler)
@@ -518,10 +678,7 @@ void input_register_handler(struct input_handler *handler)
                                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
+       input_wakeup_procfs_readers();
 }
 
 void input_unregister_handler(struct input_handler *handler)
@@ -540,10 +697,7 @@ void input_unregister_handler(struct input_handler *handler)
        if (handler->fops != NULL)
                input_table[handler->minor >> 5] = NULL;
 
-#ifdef CONFIG_PROC_FS
-       input_devices_state++;
-       wake_up(&input_devices_poll_wait);
-#endif
+       input_wakeup_procfs_readers();
 }
 
 static int input_open_file(struct inode *inode, struct file *file)
@@ -582,190 +736,43 @@ static struct file_operations input_fops = {
        .open = input_open_file,
 };
 
-#ifdef CONFIG_PROC_FS
-
-#define SPRINTF_BIT_B(bit, name, max) \
-       do { \
-               len += sprintf(buf + len, "B: %s", name); \
-               for (i = NBITS(max) - 1; i >= 0; i--) \
-                       if (dev->bit[i]) break; \
-               for (; i >= 0; i--) \
-                       len += sprintf(buf + len, "%lx ", dev->bit[i]); \
-               len += sprintf(buf + len, "\n"); \
-       } while (0)
-
-#define SPRINTF_BIT_B2(bit, name, max, ev) \
-       do { \
-               if (test_bit(ev, dev->evbit)) \
-                       SPRINTF_BIT_B(bit, name, max); \
-       } 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;
-}
+struct class *input_class;
 
-static int input_devices_read(char *buf, char **start, off_t pos, int count, int *eof, void *data)
+static int __init input_init(void)
 {
-       struct input_dev *dev;
-       struct input_handle *handle;
-
-       off_t at = 0;
-       int i, len, cnt = 0;
-
-       list_for_each_entry(dev, &input_dev_list, node) {
-
-               len = sprintf(buf, "I: Bus=%04x Vendor=%04x Product=%04x Version=%04x\n",
-                       dev->id.bustype, dev->id.vendor, dev->id.product, dev->id.version);
-
-               len += sprintf(buf + len, "N: Name=\"%s\"\n", dev->name ? dev->name : "");
-               len += sprintf(buf + len, "P: Phys=%s\n", dev->phys ? dev->phys : "");
-               len += sprintf(buf + len, "H: Handlers=");
-
-               list_for_each_entry(handle, &dev->h_list, d_node)
-                       len += sprintf(buf + len, "%s ", handle->name);
-
-               len += sprintf(buf + len, "\n");
-
-               SPRINTF_BIT_B(evbit, "EV=", EV_MAX);
-               SPRINTF_BIT_B2(keybit, "KEY=", KEY_MAX, EV_KEY);
-               SPRINTF_BIT_B2(relbit, "REL=", REL_MAX, EV_REL);
-               SPRINTF_BIT_B2(absbit, "ABS=", ABS_MAX, EV_ABS);
-               SPRINTF_BIT_B2(mscbit, "MSC=", MSC_MAX, EV_MSC);
-               SPRINTF_BIT_B2(ledbit, "LED=", LED_MAX, EV_LED);
-               SPRINTF_BIT_B2(sndbit, "SND=", SND_MAX, EV_SND);
-               SPRINTF_BIT_B2(ffbit,  "FF=",  FF_MAX, EV_FF);
-
-               len += sprintf(buf + len, "\n");
-
-               at += len;
+       int err;
 
-               if (at >= pos) {
-                       if (!*start) {
-                               *start = buf + (pos - (at - len));
-                               cnt = at - pos;
-                       } else  cnt += len;
-                       buf += len;
-                       if (cnt >= count)
-                               break;
-               }
+       input_class = class_create(THIS_MODULE, "input");
+       if (IS_ERR(input_class)) {
+               printk(KERN_ERR "input: unable to register input class\n");
+               return PTR_ERR(input_class);
        }
 
-       if (&dev->node == &input_dev_list)
-               *eof = 1;
-
-       return (count > cnt) ? cnt : count;
-}
-
-static int input_handlers_read(char *buf, char **start, off_t pos, int count, int *eof, void *data)
-{
-       struct input_handler *handler;
-
-       off_t at = 0;
-       int len = 0, cnt = 0;
-       int i = 0;
-
-       list_for_each_entry(handler, &input_handler_list, node) {
-
-               if (handler->fops)
-                       len = sprintf(buf, "N: Number=%d Name=%s Minor=%d\n",
-                               i++, handler->name, handler->minor);
-               else
-                       len = sprintf(buf, "N: Number=%d Name=%s\n",
-                               i++, handler->name);
-
-               at += len;
+       err = input_proc_init();
+       if (err)
+               goto fail1;
 
-               if (at >= pos) {
-                       if (!*start) {
-                               *start = buf + (pos - (at - len));
-                               cnt = at - pos;
-                       } else  cnt += len;
-                       buf += len;
-                       if (cnt >= count)
-                               break;
-               }
+       err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
+       if (err) {
+               printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);
+               goto fail2;
        }
-       if (&handler->node == &input_handler_list)
-               *eof = 1;
-
-       return (count > cnt) ? cnt : count;
-}
-
-static struct file_operations input_fileops;
 
-static int __init input_proc_init(void)
-{
-       struct proc_dir_entry *entry;
+       err = devfs_mk_dir("input");
+       if (err)
+               goto fail3;
 
-       proc_bus_input_dir = proc_mkdir("input", proc_bus);
-       if (proc_bus_input_dir == NULL)
-               return -ENOMEM;
-       proc_bus_input_dir->owner = THIS_MODULE;
-       entry = create_proc_read_entry("devices", 0, proc_bus_input_dir, input_devices_read, NULL);
-       if (entry == NULL) {
-               remove_proc_entry("input", proc_bus);
-               return -ENOMEM;
-       }
-       entry->owner = THIS_MODULE;
-       input_fileops = *entry->proc_fops;
-       entry->proc_fops = &input_fileops;
-       entry->proc_fops->poll = input_devices_poll;
-       entry = create_proc_read_entry("handlers", 0, proc_bus_input_dir, input_handlers_read, NULL);
-       if (entry == NULL) {
-               remove_proc_entry("devices", proc_bus_input_dir);
-               remove_proc_entry("input", proc_bus);
-               return -ENOMEM;
-       }
-       entry->owner = THIS_MODULE;
        return 0;
-}
-#else /* !CONFIG_PROC_FS */
-static inline int input_proc_init(void) { return 0; }
-#endif
 
-struct class *input_class;
-
-static int __init input_init(void)
-{
-       int retval = -ENOMEM;
-
-       input_class = class_create(THIS_MODULE, "input");
-       if (IS_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");
-       if (retval) {
-               remove_proc_entry("devices", proc_bus_input_dir);
-               remove_proc_entry("handlers", proc_bus_input_dir);
-               remove_proc_entry("input", proc_bus);
-               unregister_chrdev(INPUT_MAJOR, "input");
-               class_destroy(input_class);
-       }
-       return retval;
+ fail3:        unregister_chrdev(INPUT_MAJOR, "input");
+ fail2:        input_proc_exit();
+ fail1:        class_destroy(input_class);
+       return err;
 }
 
 static void __exit input_exit(void)
 {
-       remove_proc_entry("devices", proc_bus_input_dir);
-       remove_proc_entry("handlers", proc_bus_input_dir);
-       remove_proc_entry("input", proc_bus);
-
+       input_proc_exit();
        devfs_remove("input");
        unregister_chrdev(INPUT_MAJOR, "input");
        class_destroy(input_class);
index ff8e1bbd0e13e215926e4f133e589184bd23c52d..e0938d1d3ad791cba54a319f454d61111066ecb2 100644 (file)
@@ -37,8 +37,6 @@ MODULE_LICENSE("GPL");
 #define JOYDEV_MINORS          16
 #define JOYDEV_BUFFER_SIZE     64
 
-#define MSECS(t)       (1000 * ((t) / HZ) + 1000 * ((t) % HZ) / HZ)
-
 struct joydev {
        int exist;
        int open;
@@ -117,7 +115,7 @@ static void joydev_event(struct input_handle *handle, unsigned int type, unsigne
                        return;
        }
 
-       event.time = MSECS(jiffies);
+       event.time = jiffies_to_msecs(jiffies);
 
        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;
 
-               event.time = MSECS(jiffies);
+               event.time = jiffies_to_msecs(jiffies);
 
                if (list->startup < joydev->nkey) {
                        event.type = JS_EVENT_BUTTON | JS_EVENT_INIT;
index 98710997aaaa2c48f7cde8301ff8cc6b3b14f6a2..d5c5b32045af4d7cc6a4a95ddca785975a28dc4f 100644 (file)
 #include <linux/miscdevice.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)
 {
        struct uinput_device    *udev;
@@ -63,22 +53,24 @@ static int uinput_dev_event(struct input_dev *dev, unsigned int type, unsigned i
        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. */
-       struct uinput_device *udev = dev->private;
        int id;
+       int err = -1;
+
+       spin_lock(&udev->requests_lock);
 
-       down(&udev->requests_sem);
-       for (id=0; id<UINPUT_NUM_REQUESTS; id++)
+       for (id = 0; id < UINPUT_NUM_REQUESTS; id++)
                if (!udev->requests[id]) {
-                       udev->requests[id] = request;
                        request->id = id;
-                       up(&udev->requests_sem);
-                       return 0;
+                       udev->requests[id] = request;
+                       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)
@@ -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. */
        if (id >= UINPUT_NUM_REQUESTS || id < 0)
                return NULL;
-       if (udev->requests[id]->completed)
-               return NULL;
        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,
+                                       !uinput_request_alloc_id(udev, request));
+}
 
-       memset(request, 0, sizeof(struct uinput_request));
-       request->code = code;
-       init_waitqueue_head(&request->waitq);
+static void uinput_request_done(struct uinput_device *udev, struct uinput_request *request)
+{
+       complete(&request->done);
 
-       /* Allocate an ID. If none are available right away, wait. */
-       request->retval = wait_event_interruptible(udev->requests_waitq,
-                                      !uinput_request_alloc_id(dev, request));
+       /* Mark slot as available */
+       udev->requests[request->id] = NULL;
+       wake_up_interruptible(&udev->requests_waitq);
 }
 
-static void uinput_request_submit(struct input_dev *dev, struct uinput_request *request)
+static int uinput_request_submit(struct input_dev *dev, struct uinput_request *request)
 {
-       struct uinput_device *udev = dev->private;
        int retval;
 
        /* Tell our userspace app about this new request by queueing an input event */
        uinput_dev_event(dev, EV_UINPUT, request->code, request->id);
 
        /* Wait for the request to complete */
-       retval = wait_event_interruptible(request->waitq, request->completed);
-       if (retval)
-               request->retval = retval;
+       retval = wait_for_completion_interruptible(&request->done);
+       if (!retval)
+               retval = request->retval;
 
-       /* Release this request's ID, let others know it's available */
-       udev->requests[request->id] = NULL;
-       wake_up_interruptible(&udev->requests_waitq);
+       return retval;
 }
 
 static int uinput_dev_upload_effect(struct input_dev *dev, struct ff_effect *effect)
 {
        struct uinput_request request;
+       int retval;
 
        if (!test_bit(EV_FF, dev->evbit))
                return -ENOSYS;
 
-       uinput_request_init(dev, &request, UI_FF_UPLOAD);
-       if (request.retval)
-               return request.retval;
+       request.id = -1;
+       init_completion(&request.done);
+       request.code = UI_FF_UPLOAD;
        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)
 {
        struct uinput_request request;
+       int retval;
 
        if (!test_bit(EV_FF, dev->evbit))
                return -ENOSYS;
 
-       uinput_request_init(dev, &request, UI_FF_ERASE);
-       if (request.retval)
-               return request.retval;
+       request.id = -1;
+       init_completion(&request.done);
+       request.code = UI_FF_ERASE;
        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)
@@ -159,32 +159,30 @@ static int uinput_create_device(struct uinput_device *udev)
                return -EINVAL;
        }
 
-       udev->dev->open = uinput_dev_open;
-       udev->dev->close = uinput_dev_close;
        udev->dev->event = uinput_dev_event;
        udev->dev->upload_effect = uinput_dev_upload_effect;
        udev->dev->erase_effect = uinput_dev_erase_effect;
        udev->dev->private = udev;
 
-       init_waitqueue_head(&(udev->waitq));
+       init_waitqueue_head(&udev->waitq);
 
        input_register_device(udev->dev);
 
-       set_bit(UIST_CREATED, &(udev->state));
+       set_bit(UIST_CREATED, &udev->state);
 
        return 0;
 }
 
 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);
                return -EINVAL;
        }
 
        input_unregister_device(udev->dev);
 
-       clear_bit(UIST_CREATED, &(udev->state));
+       clear_bit(UIST_CREATED, &udev->state);
 
        return 0;
 }
@@ -198,7 +196,7 @@ static int uinput_open(struct inode *inode, struct file *file)
        if (!newdev)
                goto error;
        memset(newdev, 0, sizeof(struct uinput_device));
-       init_MUTEX(&newdev->requests_sem);
+       spin_lock_init(&newdev->requests_lock);
        init_waitqueue_head(&newdev->requests_waitq);
 
        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 input_dev        *dev;
        struct uinput_device    *udev;
-       int                     size,
-                               retval;
+       char                    *name;
+       int                     size;
+       int                     retval;
 
        retval = count;
 
        udev = file->private_data;
        dev = udev->dev;
 
-       user_dev = kmalloc(sizeof(*user_dev), GFP_KERNEL);
+       user_dev = kmalloc(sizeof(struct uinput_user_dev), GFP_KERNEL);
        if (!user_dev) {
                retval = -ENOMEM;
                goto exit;
@@ -272,17 +271,17 @@ static int uinput_alloc_device(struct file *file, const char __user *buffer, siz
                goto exit;
        }
 
-       if (NULL != dev->name)
+       if (dev->name)
                kfree(dev->name);
 
        size = strnlen(user_dev->name, UINPUT_MAX_NAME_SIZE) + 1;
-       dev->name = kmalloc(size, GFP_KERNEL);
-       if (!dev->name) {
+       dev->name = name = kmalloc(size, GFP_KERNEL);
+       if (!name) {
                retval = -ENOMEM;
                goto exit;
        }
+       strlcpy(name, user_dev->name, size);
 
-       strlcpy(dev->name, user_dev->name, size);
        dev->id.bustype = user_dev->id.bustype;
        dev->id.vendor  = user_dev->id.vendor;
        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;
 
-       if (test_bit(UIST_CREATED, &(udev->state))) {
+       if (test_bit(UIST_CREATED, &udev->state)) {
                struct input_event      ev;
 
                if (copy_from_user(&ev, buffer, sizeof(struct input_event)))
                        return -EFAULT;
                input_event(udev->dev, ev.type, ev.code, ev.value);
-       }
-       else
+       } else
                count = uinput_alloc_device(file, buffer, 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;
        int retval = 0;
 
-       if (!test_bit(UIST_CREATED, &(udev->state)))
+       if (!test_bit(UIST_CREATED, &udev->state))
                return -ENODEV;
 
-       if ((udev->head == udev->tail) && (file->f_flags & O_NONBLOCK))
+       if (udev->head == udev->tail && (file->f_flags & O_NONBLOCK))
                return -EAGAIN;
 
        retval = wait_event_interruptible(udev->waitq,
-                       (udev->head != udev->tail) ||
-                       !test_bit(UIST_CREATED, &(udev->state)));
-
+                       udev->head != udev->tail || !test_bit(UIST_CREATED, &udev->state));
        if (retval)
                return retval;
 
-       if (!test_bit(UIST_CREATED, &(udev->state)))
+       if (!test_bit(UIST_CREATED, &udev->state))
                return -ENODEV;
 
        while ((udev->head != udev->tail) &&
            (retval + sizeof(struct input_event) <= count)) {
-               if (copy_to_user(buffer + retval, &(udev->buff[udev->tail]),
-                   sizeof(struct input_event))) return -EFAULT;
+               if (copy_to_user(buffer + retval, &udev->buff[udev->tail], sizeof(struct input_event)))
+                       return -EFAULT;
                udev->tail = (udev->tail + 1) % UINPUT_BUFFER_SIZE;
                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)
 {
-       if (test_bit(UIST_CREATED, &(udev->state)))
+       if (test_bit(UIST_CREATED, &udev->state))
                uinput_destroy_device(udev);
 
-       if (NULL != udev->dev->name)
+       if (udev->dev->name)
                kfree(udev->dev->name);
-       if (NULL != udev->dev->phys)
+       if (udev->dev->phys)
                kfree(udev->dev->phys);
 
        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)
 {
-       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)
@@ -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_request   *req;
        int                     length;
+       char                    *phys;
 
        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_FFBIT:
                case UI_SET_PHYS:
-                       if (test_bit(UIST_CREATED, &(udev->state)))
+                       if (test_bit(UIST_CREATED, &udev->state))
                                return -EINVAL;
        }
 
@@ -498,20 +496,19 @@ static int uinput_ioctl(struct inode *inode, struct file *file, unsigned int cmd
                                retval = -EFAULT;
                                break;
                        }
-                       if (NULL != udev->dev->phys)
-                               kfree(udev->dev->phys);
-                       udev->dev->phys = kmalloc(length, GFP_KERNEL);
-                       if (!udev->dev->phys) {
+                       kfree(udev->dev->phys);
+                       udev->dev->phys = phys = kmalloc(length, GFP_KERNEL);
+                       if (!phys) {
                                retval = -ENOMEM;
                                break;
                        }
-                       if (copy_from_user(udev->dev->phys, p, length)) {
-                               retval = -EFAULT;
-                               kfree(udev->dev->phys);
+                       if (copy_from_user(phys, p, length)) {
                                udev->dev->phys = NULL;
+                               kfree(phys);
+                               retval = -EFAULT;
                                break;
                        }
-                       udev->dev->phys[length-1] = '\0';
+                       phys[length - 1] = '\0';
                        break;
 
                case UI_BEGIN_FF_UPLOAD:
@@ -520,7 +517,7 @@ static int uinput_ioctl(struct inode *inode, struct file *file, unsigned int cmd
                                break;
                        }
                        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;
                                break;
                        }
@@ -538,7 +535,7 @@ static int uinput_ioctl(struct inode *inode, struct file *file, unsigned int cmd
                                break;
                        }
                        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;
                                break;
                        }
@@ -556,14 +553,13 @@ static int uinput_ioctl(struct inode *inode, struct file *file, unsigned int cmd
                                break;
                        }
                        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;
                                break;
                        }
                        req->retval = ff_up.retval;
                        memcpy(req->u.effect, &ff_up.effect, sizeof(struct ff_effect));
-                       req->completed = 1;
-                       wake_up_interruptible(&req->waitq);
+                       uinput_request_done(udev, req);
                        break;
 
                case UI_END_FF_ERASE:
@@ -572,13 +568,12 @@ static int uinput_ioctl(struct inode *inode, struct file *file, unsigned int cmd
                                break;
                        }
                        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;
                                break;
                        }
                        req->retval = ff_erase.retval;
-                       req->completed = 1;
-                       wake_up_interruptible(&req->waitq);
+                       uinput_request_done(udev, req);
                        break;
 
                default:
index a12e98158a759f87a199fa271d295017f468810c..0d68e5e0182aea89825963b8fc87b291ae320fd9 100644 (file)
@@ -2,7 +2,7 @@
  * ALPS touchpad PS/2 mouse driver
  *
  * 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) 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)
 {
        struct alps_data *priv = psmouse->private;
-       unsigned char param[4];
        int version;
 
        psmouse_reset(psmouse);
@@ -358,21 +357,20 @@ static int alps_reconnect(struct psmouse *psmouse)
        if (!(priv->i = alps_get_model(psmouse, &version)))
                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;
 
-       if (alps_get_status(psmouse, param))
+       if (alps_tap_mode(psmouse, 1)) {
+               printk(KERN_WARNING "alps.c: Failed to reenable hardware tapping\n");
                return -1;
-
-       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");
+               printk(KERN_ERR "alps.c: Failed to reenable absolute mode\n");
                return -1;
        }
 
-       if (priv->i->flags == ALPS_PASS && alps_passthrough_mode(psmouse, 0))
+       if ((priv->i->flags & ALPS_PASS) && alps_passthrough_mode(psmouse, 0))
                return -1;
 
        return 0;
@@ -389,7 +387,6 @@ static void alps_disconnect(struct psmouse *psmouse)
 int alps_init(struct psmouse *psmouse)
 {
        struct alps_data *priv;
-       unsigned char param[4];
        int version;
 
        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))
                goto init_fail;
 
-       if (alps_get_status(psmouse, param)) {
-               printk(KERN_ERR "alps.c: touchpad status report request failed\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_tap_mode(psmouse, 1))
+               printk(KERN_WARNING "alps.c: Failed to enable hardware tapping\n");
 
        if (alps_absolute_mode(psmouse)) {
                printk(KERN_ERR "alps.c: Failed to enable absolute mode\n");
index 5ab1bd7d529d7d6daef4938fd075dfa53dec0659..48d2b20d264299b30cd6cac8441ecab38253c1d4 100644 (file)
@@ -385,8 +385,6 @@ int ps2pp_init(struct psmouse *psmouse, int set_properties)
 
                if (buttons < 3)
                        clear_bit(BTN_MIDDLE, psmouse->dev.keybit);
-               if (buttons < 2)
-                       clear_bit(BTN_RIGHT, psmouse->dev.keybit);
 
                if (model_info)
                        ps2pp_set_model_properties(psmouse, model_info, use_ps2pp);
index 19785a6c5abd790fdfba408ef84c6b477d9e64d6..2bb2fe78bdca988f34ccae1cdebf0ba0faff79c5 100644 (file)
@@ -344,6 +344,7 @@ static int intellimouse_detect(struct psmouse *psmouse, int set_properties)
                return -1;
 
        if (set_properties) {
+               set_bit(BTN_MIDDLE, psmouse->dev.keybit);
                set_bit(REL_WHEEL, psmouse->dev.relbit);
 
                if (!psmouse->vendor) psmouse->vendor = "Generic";
@@ -376,6 +377,7 @@ static int im_explorer_detect(struct psmouse *psmouse, int set_properties)
                return -1;
 
        if (set_properties) {
+               set_bit(BTN_MIDDLE, psmouse->dev.keybit);
                set_bit(REL_WHEEL, psmouse->dev.relbit);
                set_bit(BTN_SIDE, psmouse->dev.keybit);
                set_bit(BTN_EXTRA, psmouse->dev.keybit);
index 36c721227b681cfd4e28f3b7ac5cd0265c56d9b7..0293094224098b1b2aa46c71609fddad1b0239f3 100644 (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[4], 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);
        } else
                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 */
        if (child) {
-               if (child->type >= PSMOUSE_GENPS)
+               if (child->pktsize == 4)
                        priv->mode |= SYN_BIT_FOUR_BYTE_CLIENT;
                else
                        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"),
                },
        },
+       {
+               .ident = "Toshiba Dynabook",
+               .matches = {
+                       DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
+                       DMI_MATCH(DMI_PRODUCT_NAME , "dynabook"),
+               },
+       },
        { }
 };
 #endif
@@ -656,7 +663,8 @@ int synaptics_init(struct psmouse *psmouse)
         * thye same as rate of standard PS/2 mouse.
         */
        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;
        }
 #endif
index b3710733b36b1b6c2f97bf0123d89c68b2355194..98acf170252cfa351d67294d20dc960210a1e207 100644 (file)
@@ -175,7 +175,7 @@ config SERIO_RAW
          allocating minor 1 (that historically corresponds to /dev/psaux)
          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
          module will be called serio_raw.
index 0487ecbb8a49232d26b32a26c63b5e5911d31f02..03877c84e6ff97487b6585a5efa8c953619cd39d 100644 (file)
@@ -130,6 +130,13 @@ static struct dmi_system_id __initdata i8042_dmi_nomux_table[] = {
                        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",
                .matches = {
@@ -137,6 +144,13 @@ static struct dmi_system_id __initdata i8042_dmi_nomux_table[] = {
                        DMI_MATCH(DMI_PRODUCT_NAME, "Satellite P10"),
                },
        },
+       {
+               .ident = "Alienware Sentia",
+               .matches = {
+                       DMI_MATCH(DMI_SYS_VENDOR, "ALIENWARE"),
+                       DMI_MATCH(DMI_PRODUCT_NAME, "Sentia"),
+               },
+       },
        { }
 };
 
index a9bf549c8dc5b0e8f637f691938d7fd2bd9de2e5..708a1d3beab975100bd6dbf4f88754c9d99e3f2a 100644 (file)
@@ -100,7 +100,7 @@ struct i8042_port {
 static struct i8042_port i8042_ports[I8042_NUM_PORTS] = {
        {
                .disable        = I8042_CTR_KBDDIS,
-               .irqen          = I8042_CTR_KBDINT,
+               .irqen          = I8042_CTR_KBDINT,
                .mux            = -1,
                .name           = "KBD",
        },
@@ -191,41 +191,45 @@ static int i8042_flush(void)
 static int i8042_command(unsigned char *param, int command)
 {
        unsigned long flags;
-       int retval = 0, i = 0;
+       int i, retval, auxerr = 0;
 
        if (i8042_noloop && command == I8042_CMD_AUX_LOOP)
                return -1;
 
        spin_lock_irqsave(&i8042_lock, flags);
 
-       retval = i8042_wait_write();
-       if (!retval) {
-               dbg("%02x -> i8042 (command)", command & 0xff);
-               i8042_write_command(command & 0xff);
+       if ((retval = i8042_wait_write()))
+               goto out;
+
+       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 >> 12) & 0xf); i++) {
-                       if ((retval = i8042_wait_write())) break;
-                       dbg("%02x -> i8042 (parameter)", param[i]);
-                       i8042_write_data(param[i]);
-               }
+       for (i = 0; i < ((command >> 8) & 0xf); i++) {
+               if ((retval = i8042_wait_read()))
+                       goto out;
 
-       if (!retval)
-               for (i = 0; i < ((command >> 8) & 0xf); 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]);
+               if (command == I8042_CMD_AUX_LOOP &&
+                   !(i8042_read_status() & I8042_STR_AUXDATA)) {
+                       retval = auxerr = -1;
+                       goto out;
                }
 
-       spin_unlock_irqrestore(&i8042_lock, flags);
+               param[i] = i8042_read_data();
+               dbg("%02x <- i8042 (return)", param[i]);
+       }
 
        if (retval)
-               dbg("     -- i8042 (timeout)");
+               dbg("     -- i8042 (%s)", auxerr ? "auxerr" : "timeout");
 
+ out:
+       spin_unlock_irqrestore(&i8042_lock, flags);
        return retval;
 }
 
@@ -507,17 +511,17 @@ static int i8042_set_mux_mode(unsigned int mode, unsigned char *mux_version)
  */
 
        param = 0xf0;
-       if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param != 0x0f)
+       if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param != 0xf0)
                return -1;
        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;
        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;
 
        if (mux_version)
-               *mux_version = ~param;
+               *mux_version = param;
 
        return 0;
 }
@@ -619,7 +623,7 @@ static int __init i8042_check_aux(void)
  */
 
        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
@@ -630,7 +634,7 @@ static int __init i8042_check_aux(void)
  */
 
                if (i8042_command(&param, I8042_CMD_AUX_TEST)
-                       || (param && param != 0xfa && param != 0xff))
+                       || (param && param != 0xfa && param != 0xff))
                                return -1;
        }
 
index f367695e69b5c78e35a66ca731369f3e67b0550f..edd15db17715852ff05e1119ddd02b5de248e469 100644 (file)
@@ -389,6 +389,14 @@ static ssize_t serio_show_description(struct device *dev, struct device_attribut
        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)
 {
        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[] = {
        __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(bind_mode, S_IWUSR | S_IRUGO, serio_show_bind_mode, serio_set_bind_mode),
        __ATTR_NULL
@@ -785,36 +794,37 @@ static int serio_bus_match(struct device *dev, struct device_driver *drv)
 
 #ifdef CONFIG_HOTPLUG
 
-#define PUT_ENVP(fmt, val)                                             \
-do {                                                                   \
-       envp[i++] = buffer;                                             \
-       length += snprintf(buffer, buffer_size - length, fmt, val);     \
-       if (buffer_size - length <= 0 || i >= num_envp)                 \
-               return -ENOMEM;                                         \
-       length++;                                                       \
-       buffer += length;                                               \
-} while (0)
+#define SERIO_ADD_HOTPLUG_VAR(fmt, val...)                             \
+       do {                                                            \
+               int err = add_hotplug_env_var(envp, num_envp, &i,       \
+                                       buffer, buffer_size, &len,      \
+                                       fmt, val);                      \
+               if (err)                                                \
+                       return err;                                     \
+       } while (0)
+
 static int serio_hotplug(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size)
 {
        struct serio *serio;
        int i = 0;
-       int length = 0;
+       int len = 0;
 
        if (!dev)
                return -ENODEV;
 
        serio = to_serio_port(dev);
 
-       PUT_ENVP("SERIO_TYPE=%02x", serio->id.type);
-       PUT_ENVP("SERIO_PROTO=%02x", serio->id.proto);
-       PUT_ENVP("SERIO_ID=%02x", serio->id.id);
-       PUT_ENVP("SERIO_EXTRA=%02x", serio->id.extra);
-
+       SERIO_ADD_HOTPLUG_VAR("SERIO_TYPE=%02x", serio->id.type);
+       SERIO_ADD_HOTPLUG_VAR("SERIO_PROTO=%02x", serio->id.proto);
+       SERIO_ADD_HOTPLUG_VAR("SERIO_ID=%02x", serio->id.id);
+       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;
 
        return 0;
 }
-#undef PUT_ENVP
+#undef SERIO_ADD_HOTPLUG_VAR
 
 #else
 
index d914e7e93db4c483b63e77074cd903670c39db70..47e08de18d07adab295db158fa237b2cc5f83383 100644 (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.name = serio_raw->name;
+       serio_raw->dev.dev = &serio->dev;
        serio_raw->dev.fops = &serio_raw_fops;
 
        err = misc_register(&serio_raw->dev);
index 7e991274ea400beb5d8eaaf9ab72a72755469082..0489af5a80c95bcdf67c2c87e3159bed004eec55 100644 (file)
@@ -58,7 +58,7 @@ config TOUCHSCREEN_ELO
          If unsure, say N.
 
          To compile this driver as a module, choose M here: the
-         module will be called gunze.
+         module will be called elo.
 
 config TOUCHSCREEN_MTOUCH
        tristate "MicroTouch serial touchscreens"
index ebcf7c955800c6506e443597537e6d713190839f..13532f3e3efc4325ea1c4b516d2045fad3cfd0d4 100644 (file)
@@ -31,6 +31,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/usb.h>
+#include <linux/usb_input.h>
 
 /*
  * Version Information
@@ -87,8 +88,8 @@ static void usb_acecad_irq(struct urb *urb, struct pt_regs *regs)
        if (prox) {
                int x = data[1] | (data[2] << 8);
                int y = data[3] | (data[4] << 8);
-               /*Pressure should compute the same way for flair and 302*/
-               int pressure = data[5] | ((int)data[6] << 8);
+               /* Pressure should compute the same way for flair and 302 */
+               int pressure = data[5] | (data[6] << 8);
                int touch = data[0] & 0x01;
                int stylus = (data[0] & 0x10) >> 4;
                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);
 
 resubmit:
-       status = usb_submit_urb (urb, GFP_ATOMIC);
+       status = usb_submit_urb(urb, GFP_ATOMIC);
        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);
 }
 
@@ -212,10 +213,7 @@ static int usb_acecad_probe(struct usb_interface *intf, const struct usb_device_
 
        acecad->dev.name = acecad->name;
        acecad->dev.phys = acecad->phys;
-       acecad->dev.id.bustype = BUS_USB;
-       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);
+       usb_to_input_id(dev, &acecad->dev.id);
        acecad->dev.dev = &intf->dev;
 
        usb_fill_int_urb(acecad->irq, dev, pipe,
index 6bb0f25e8e935a0db0d5a68743740255f8f4e149..cd0cbfe207232a3fd32ca468a07811279b2b59db 100644 (file)
@@ -77,6 +77,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/usb.h>
+#include <linux/usb_input.h>
 #include <linux/sched.h>
 #include <asm/uaccess.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.name = "Aiptek";
        aiptek->inputdev.phys = aiptek->features.usbPath;
-       aiptek->inputdev.id.bustype = BUS_USB;
-       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);
+       usb_to_input_id(usbdev, &aiptek->inputdev.id);
        aiptek->inputdev.dev = &intf->dev;
 
        aiptek->usbdev = usbdev;
index 654ac454744db7acd7ddc454ce749f90599d3ce8..fd99681ee48355ab1866338f7200a1eac12f7c87 100644 (file)
@@ -94,6 +94,7 @@
 #include <linux/moduleparam.h>
 #include <linux/input.h>
 #include <linux/usb.h>
+#include <linux/usb_input.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->phys = ati_remote->phys;
 
-       idev->id.bustype = BUS_USB;
-       idev->id.vendor = le16_to_cpu(ati_remote->udev->descriptor.idVendor);
-       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);
+       usb_to_input_id(ati_remote->udev, &idev->id);
+       idev->dev = &ati_remote->udev->dev;
 }
 
 static int ati_remote_initialize(struct ati_remote *ati_remote)
index 2350e7a5ad70470e6183e4560bcc6d4847e34b85..b2cb2b35892e51eb57ebd80f7071f556831f5949 100644 (file)
@@ -789,12 +789,12 @@ static __inline__ int search(__s32 *array, __s32 value, unsigned n)
        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);
        if (hid->claimed & HID_CLAIMED_INPUT)
                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);
 }
 
@@ -804,7 +804,7 @@ static void hid_process_event(struct hid_device *hid, struct hid_field *field, s
  * 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 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++) {
 
                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;
                }
 
                if (field->value[n] >= min && field->value[n] <= max
                        && field->usage[field->value[n] - min].hid
                        && 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
                        && field->usage[value[n] - min].hid
                        && 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));
@@ -851,7 +851,7 @@ exit:
        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_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);
 
        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)
                hidinput_report_event(hid, report);
@@ -918,7 +918,7 @@ static void hid_irq_in(struct urb *urb, struct pt_regs *regs)
 
        switch (urb->status) {
                case 0:                 /* success */
-                       hid_input_report(HID_INPUT_REPORT, urb, regs);
+                       hid_input_report(HID_INPUT_REPORT, urb, 1, regs);
                        break;
                case -ECONNRESET:       /* unlink */
                case -ENOENT:
@@ -1142,7 +1142,7 @@ static void hid_ctrl(struct urb *urb, struct pt_regs *regs)
        switch (urb->status) {
                case 0:                 /* success */
                        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 -EILSEQ:           /* unplug timectrl on uhci */
                        unplug = 1;
@@ -1372,6 +1372,9 @@ void hid_init_reports(struct hid_device *hid)
 #define USB_VENDOR_ID_A4TECH           0x09da
 #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_DEVICE_ID_CYPRESS_MOUSE    0x0001
 #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_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_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 },
index 9ac1e90953347e1171f66a9316c9734b79db589b..e071c8eecceea96a64ab2ccb927f9b896e0922e5 100644 (file)
@@ -31,6 +31,7 @@
 #include <linux/kernel.h>
 #include <linux/input.h>
 #include <linux/usb.h>
+#include <linux/usb_input.h>
 
 #undef DEBUG
 
@@ -581,10 +582,7 @@ int hidinput_connect(struct hid_device *hid)
                                hidinput->input.name = hid->name;
                                hidinput->input.phys = hid->phys;
                                hidinput->input.uniq = hid->uniq;
-                               hidinput->input.id.bustype = BUS_USB;
-                               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);
+                               usb_to_input_id(dev, &hidinput->input.id);
                                hidinput->input.dev = &hid->intf->dev;
                        }
 
index 47dec6a1b344bf950e30cf921e605a78e118a3f5..0dc439f10823a90f1d13bbe4d7658f4c441cf3f3 100644 (file)
@@ -53,6 +53,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/usb.h>
+#include <linux/usb_input.h>
 
 /* only an 8 byte buffer necessary for a single packet */
 #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.phys = itmtouch->phys;
-       itmtouch->inputdev.id.bustype = BUS_USB;
-       itmtouch->inputdev.id.vendor = udev->descriptor.idVendor;
-       itmtouch->inputdev.id.product = udev->descriptor.idProduct;
-       itmtouch->inputdev.id.version = udev->descriptor.bcdDevice;
+       usb_to_input_id(udev, &itmtouch->inputdev.id);
        itmtouch->inputdev.dev = &intf->dev;
 
        if (!strlen(itmtouch->name))
index d2f0f90a9bcdab3dba31232ff059e863aae948e6..b6f6ac8d9c2f0a5cd1ee6652d66652032209e67f 100644 (file)
@@ -4,6 +4,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/usb.h>
+#include <linux/usb_input.h>
 #include <asm/unaligned.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.phys = kbtab->phys;
-       kbtab->dev.id.bustype = BUS_USB;
-       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);
+       usb_to_input_id(dev, &kbtab->dev.id);
        kbtab->dev.dev = &intf->dev;
        kbtab->usbdev = dev;
 
index 09b5cc7c66de15167a5445bae090694cb6e9b08f..ff9275057a18f68ed156471ad8a0b9d7403d5c8d 100644 (file)
@@ -53,6 +53,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/usb.h>
+#include <linux/usb_input.h>
 
 #define MTOUCHUSB_MIN_XC                0x0
 #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.phys = mtouch->phys;
-       mtouch->input.id.bustype = BUS_USB;
-       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);
+       usb_to_input_id(udev, &mtouch->input.id);
        mtouch->input.dev = &intf->dev;
 
        mtouch->input.evbit[0] = BIT(EV_KEY) | BIT(EV_ABS);
index 3975b309d55fbb11e1ba0b7d0887f6c150e2fecd..ad4afe7e58974f4b007ef584f100d3e4eb914279 100644 (file)
@@ -35,6 +35,7 @@
 #include <linux/init.h>
 #include <linux/spinlock.h>
 #include <linux/usb.h>
+#include <linux/usb_input.h>
 
 #define POWERMATE_VENDOR       0x077d  /* Griffin Technology, Inc. */
 #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.relbit[LONG(REL_DIAL)] = BIT(REL_DIAL);
        pm->input.mscbit[LONG(MSC_PULSELED)] = BIT(MSC_PULSELED);
-       pm->input.id.bustype = BUS_USB;
-       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);
+       usb_to_input_id(udev, &pm->input.id);
        pm->input.event = powermate_input_event;
        pm->input.dev = &intf->dev;
        pm->input.phys = pm->phys;
index 386595ee21c0b73c688235126850dc2ce312a987..4276c24a50807a64cd35c2f57427faa0eebfe089 100644 (file)
@@ -35,7 +35,7 @@
 #define DEBUG
 #endif
 #include <linux/usb.h>
-
+#include <linux/usb_input.h>
 
 #define TOUCHKIT_MIN_XC                        0x0
 #define TOUCHKIT_MAX_XC                        0x07ff
@@ -202,10 +202,7 @@ static int touchkit_probe(struct usb_interface *intf,
 
        touchkit->input.name = touchkit->name;
        touchkit->input.phys = touchkit->phys;
-       touchkit->input.id.bustype = BUS_USB;
-       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);
+       usb_to_input_id(udev, &touchkit->input.id);
        touchkit->input.dev = &intf->dev;
 
        touchkit->input.evbit[0] = BIT(EV_KEY) | BIT(EV_ABS);
index f35db1974c4258407e607b5f5ae56ef2df38e72b..28987f15eeee9cdb0994533b1204335e87715075 100644 (file)
@@ -32,6 +32,7 @@
 #include <linux/input.h>
 #include <linux/init.h>
 #include <linux/usb.h>
+#include <linux/usb_input.h>
 
 /*
  * Version Information
@@ -288,10 +289,7 @@ static int usb_kbd_probe(struct usb_interface *iface,
 
        kbd->dev.name = kbd->name;
        kbd->dev.phys = kbd->phys;
-       kbd->dev.id.bustype = BUS_USB;
-       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);
+       usb_to_input_id(dev, &kbd->dev.id);
        kbd->dev.dev = &iface->dev;
 
        if (dev->manufacturer)
index 1ec41b5effe627fee269239b8350a1777fd5ae3f..4104dec847fbad4248137ee0a9ffebf7f530b20d 100644 (file)
@@ -32,6 +32,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/usb.h>
+#include <linux/usb_input.h>
 
 /*
  * 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.phys = mouse->phys;
-       mouse->dev.id.bustype = BUS_USB;
-       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);
+       usb_to_input_id(dev, &mouse->dev.id);
        mouse->dev.dev = &intf->dev;
 
        if (dev->manufacturer)
index f6b34af66b3d9a23954bb7300dc7446a3867281c..02412e31a46b18b085ef3dab1d09e01a97140b4f 100644 (file)
@@ -69,6 +69,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/usb.h>
+#include <linux/usb_input.h>
 #include <asm/unaligned.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.phys = wacom->phys;
-       wacom->dev.id.bustype = BUS_USB;
-       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);
+       usb_to_input_id(dev, &wacom->dev.id);
        wacom->dev.dev = &intf->dev;
        wacom->usbdev = dev;
 
index a7fa1b17dcfedd9fcd386802288da52fec71ebeb..18125e0bffa210d3c8f51f217531dc3e7c87d50d 100644 (file)
@@ -62,6 +62,7 @@
 #include <linux/module.h>
 #include <linux/smp_lock.h>
 #include <linux/usb.h>
+#include <linux/usb_input.h>
 
 #define DRIVER_VERSION "v0.0.5"
 #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->dev.id.bustype = BUS_USB;
-       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);
+       usb_to_input_id(udev, &xpad->dev.id);
        xpad->dev.dev = &intf->dev;
        xpad->dev.private = xpad;
        xpad->dev.name = xpad_device[i].name;
index 08521a2b4f3dcd046384ab2fea9ebaabe25b26ec..20ac9e1069d46cd7f0e5a1fba5d65f0302e62269 100644 (file)
@@ -16,6 +16,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/input.h>
+#include <linux/usb_input.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.evbit[0] = BIT(EV_KEY);
                cam->input.keybit[LONG(BTN_0)] = BIT(BTN_0);
-               cam->input.id.bustype = BUS_USB;
-               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);
+               usb_to_input_id(dev, &cam->input.id);
                input_register_device(&cam->input);
                
                usb_make_path(dev, cam->input_physname, 56);
index b9cc0ac71f44db7b6e361bca0a789defacdd8886..bdc53c6cc962ad78989fbbb0cfbac2a68cb57aa2 100644 (file)
@@ -811,9 +811,9 @@ struct input_dev {
 
        void *private;
 
-       char *name;
-       char *phys;
-       char *uniq;
+       const char *name;
+       const char *phys;
+       const char *uniq;
        struct input_id id;
 
        unsigned long evbit[NBITS(EV_MAX)];
index 4c2c82336d1031a7ea45f83580724997260c2bdf..84876077027fb6c89643b76f9938085efdcfab86 100644 (file)
@@ -42,8 +42,7 @@ struct uinput_request {
        int                     code;   /* UI_FF_UPLOAD, UI_FF_ERASE */
 
        int                     retval;
-       wait_queue_head_t       waitq;
-       int                     completed;
+       struct completion       done;
 
        union {
                int             effect_id;
@@ -62,7 +61,7 @@ struct uinput_device {
 
        struct uinput_request   *requests[UINPUT_NUM_REQUESTS];
        wait_queue_head_t       requests_waitq;
-       struct semaphore        requests_sem;
+       spinlock_t              requests_lock;
 };
 #endif /* __KERNEL__ */
 
diff --git a/include/linux/usb_input.h b/include/linux/usb_input.h
new file mode 100644 (file)
index 0000000..716e0cc
--- /dev/null
@@ -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