Merge master.kernel.org:/pub/scm/linux/kernel/git/steve/gfs2-2.6-nmw

[pandora-kernel.git] / drivers / input / serio / serio.c

diff --git a/drivers/input/serio/serio.c b/drivers/input/serio/serio.c
index 9666007..5f1d403 100644 (file)
--- a/drivers/input/serio/serio.c
+++ b/drivers/input/serio/serio.c
@@ -35,6 +35,7 @@
 #include <linux/slab.h>
 #include <linux/kthread.h>
 #include <linux/mutex.h>
+#include <linux/freezer.h>
 
 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
 MODULE_DESCRIPTION("Serio abstraction core");
@@ -62,6 +63,7 @@ static LIST_HEAD(serio_list);
 
 static struct bus_type serio_bus;
 
+static void serio_add_driver(struct serio_driver *drv);
 static void serio_add_port(struct serio *serio);
 static void serio_destroy_port(struct serio *serio);
 static void serio_reconnect_port(struct serio *serio);
@@ -117,6 +119,8 @@ static int serio_match_port(const struct serio_device_id *ids, struct serio *ser
 
 static void serio_bind_driver(struct serio *serio, struct serio_driver *drv)
 {
+       int error;
+
        down_write(&serio_bus.subsys.rwsem);
 
        if (serio_match_port(drv->id_table, serio)) {
@@ -125,9 +129,19 @@ static void serio_bind_driver(struct serio *serio, struct serio_driver *drv)
                        serio->dev.driver = NULL;
                        goto out;
                }
-               device_bind_driver(&serio->dev);
+               error = device_bind_driver(&serio->dev);
+               if (error) {
+                       printk(KERN_WARNING
+                               "serio: device_bind_driver() failed "
+                               "for %s (%s) and %s, error: %d\n",
+                               serio->phys, serio->name,
+                               drv->description, error);
+                       serio_disconnect_driver(serio);
+                       serio->dev.driver = NULL;
+                       goto out;
+               }
        }
-out:
+ out:
        up_write(&serio_bus.subsys.rwsem);
 }
 
@@ -140,8 +154,14 @@ static void serio_release_driver(struct serio *serio)
 
 static void serio_find_driver(struct serio *serio)
 {
+       int error;
+
        down_write(&serio_bus.subsys.rwsem);
-       device_attach(&serio->dev);
+       error = device_attach(&serio->dev);
+       if (error < 0)
+               printk(KERN_WARNING
+                       "serio: device_attach() failed for %s (%s), error: %d\n",
+                       serio->phys, serio->name, error);
        up_write(&serio_bus.subsys.rwsem);
 }
 
