Revert to Fedora kernel-2.6.17-1.2187_FC5 patched with vs2.0.2.1; there are too many...

[linux-2.6.git] / drivers / input / input.c

diff --git a/drivers/input/input.c b/drivers/input/input.c
index 9cb4b9a..b149c94 100644 (file)
--- a/drivers/input/input.c
+++ b/drivers/input/input.c
@@ -28,6 +28,20 @@ MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
 MODULE_DESCRIPTION("Input core");
 MODULE_LICENSE("GPL");
 
+EXPORT_SYMBOL(input_allocate_device);
+EXPORT_SYMBOL(input_register_device);
+EXPORT_SYMBOL(input_unregister_device);
+EXPORT_SYMBOL(input_register_handler);
+EXPORT_SYMBOL(input_unregister_handler);
+EXPORT_SYMBOL(input_grab_device);
+EXPORT_SYMBOL(input_release_device);
+EXPORT_SYMBOL(input_open_device);
+EXPORT_SYMBOL(input_close_device);
+EXPORT_SYMBOL(input_accept_process);
+EXPORT_SYMBOL(input_flush_device);
+EXPORT_SYMBOL(input_event);
+EXPORT_SYMBOL_GPL(input_class);
+
 #define INPUT_DEVICES  256
 
 static LIST_HEAD(input_dev_list);
@@ -35,16 +49,6 @@ static LIST_HEAD(input_handler_list);
 
 static struct input_handler *input_table[8];
 
