md: allow upper limit for resync/reshape to be set when array is read-only

[safe/jmp/linux-2.6] / drivers / input / input.c

diff --git a/drivers/input/input.c b/drivers/input/input.c
index e1729e1..7c237e6 100644 (file)
--- a/drivers/input/input.c
+++ b/drivers/input/input.c
@@ -21,6 +21,7 @@
 #include <linux/device.h>
 #include <linux/mutex.h>
 #include <linux/rcupdate.h>
+#include <linux/smp_lock.h>
 
 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
 MODULE_DESCRIPTION("Input core");
@@ -28,6 +29,24 @@ MODULE_LICENSE("GPL");
 
 #define INPUT_DEVICES  256
 
+/*
+ * EV_ABS events which should not be cached are listed here.
+ */
+static unsigned int input_abs_bypass_init_data[] __initdata = {
+       ABS_MT_TOUCH_MAJOR,
+       ABS_MT_TOUCH_MINOR,
+       ABS_MT_WIDTH_MAJOR,
+       ABS_MT_WIDTH_MINOR,
+       ABS_MT_ORIENTATION,
+       ABS_MT_POSITION_X,
+       ABS_MT_POSITION_Y,
+       ABS_MT_TOOL_TYPE,
+       ABS_MT_BLOB_ID,
+       ABS_MT_TRACKING_ID,
+       0
+};
+static unsigned long input_abs_bypass[BITS_TO_LONGS(ABS_CNT)];
+
 static LIST_HEAD(input_dev_list);
 static LIST_HEAD(input_handler_list);
 
@@ -131,6 +150,11 @@ static void input_start_autorepeat(struct input_dev *dev, int code)
        }
 }
 
+static void input_stop_autorepeat(struct input_dev *dev)
+{
+       del_timer(&dev->timer);
+}
+
 #define INPUT_IGNORE_EVENT     0
 #define INPUT_PASS_TO_HANDLERS 1
 #define INPUT_PASS_TO_DEVICE   2
@@ -155,6 +179,10 @@ static void input_handle_event(struct input_dev *dev,
                                disposition = INPUT_PASS_TO_HANDLERS;
                        }
                        break;
+               case SYN_MT_REPORT:
+                       dev->sync = 0;
+                       disposition = INPUT_PASS_TO_HANDLERS;
+                       break;
                }
                break;
 
@@ -166,6 +194,8 @@ static void input_handle_event(struct input_dev *dev,
                                __change_bit(code, dev->key);
                                if (value)
                                        input_start_autorepeat(dev, code);
+                               else
+                                       input_stop_autorepeat(dev);
                        }
 
                        disposition = INPUT_PASS_TO_HANDLERS;
@@ -184,6 +214,11 @@ static void input_handle_event(struct input_dev *dev,
        case EV_ABS:
                if (is_event_supported(code, dev->absbit, ABS_MAX)) {
 
+                       if (test_bit(code, input_abs_bypass)) {
+                               disposition = INPUT_PASS_TO_HANDLERS;
+                               break;
+                       }
+
                        value = input_defuzz_abs_event(value,
                                        dev->abs[code], dev->absfuzz[code]);
 
@@ -241,7 +276,7 @@ static void input_handle_event(struct input_dev *dev,
                break;
        }
 
-       if (type != EV_SYN)
+       if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
                dev->sync = 0;
 
        if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
@@ -736,11 +771,11 @@ static inline void input_wakeup_procfs_readers(void)
 
 static unsigned int input_proc_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)
+       if (file->f_version != input_devices_state) {
+               file->f_version = input_devices_state;
                return POLLIN | POLLRDNORM;
+       }
 
        return 0;
 }
@@ -821,7 +856,7 @@ static int input_devices_seq_show(struct seq_file *seq, void *v)
        return 0;
 }
 