@@ -196,6 +216,7 @@ static void serio_queue_event(void *object, struct module *owner,
        if ((event = kmalloc(sizeof(struct serio_event), GFP_ATOMIC))) {
                if (!try_module_get(owner)) {
                        printk(KERN_WARNING "serio: Can't get module reference, dropping event %d\n", event_type);
+                       kfree(event);
                        goto out;
                }
 
@@ -271,7 +292,6 @@ static struct serio_event *serio_get_event(void)
 static void serio_handle_event(void)
 {
        struct serio_event *event;
-       struct serio_driver *serio_drv;
 
        mutex_lock(&serio_mutex);
 
@@ -303,8 +323,7 @@ static void serio_handle_event(void)
                                break;
 
                        case SERIO_REGISTER_DRIVER:
-                               serio_drv = event->object;
-                               driver_register(&serio_drv->driver);
+                               serio_add_driver(event->object);
                                break;
 
                        default:
@@ -524,6 +543,7 @@ static void serio_init_port(struct serio *serio)
 
        __module_get(THIS_MODULE);
 
+       INIT_LIST_HEAD(&serio->node);
        spin_lock_init(&serio->lock);
        mutex_init(&serio->drv_mutex);
        device_initialize(&serio->dev);
@@ -531,8 +551,12 @@ static void serio_init_port(struct serio *serio)
                 "serio%ld", (long)atomic_inc_return(&serio_no) - 1);
        serio->dev.bus = &serio_bus;
        serio->dev.release = serio_release_port;
-       if (serio->parent)
+       if (serio->parent) {
                serio->dev.parent = &serio->parent->dev;
+               serio->depth = serio->parent->depth + 1;
+       } else
+               serio->depth = 0;
+       lockdep_set_subclass(&serio->lock, serio->depth);
 }
 
 /*
@@ -541,6 +565,8 @@ static void serio_init_port(struct serio *serio)
  */
 static void serio_add_port(struct serio *serio)
 {
+       int error;
+
        if (serio->parent) {
                serio_pause_rx(serio->parent);
                serio->parent->child = serio;
@@ -550,9 +576,19 @@ static void serio_add_port(struct serio *serio)
        list_add_tail(&serio->node, &serio_list);
        if (serio->start)
                serio->start(serio);
-       device_add(&serio->dev);
-       sysfs_create_group(&serio->dev.kobj, &serio_id_attr_group);
-       serio->registered = 1;
+       error = device_add(&serio->dev);
+       if (error)
+               printk(KERN_ERR
+                       "serio: device_add() failed for %s (%s), error: %d\n",
+                       serio->phys, serio->name, error);
+       else {
+               serio->registered = 1;
+               error = sysfs_create_group(&serio->dev.kobj, &serio_id_attr_group);
+               if (error)
+                       printk(KERN_ERR
+                               "serio: sysfs_create_group() failed for %s (%s), error: %d\n",
+                               serio->phys, serio->name, error);
+       }
 }
 
 /*
@@ -582,10 +618,10 @@ static void serio_destroy_port(struct serio *serio)
        if (serio->registered) {
                sysfs_remove_group(&serio->dev.kobj, &serio_id_attr_group);
                device_del(&serio->dev);
-               list_del_init(&serio->node);
                serio->registered = 0;
        }
 
+       list_del_init(&serio->node);
        serio_remove_pending_events(serio);
        put_device(&serio->dev);
 }
@@ -755,6 +791,17 @@ static struct bus_type serio_bus = {
        .remove = serio_driver_remove,
 };
 
+static void serio_add_driver(struct serio_driver *drv)
+{
+       int error;
+
+       error = driver_register(&drv->driver);
+       if (error)
+               printk(KERN_ERR
+                       "serio: driver_register() failed for %s, error: %d\n",
+                       drv->driver.name, error);
+}
+
 void __serio_register_driver(struct serio_driver *drv, struct module *owner)
 {
        drv->driver.bus = &serio_bus;
@@ -881,7 +928,7 @@ void serio_close(struct serio *serio)
 }
 
 irqreturn_t serio_interrupt(struct serio *serio,
-               unsigned char data, unsigned int dfl, struct pt_regs *regs)
+               unsigned char data, unsigned int dfl)
 {
        unsigned long flags;
        irqreturn_t ret = IRQ_NONE;
@@ -889,7 +936,7 @@ irqreturn_t serio_interrupt(struct serio *serio,
        spin_lock_irqsave(&serio->lock, flags);
 
         if (likely(serio->drv)) {
-                ret = serio->drv->interrupt(serio, data, dfl, regs);
+                ret = serio->drv->interrupt(serio, data, dfl);
        } else if (!dfl && serio->registered) {
                serio_rescan(serio);
                ret = IRQ_HANDLED;
@@ -902,18 +949,26 @@ irqreturn_t serio_interrupt(struct serio *serio,
 
 static int __init serio_init(void)
 {
-       serio_task = kthread_run(serio_thread, NULL, "kseriod");
-       if (IS_ERR(serio_task)) {
-               printk(KERN_ERR "serio: Failed to start kseriod\n");
-               return PTR_ERR(serio_task);
-       }
+       int error;
 
        serio_bus.dev_attrs = serio_device_attrs;
        serio_bus.drv_attrs = serio_driver_attrs;
        serio_bus.match = serio_bus_match;
        serio_bus.uevent = serio_uevent;
        serio_bus.resume = serio_resume;
-       bus_register(&serio_bus);
+       error = bus_register(&serio_bus);
+       if (error) {
+               printk(KERN_ERR "serio: failed to register serio bus, error: %d\n", error);
+               return error;
+       }
+
+       serio_task = kthread_run(serio_thread, NULL, "kseriod");
+       if (IS_ERR(serio_task)) {
+               bus_unregister(&serio_bus);
+               error = PTR_ERR(serio_task);
+               printk(KERN_ERR "serio: Failed to start kseriod, error: %d\n", error);
+               return error;
+       }
 
        return 0;
 }