-/**
- * input_event() - report new input event
- * @handle: device that generated the event
- * @type: type of the event
- * @code: event code
- * @value: value of the event
- *
- * This function should be used by drivers implementing various input devices
- * See also input_inject_event()
- */
 void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
 {
        struct input_handle *handle;
@@ -59,13 +63,11 @@ void input_event(struct input_dev *dev, unsigned int type, unsigned int code, in
                case EV_SYN:
                        switch (code) {
                                case SYN_CONFIG:
-                                       if (dev->event)
-                                               dev->event(dev, type, code, value);
+                                       if (dev->event) dev->event(dev, type, code, value);
                                        break;
 
                                case SYN_REPORT:
-                                       if (dev->sync)
-                                               return;
+                                       if (dev->sync) return;
                                        dev->sync = 1;
                                        break;
                        }
@@ -134,8 +136,7 @@ void input_event(struct input_dev *dev, unsigned int type, unsigned int code, in
                        if (code > MSC_MAX || !test_bit(code, dev->mscbit))
                                return;
 
-                       if (dev->event)
-                               dev->event(dev, type, code, value);
+                       if (dev->event) dev->event(dev, type, code, value);
 
                        break;
 
@@ -145,9 +146,7 @@ void input_event(struct input_dev *dev, unsigned int type, unsigned int code, in
                                return;
 
                        change_bit(code, dev->led);
-
-                       if (dev->event)
-                               dev->event(dev, type, code, value);
+                       if (dev->event) dev->event(dev, type, code, value);
 
                        break;
 
@@ -159,25 +158,21 @@ void input_event(struct input_dev *dev, unsigned int type, unsigned int code, in
                        if (!!test_bit(code, dev->snd) != !!value)
                                change_bit(code, dev->snd);
 
-                       if (dev->event)
-                               dev->event(dev, type, code, value);
+                       if (dev->event) dev->event(dev, type, code, value);
 
                        break;
 
                case EV_REP:
 
-                       if (code > REP_MAX || value < 0 || dev->rep[code] == value)
-                               return;
+                       if (code > REP_MAX || value < 0 || dev->rep[code] == value) return;
 
                        dev->rep[code] = value;
-                       if (dev->event)
-                               dev->event(dev, type, code, value);
+                       if (dev->event) dev->event(dev, type, code, value);
 
                        break;
 
                case EV_FF:
-                       if (dev->event)
-                               dev->event(dev, type, code, value);
+                       if (dev->event) dev->event(dev, type, code, value);
                        break;
        }
 
@@ -191,24 +186,6 @@ void input_event(struct input_dev *dev, unsigned int type, unsigned int code, in
                        if (handle->open)
                                handle->handler->event(handle, type, code, value);
 }
-EXPORT_SYMBOL(input_event);
-
-/**
- * input_inject_event() - send input event from input handler
- * @handle: input handle to send event through
- * @type: type of the event
- * @code: event code
- * @value: value of the event
- *
- * Similar to input_event() but will ignore event if device is "grabbed" and handle
- * injecting event is not the one that owns the device.
- */
-void input_inject_event(struct input_handle *handle, unsigned int type, unsigned int code, int value)
-{
-       if (!handle->dev->grab || handle->dev->grab == handle)
-               input_event(handle->dev, type, code, value);
-}
-EXPORT_SYMBOL(input_inject_event);
 
 static void input_repeat_key(unsigned long data)
 {
@@ -224,6 +201,14 @@ static void input_repeat_key(unsigned long data)
                mod_timer(&dev->timer, jiffies + msecs_to_jiffies(dev->rep[REP_PERIOD]));
 }
 
+int input_accept_process(struct input_handle *handle, struct file *file)
+{
+       if (handle->dev->accept)
+               return handle->dev->accept(handle->dev, file);
+
+       return 0;
+}
+
 int input_grab_device(struct input_handle *handle)
 {
        if (handle->dev->grab)
@@ -232,21 +217,12 @@ int input_grab_device(struct input_handle *handle)
        handle->dev->grab = handle;
        return 0;
 }
-EXPORT_SYMBOL(input_grab_device);
 
 void input_release_device(struct input_handle *handle)
 {
-       struct input_dev *dev = handle->dev;
-
-       if (dev->grab == handle) {
-               dev->grab = NULL;
-
-               list_for_each_entry(handle, &dev->h_list, d_node)
-                       if (handle->handler->start)
-                               handle->handler->start(handle);
-       }
+       if (handle->dev->grab == handle)
+               handle->dev->grab = NULL;
 }
-EXPORT_SYMBOL(input_release_device);
 
 int input_open_device(struct input_handle *handle)
 {
@@ -269,7 +245,6 @@ int input_open_device(struct input_handle *handle)
 
        return err;
 }
-EXPORT_SYMBOL(input_open_device);
 
 int input_flush_device(struct input_handle* handle, struct file* file)
 {
@@ -278,7 +253,6 @@ int input_flush_device(struct input_handle* handle, struct file* file)
 
        return 0;
 }
-EXPORT_SYMBOL(input_flush_device);
 
 void input_close_device(struct input_handle *handle)
 {
@@ -294,7 +268,6 @@ void input_close_device(struct input_handle *handle)
 
        mutex_unlock(&dev->mutex);
 }
-EXPORT_SYMBOL(input_close_device);
 
 static void input_link_handle(struct input_handle *handle)
 {
@@ -362,11 +335,9 @@ 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)
                return POLLIN | POLLRDNORM;
-
        return 0;
 }
 
@@ -891,7 +862,6 @@ struct class input_class = {
        .release                = input_dev_release,
        .uevent                 = input_dev_uevent,
 };
-EXPORT_SYMBOL_GPL(input_class);
 
 struct input_dev *input_allocate_device(void)
 {
@@ -902,27 +872,12 @@ struct input_dev *input_allocate_device(void)
                dev->dynalloc = 1;
                dev->cdev.class = &input_class;
                class_device_initialize(&dev->cdev);
-               mutex_init(&dev->mutex);
                INIT_LIST_HEAD(&dev->h_list);
                INIT_LIST_HEAD(&dev->node);
        }
 
        return dev;
 }
-EXPORT_SYMBOL(input_allocate_device);
-
-void input_free_device(struct input_dev *dev)
-{
-       if (dev) {
-
-               mutex_lock(&dev->mutex);
-               dev->name = dev->phys = dev->uniq = NULL;
-               mutex_unlock(&dev->mutex);
-
-               input_put_device(dev);
-       }
-}
-EXPORT_SYMBOL(input_free_device);
 
 int input_register_device(struct input_dev *dev)
 {
@@ -940,6 +895,7 @@ int input_register_device(struct input_dev *dev)
                return -EINVAL;
        }
 
+       mutex_init(&dev->mutex);
        set_bit(EV_SYN, dev->evbit);
 
        /*
@@ -988,11 +944,8 @@ int input_register_device(struct input_dev *dev)
        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))) {
+                               if ((handle = handler->connect(handler, dev, id)))
                                        input_link_handle(handle);
-                                       if (handler->start)
-                                               handler->start(handle);
-                               }
 
        input_wakeup_procfs_readers();
 
@@ -1003,14 +956,12 @@ int input_register_device(struct input_dev *dev)
  fail1:        class_device_del(&dev->cdev);
        return error;
 }
-EXPORT_SYMBOL(input_register_device);
 
 void input_unregister_device(struct input_dev *dev)
 {
-       struct list_head *node, *next;
+       struct list_head * node, * next;
 
-       if (!dev)
-               return;
+       if (!dev) return;
 
        del_timer_sync(&dev->timer);
 
@@ -1026,16 +977,10 @@ void input_unregister_device(struct input_dev *dev)
        sysfs_remove_group(&dev->cdev.kobj, &input_dev_caps_attr_group);
        sysfs_remove_group(&dev->cdev.kobj, &input_dev_id_attr_group);
        sysfs_remove_group(&dev->cdev.kobj, &input_dev_attr_group);
-
-       mutex_lock(&dev->mutex);
-       dev->name = dev->phys = dev->uniq = NULL;
-       mutex_unlock(&dev->mutex);
-
        class_device_unregister(&dev->cdev);
 
        input_wakeup_procfs_readers();
 }
-EXPORT_SYMBOL(input_unregister_device);
 
 void input_register_handler(struct input_handler *handler)
 {
@@ -1043,8 +988,7 @@ void input_register_handler(struct input_handler *handler)
        struct input_handle *handle;
        struct input_device_id *id;
 
-       if (!handler)
-               return;
+       if (!handler) return;
 
        INIT_LIST_HEAD(&handler->h_list);
 
@@ -1056,19 +1000,15 @@ void input_register_handler(struct input_handler *handler)
        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))) {
+                               if ((handle = handler->connect(handler, dev, id)))
                                        input_link_handle(handle);
-                                       if (handler->start)
-                                               handler->start(handle);
-                               }
 
        input_wakeup_procfs_readers();
 }
-EXPORT_SYMBOL(input_register_handler);
 
 void input_unregister_handler(struct input_handler *handler)
 {
-       struct list_head *node, *next;
+       struct list_head * node, * next;
 
        list_for_each_safe(node, next, &handler->h_list) {
                struct input_handle * handle = to_handle_h(node);
@@ -1084,7 +1024,6 @@ void input_unregister_handler(struct input_handler *handler)
 
        input_wakeup_procfs_readers();
 }
-EXPORT_SYMBOL(input_unregister_handler);
 
 static int input_open_file(struct inode *inode, struct file *file)
 {