-static struct seq_operations input_devices_seq_ops = {
+static const struct seq_operations input_devices_seq_ops = {
        .start  = input_devices_seq_start,
        .next   = input_devices_seq_next,
        .stop   = input_devices_seq_stop,
@@ -874,7 +909,7 @@ static int input_handlers_seq_show(struct seq_file *seq, void *v)
 
        return 0;
 }
-static struct seq_operations input_handlers_seq_ops = {
+static const struct seq_operations input_handlers_seq_ops = {
        .start  = input_handlers_seq_start,
        .next   = input_handlers_seq_next,
        .stop   = input_handlers_seq_stop,
@@ -898,30 +933,24 @@ static int __init input_proc_init(void)
 {
        struct proc_dir_entry *entry;
 
-       proc_bus_input_dir = proc_mkdir("input", proc_bus);
+       proc_bus_input_dir = proc_mkdir("bus/input", NULL);
        if (!proc_bus_input_dir)
                return -ENOMEM;
 
-       proc_bus_input_dir->owner = THIS_MODULE;
-
-       entry = create_proc_entry("devices", 0, proc_bus_input_dir);
+       entry = proc_create("devices", 0, proc_bus_input_dir,
+                           &input_devices_fileops);
        if (!entry)
                goto fail1;
 
-       entry->owner = THIS_MODULE;
-       entry->proc_fops = &input_devices_fileops;
-
-       entry = create_proc_entry("handlers", 0, proc_bus_input_dir);
+       entry = proc_create("handlers", 0, proc_bus_input_dir,
+                           &input_handlers_fileops);
        if (!entry)
                goto fail2;
 
-       entry->owner = THIS_MODULE;
-       entry->proc_fops = &input_handlers_fileops;
-
        return 0;
 
  fail2:        remove_proc_entry("devices", proc_bus_input_dir);
- fail1: remove_proc_entry("input", proc_bus);
+ fail1: remove_proc_entry("bus/input", NULL);
        return -ENOMEM;
 }
 
@@ -929,7 +958,7 @@ 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);
+       remove_proc_entry("bus/input", NULL);
 }
 
 #else /* !CONFIG_PROC_FS */
@@ -1236,8 +1265,14 @@ static struct device_type input_dev_type = {
        .uevent         = input_dev_uevent,
 };
 
+static char *input_nodename(struct device *dev)
+{
+       return kasprintf(GFP_KERNEL, "input/%s", dev_name(dev));
+}
+
 struct class input_class = {
        .name           = "input",
+       .nodename       = input_nodename,
 };
 EXPORT_SYMBOL_GPL(input_class);
 
@@ -1392,11 +1427,8 @@ int input_register_device(struct input_dev *dev)
        if (!dev->setkeycode)
                dev->setkeycode = input_default_setkeycode;
 
-       snprintf(dev->dev.bus_id, sizeof(dev->dev.bus_id),
-                "input%ld", (unsigned long) atomic_inc_return(&input_no) - 1);
-
-       if (dev->cdev.dev)
-               dev->dev.parent = dev->cdev.dev;
+       dev_set_name(&dev->dev, "input%ld",
+                    (unsigned long) atomic_inc_return(&input_no) - 1);
 
        error = device_add(&dev->dev);
        if (error)
@@ -1550,7 +1582,6 @@ int input_register_handle(struct input_handle *handle)
                return error;
        list_add_tail_rcu(&handle->d_node, &dev->h_list);
        mutex_unlock(&dev->mutex);
-       synchronize_rcu();
 
        /*
         * Since we are supposed to be called from ->connect()
@@ -1595,13 +1626,17 @@ EXPORT_SYMBOL(input_unregister_handle);
 
 static int input_open_file(struct inode *inode, struct file *file)
 {
-       struct input_handler *handler = input_table[iminor(inode) >> 5];
+       struct input_handler *handler;
        const struct file_operations *old_fops, *new_fops = NULL;
        int err;
 
+       lock_kernel();
        /* No load-on-demand here? */
-       if (!handler || !(new_fops = fops_get(handler->fops)))
-               return -ENODEV;
+       handler = input_table[iminor(inode) >> 5];
+       if (!handler || !(new_fops = fops_get(handler->fops))) {
+               err = -ENODEV;
+               goto out;
+       }
 
        /*
         * That's _really_ odd. Usually NULL ->open means "nothing special",
@@ -1609,7 +1644,8 @@ static int input_open_file(struct inode *inode, struct file *file)
         */
        if (!new_fops->open) {
                fops_put(new_fops);
-               return -ENODEV;
+               err = -ENODEV;
+               goto out;
        }
        old_fops = file->f_op;
        file->f_op = new_fops;
@@ -1621,6 +1657,8 @@ static int input_open_file(struct inode *inode, struct file *file)
                file->f_op = fops_get(old_fops);
        }
        fops_put(old_fops);
+out:
+       unlock_kernel();
        return err;
 }
 
@@ -1629,10 +1667,20 @@ static const struct file_operations input_fops = {
        .open = input_open_file,
 };
 
+static void __init input_init_abs_bypass(void)
+{
+       const unsigned int *p;
+
+       for (p = input_abs_bypass_init_data; *p; p++)
+               input_abs_bypass[BIT_WORD(*p)] |= BIT_MASK(*p);
+}
+
 static int __init input_init(void)
 {
        int err;
 
+       input_init_abs_bypass();
+
        err = class_register(&input_class);
        if (err) {
                printk(KERN_ERR "input: unable to register input_dev class\n");