12 files changed, 95 insertions, 119 deletions

diff --git a/drivers/input/evdev.c b/drivers/input/evdev.c
index d62c73f5ba93..374f404e81da 100644
--- a/drivers/input/evdev.c
+++ b/drivers/input/evdev.c
@@ -678,9 +678,9 @@ static struct input_handle *evdev_connect(struct input_handler *handler, struct
 
         devfs_mk_cdev(MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor),
                         S_IFCHR|S_IRUGO|S_IWUSR, "input/event%d", minor);
-        class_simple_device_add(input_class,
-                                MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor),
-                                dev->dev, "event%d", minor);
+        class_device_create(input_class,
+                        MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor),
+                        dev->dev, "event%d", minor);
 
         return &evdev->handle;
 }
@@ -690,7 +690,8 @@ static void evdev_disconnect(struct input_handle *handle)
         struct evdev *evdev = handle->private;
         struct evdev_list *list;
 
-        class_simple_device_remove(MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + evdev->minor));
+        class_device_destroy(input_class,
+                        MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + evdev->minor));
         devfs_remove("input/event%d", evdev->minor);
         evdev->exist = 0;
 
diff --git a/drivers/input/gameport/gameport.c b/drivers/input/gameport/gameport.c
index d7dfa6f53cf6..c77a82e46055 100644
--- a/drivers/input/gameport/gameport.c
+++ b/drivers/input/gameport/gameport.c
@@ -17,10 +17,11 @@
 #include <linux/init.h>
 #include <linux/gameport.h>
 #include <linux/wait.h>
+#include <linux/completion.h>
 #include <linux/sched.h>
+#include <linux/smp_lock.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
-#include <linux/kthread.h>
 
 /*#include <asm/io.h>*/
 
@@ -133,7 +134,7 @@ static int gameport_measure_speed(struct gameport *gameport)
         }
 
         gameport_close(gameport);
-        return (cpu_data[_smp_processor_id()].loops_per_jiffy * (unsigned long)HZ / (1000 / 50)) / (tx < 1 ? 1 : tx);
+        return (cpu_data[raw_smp_processor_id()].loops_per_jiffy * (unsigned long)HZ / (1000 / 50)) / (tx < 1 ? 1 : tx);
 
 #else
 
@@ -237,7 +238,8 @@ struct gameport_event {
 static DEFINE_SPINLOCK(gameport_event_lock);    /* protects gameport_event_list */
 static LIST_HEAD(gameport_event_list);
 static DECLARE_WAIT_QUEUE_HEAD(gameport_wait);
-static struct task_struct *gameport_task;
+static DECLARE_COMPLETION(gameport_exited);
+static int gameport_pid;
 
 static void gameport_queue_event(void *object, struct module *owner,
                               enum gameport_event_type event_type)
@@ -248,12 +250,12 @@ static void gameport_queue_event(void *object, struct module *owner,
         spin_lock_irqsave(&gameport_event_lock, flags);
 
         /*
-         * Scan event list for the other events for the same gameport port,
+         * Scan event list for the other events for the same gameport port,
          * starting with the most recent one. If event is the same we
          * do not need add new one. If event is of different type we
          * need to add this event and should not look further because
          * we need to preseve sequence of distinct events.
-         */
+         */
         list_for_each_entry_reverse(event, &gameport_event_list, node) {
                 if (event->object == object) {
                         if (event->type == event_type)
@@ -430,15 +432,20 @@ static struct gameport *gameport_get_pending_child(struct gameport *parent)
 
 static int gameport_thread(void *nothing)
 {
+        lock_kernel();
+        daemonize("kgameportd");
+        allow_signal(SIGTERM);
+
         do {
                 gameport_handle_events();
-                wait_event_interruptible(gameport_wait,
-                        kthread_should_stop() || !list_empty(&gameport_event_list));
-                try_to_freeze(PF_FREEZE);
-        } while (!kthread_should_stop());
+                wait_event_interruptible(gameport_wait, !list_empty(&gameport_event_list));
+                try_to_freeze();
+        } while (!signal_pending(current));
 
         printk(KERN_DEBUG "gameport: kgameportd exiting\n");
-        return 0;
+
+        unlock_kernel();
+        complete_and_exit(&gameport_exited, 0);
 }
 
 
@@ -446,13 +453,13 @@ static int gameport_thread(void *nothing)
  * Gameport port operations
  */
 
-static ssize_t gameport_show_description(struct device *dev, char *buf)
+static ssize_t gameport_show_description(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct gameport *gameport = to_gameport_port(dev);
         return sprintf(buf, "%s\n", gameport->name);
 }
 
-static ssize_t gameport_rebind_driver(struct device *dev, const char *buf, size_t count)
+static ssize_t gameport_rebind_driver(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
         struct gameport *gameport = to_gameport_port(dev);
         struct device_driver *drv;
@@ -766,10 +773,9 @@ void gameport_close(struct gameport *gameport)
 
 static int __init gameport_init(void)
 {
-        gameport_task = kthread_run(gameport_thread, NULL, "kgameportd");
-        if (IS_ERR(gameport_task)) {
+        if (!(gameport_pid = kernel_thread(gameport_thread, NULL, CLONE_KERNEL))) {
                 printk(KERN_ERR "gameport: Failed to start kgameportd\n");
-                return PTR_ERR(gameport_task);
+                return -1;
         }
 
         gameport_bus.dev_attrs = gameport_device_attrs;
@@ -783,7 +789,8 @@ static int __init gameport_init(void)
 static void __exit gameport_exit(void)
 {
         bus_unregister(&gameport_bus);
-        kthread_stop(gameport_task);
+        kill_proc(gameport_pid, SIGTERM, 1);
+        wait_for_completion(&gameport_exited);
 }
 
 module_init(gameport_init);
diff --git a/drivers/input/input.c b/drivers/input/input.c
index c1dbc04cf54a..7c4b4d37b3e6 100644
--- a/drivers/input/input.c
+++ b/drivers/input/input.c
@@ -729,13 +729,13 @@ static int __init input_proc_init(void)
 static inline int input_proc_init(void) { return 0; }
 #endif
 
-struct class_simple *input_class;
+struct class *input_class;
 
 static int __init input_init(void)
 {
         int retval = -ENOMEM;
 
-        input_class = class_simple_create(THIS_MODULE, "input");
+        input_class = class_create(THIS_MODULE, "input");
         if (IS_ERR(input_class))
                 return PTR_ERR(input_class);
         input_proc_init();
@@ -745,7 +745,7 @@ static int __init input_init(void)
                 remove_proc_entry("devices", proc_bus_input_dir);
                 remove_proc_entry("handlers", proc_bus_input_dir);
                 remove_proc_entry("input", proc_bus);
-                class_simple_destroy(input_class);
+                class_destroy(input_class);
                 return retval;
         }
 
@@ -755,7 +755,7 @@ static int __init input_init(void)
                 remove_proc_entry("handlers", proc_bus_input_dir);
                 remove_proc_entry("input", proc_bus);
                 unregister_chrdev(INPUT_MAJOR, "input");
-                class_simple_destroy(input_class);
+                class_destroy(input_class);
         }
         return retval;
 }
@@ -768,7 +768,7 @@ static void __exit input_exit(void)
 
         devfs_remove("input");
         unregister_chrdev(INPUT_MAJOR, "input");
-        class_simple_destroy(input_class);
+        class_destroy(input_class);
 }
 
 subsys_initcall(input_init);
diff --git a/drivers/input/joydev.c b/drivers/input/joydev.c
index 816a585a0e6b..ff8e1bbd0e13 100644
--- a/drivers/input/joydev.c
+++ b/drivers/input/joydev.c
@@ -518,9 +518,9 @@ static struct input_handle *joydev_connect(struct input_handler *handler, struct
 
         devfs_mk_cdev(MKDEV(INPUT_MAJOR, JOYDEV_MINOR_BASE + minor),
                         S_IFCHR|S_IRUGO|S_IWUSR, "input/js%d", minor);
-        class_simple_device_add(input_class,
-                                MKDEV(INPUT_MAJOR, JOYDEV_MINOR_BASE + minor),
-                                dev->dev, "js%d", minor);
+        class_device_create(input_class,
+                        MKDEV(INPUT_MAJOR, JOYDEV_MINOR_BASE + minor),
+                        dev->dev, "js%d", minor);
 
         return &joydev->handle;
 }
@@ -530,7 +530,7 @@ static void joydev_disconnect(struct input_handle *handle)
         struct joydev *joydev = handle->private;
         struct joydev_list *list;
 
-        class_simple_device_remove(MKDEV(INPUT_MAJOR, JOYDEV_MINOR_BASE + joydev->minor));
+        class_device_destroy(input_class, MKDEV(INPUT_MAJOR, JOYDEV_MINOR_BASE + joydev->minor));
         devfs_remove("input/js%d", joydev->minor);
         joydev->exist = 0;
 
diff --git a/drivers/input/keyboard/atkbd.c b/drivers/input/keyboard/atkbd.c
index 9f9da6d4a23f..4d4985b59abf 100644
--- a/drivers/input/keyboard/atkbd.c
+++ b/drivers/input/keyboard/atkbd.c
@@ -54,7 +54,7 @@ static int atkbd_softraw = 1;
 module_param_named(softraw, atkbd_softraw, bool, 0);
 MODULE_PARM_DESC(softraw, "Use software generated rawmode");
 
-static int atkbd_scroll = 1;
+static int atkbd_scroll = 0;
 module_param_named(scroll, atkbd_scroll, bool, 0);
 MODULE_PARM_DESC(scroll, "Enable scroll-wheel on MS Office and similar keyboards");
 
@@ -219,11 +219,11 @@ static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t
 #define ATKBD_DEFINE_ATTR(_name)                                                \
 static ssize_t atkbd_show_##_name(struct atkbd *, char *);                      \
 static ssize_t atkbd_set_##_name(struct atkbd *, const char *, size_t);         \
-static ssize_t atkbd_do_show_##_name(struct device *d, char *b)                 \
+static ssize_t atkbd_do_show_##_name(struct device *d, struct device_attribute *attr, char *b)                  \
 {                                                                               \
         return atkbd_attr_show_helper(d, b, atkbd_show_##_name);                \
 }                                                                               \
-static ssize_t atkbd_do_set_##_name(struct device *d, const char *b, size_t s)  \
+static ssize_t atkbd_do_set_##_name(struct device *d, struct device_attribute *attr, const char *b, size_t s)   \
 {                                                                               \
         return atkbd_attr_set_helper(d, b, s, atkbd_set_##_name);               \
 }                                                                               \
diff --git a/drivers/input/mouse/alps.c b/drivers/input/mouse/alps.c
index ffdc82313192..a12e98158a75 100644
--- a/drivers/input/mouse/alps.c
+++ b/drivers/input/mouse/alps.c
@@ -364,7 +364,7 @@ static int alps_reconnect(struct psmouse *psmouse)
         if (alps_get_status(psmouse, param))
                 return -1;
 
-        if (param[0] & 0x04)
+        if (!(param[0] & 0x04))
                 alps_tap_mode(psmouse, 1);
 
         if (alps_absolute_mode(psmouse)) {
diff --git a/drivers/input/mouse/psmouse.h b/drivers/input/mouse/psmouse.h
index dc8e9ae07f32..86691cf43433 100644
--- a/drivers/input/mouse/psmouse.h
+++ b/drivers/input/mouse/psmouse.h
@@ -93,11 +93,11 @@ ssize_t psmouse_attr_set_helper(struct device *dev, const char *buf, size_t coun
 #define PSMOUSE_DEFINE_ATTR(_name)                                              \
 static ssize_t psmouse_attr_show_##_name(struct psmouse *, char *);             \
 static ssize_t psmouse_attr_set_##_name(struct psmouse *, const char *, size_t);\
-static ssize_t psmouse_do_show_##_name(struct device *d, char *b)               \
+static ssize_t psmouse_do_show_##_name(struct device *d, struct device_attribute *attr, char *b)                \
 {                                                                               \
         return psmouse_attr_show_helper(d, b, psmouse_attr_show_##_name);       \
 }                                                                               \
-static ssize_t psmouse_do_set_##_name(struct device *d, const char *b, size_t s)\
+static ssize_t psmouse_do_set_##_name(struct device *d, struct device_attribute *attr, const char *b, size_t s)\
 {                                                                               \
         return psmouse_attr_set_helper(d, b, s, psmouse_attr_set_##_name);      \
 }                                                                               \
diff --git a/drivers/input/mousedev.c b/drivers/input/mousedev.c
index 08b191180af0..c6194a9dd174 100644
--- a/drivers/input/mousedev.c
+++ b/drivers/input/mousedev.c
@@ -651,9 +651,9 @@ static struct input_handle *mousedev_connect(struct input_handler *handler, stru
 
         devfs_mk_cdev(MKDEV(INPUT_MAJOR, MOUSEDEV_MINOR_BASE + minor),
                         S_IFCHR|S_IRUGO|S_IWUSR, "input/mouse%d", minor);
-        class_simple_device_add(input_class,
-                                MKDEV(INPUT_MAJOR, MOUSEDEV_MINOR_BASE + minor),
-                                dev->dev, "mouse%d", minor);
+        class_device_create(input_class,
+                        MKDEV(INPUT_MAJOR, MOUSEDEV_MINOR_BASE + minor),
+                        dev->dev, "mouse%d", minor);
 
         return &mousedev->handle;
 }
@@ -663,7 +663,8 @@ static void mousedev_disconnect(struct input_handle *handle)
         struct mousedev *mousedev = handle->private;
         struct mousedev_list *list;
 
-        class_simple_device_remove(MKDEV(INPUT_MAJOR, MOUSEDEV_MINOR_BASE + mousedev->minor));
+        class_device_destroy(input_class,
+                        MKDEV(INPUT_MAJOR, MOUSEDEV_MINOR_BASE + mousedev->minor));
         devfs_remove("input/mouse%d", mousedev->minor);
         mousedev->exist = 0;
 
@@ -739,8 +740,8 @@ static int __init mousedev_init(void)
 
         devfs_mk_cdev(MKDEV(INPUT_MAJOR, MOUSEDEV_MINOR_BASE + MOUSEDEV_MIX),
                         S_IFCHR|S_IRUGO|S_IWUSR, "input/mice");
-        class_simple_device_add(input_class, MKDEV(INPUT_MAJOR, MOUSEDEV_MINOR_BASE + MOUSEDEV_MIX),
-                                NULL, "mice");
+        class_device_create(input_class,
+                        MKDEV(INPUT_MAJOR, MOUSEDEV_MINOR_BASE + MOUSEDEV_MIX), NULL, "mice");
 
 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
         if (!(psaux_registered = !misc_register(&psaux_mouse)))
@@ -759,7 +760,8 @@ static void __exit mousedev_exit(void)
                 misc_deregister(&psaux_mouse);
 #endif
         devfs_remove("input/mice");
-        class_simple_device_remove(MKDEV(INPUT_MAJOR, MOUSEDEV_MINOR_BASE + MOUSEDEV_MIX));
+        class_device_destroy(input_class,
+                        MKDEV(INPUT_MAJOR, MOUSEDEV_MINOR_BASE + MOUSEDEV_MIX));
         input_unregister_handler(&mousedev_handler);
 }
 
diff --git a/drivers/input/serio/i8042.c b/drivers/input/serio/i8042.c
index 5900de3c3f4f..a9bf549c8dc5 100644
--- a/drivers/input/serio/i8042.c
+++ b/drivers/input/serio/i8042.c
@@ -396,7 +396,7 @@ static void i8042_stop(struct serio *serio)
         struct i8042_port *port = serio->port_data;
 
         port->exists = 0;
-        synchronize_kernel();
+        synchronize_sched();
         port->serio = NULL;
 }
 
diff --git a/drivers/input/serio/serio.c b/drivers/input/serio/serio.c
index 615bf62ad468..341824c48529 100644
--- a/drivers/input/serio/serio.c
+++ b/drivers/input/serio/serio.c
@@ -31,9 +31,10 @@
 #include <linux/serio.h>
 #include <linux/errno.h>
 #include <linux/wait.h>
+#include <linux/completion.h>
 #include <linux/sched.h>
+#include <linux/smp_lock.h>
 #include <linux/slab.h>
-#include <linux/kthread.h>
 
 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
 MODULE_DESCRIPTION("Serio abstraction core");
@@ -42,7 +43,6 @@ MODULE_LICENSE("GPL");
 EXPORT_SYMBOL(serio_interrupt);
 EXPORT_SYMBOL(__serio_register_port);
 EXPORT_SYMBOL(serio_unregister_port);
-EXPORT_SYMBOL(serio_unregister_child_port);
 EXPORT_SYMBOL(__serio_unregister_port_delayed);
 EXPORT_SYMBOL(__serio_register_driver);
 EXPORT_SYMBOL(serio_unregister_driver);
@@ -68,37 +68,6 @@ static void serio_destroy_port(struct serio *serio);
 static void serio_reconnect_port(struct serio *serio);
 static void serio_disconnect_port(struct serio *serio);
 
-static int serio_connect_driver(struct serio *serio, struct serio_driver *drv)
-{
-        int retval;
-
-        down(&serio->drv_sem);
-        retval = drv->connect(serio, drv);
-        up(&serio->drv_sem);
-
-        return retval;
-}
-
-static int serio_reconnect_driver(struct serio *serio)
-{
-        int retval = -1;
-
-        down(&serio->drv_sem);
-        if (serio->drv && serio->drv->reconnect)
-                retval = serio->drv->reconnect(serio);
-        up(&serio->drv_sem);
-
-        return retval;
-}
-
-static void serio_disconnect_driver(struct serio *serio)
-{
-        down(&serio->drv_sem);
-        if (serio->drv)
-                serio->drv->disconnect(serio);
-        up(&serio->drv_sem);
-}
-
 static int serio_match_port(const struct serio_device_id *ids, struct serio *serio)
 {
         while (ids->type || ids->proto) {
@@ -122,7 +91,7 @@ static void serio_bind_driver(struct serio *serio, struct serio_driver *drv)
 
         if (serio_match_port(drv->id_table, serio)) {
                 serio->dev.driver = &drv->driver;
-                if (serio_connect_driver(serio, drv)) {
+                if (drv->connect(serio, drv)) {
                         serio->dev.driver = NULL;
                         goto out;
                 }
@@ -169,7 +138,8 @@ struct serio_event {
 static DEFINE_SPINLOCK(serio_event_lock);       /* protects serio_event_list */
 static LIST_HEAD(serio_event_list);
 static DECLARE_WAIT_QUEUE_HEAD(serio_wait);
-static struct task_struct *serio_task;
+static DECLARE_COMPLETION(serio_exited);
+static int serio_pid;
 
 static void serio_queue_event(void *object, struct module *owner,
                               enum serio_event_type event_type)
@@ -180,12 +150,12 @@ static void serio_queue_event(void *object, struct module *owner,
         spin_lock_irqsave(&serio_event_lock, flags);
 
         /*
-         * Scan event list for the other events for the same serio port,
+         * Scan event list for the other events for the same serio port,
          * starting with the most recent one. If event is the same we
          * do not need add new one. If event is of different type we
          * need to add this event and should not look further because
          * we need to preseve sequence of distinct events.
-         */
+         */
         list_for_each_entry_reverse(event, &serio_event_list, node) {
                 if (event->object == object) {
                         if (event->type == event_type)
@@ -367,15 +337,20 @@ static struct serio *serio_get_pending_child(struct serio *parent)
 
 static int serio_thread(void *nothing)
 {
+        lock_kernel();
+        daemonize("kseriod");
+        allow_signal(SIGTERM);
+
         do {
                 serio_handle_events();
-                wait_event_interruptible(serio_wait,
-                        kthread_should_stop() || !list_empty(&serio_event_list));
-                try_to_freeze(PF_FREEZE);
-        } while (!kthread_should_stop());
+                wait_event_interruptible(serio_wait, !list_empty(&serio_event_list));
+                try_to_freeze();
+        } while (!signal_pending(current));
 
         printk(KERN_DEBUG "serio: kseriod exiting\n");
-        return 0;
+
+        unlock_kernel();
+        complete_and_exit(&serio_exited, 0);
 }
 
 
@@ -383,31 +358,31 @@ static int serio_thread(void *nothing)
  * Serio port operations
  */
 
-static ssize_t serio_show_description(struct device *dev, char *buf)
+static ssize_t serio_show_description(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct serio *serio = to_serio_port(dev);
         return sprintf(buf, "%s\n", serio->name);
 }
 
-static ssize_t serio_show_id_type(struct device *dev, char *buf)
+static ssize_t serio_show_id_type(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct serio *serio = to_serio_port(dev);
         return sprintf(buf, "%02x\n", serio->id.type);
 }
 
-static ssize_t serio_show_id_proto(struct device *dev, char *buf)
+static ssize_t serio_show_id_proto(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct serio *serio = to_serio_port(dev);
         return sprintf(buf, "%02x\n", serio->id.proto);
 }
 
-static ssize_t serio_show_id_id(struct device *dev, char *buf)
+static ssize_t serio_show_id_id(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct serio *serio = to_serio_port(dev);
         return sprintf(buf, "%02x\n", serio->id.id);
 }
 
-static ssize_t serio_show_id_extra(struct device *dev, char *buf)
+static ssize_t serio_show_id_extra(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct serio *serio = to_serio_port(dev);
         return sprintf(buf, "%02x\n", serio->id.extra);
@@ -431,7 +406,7 @@ static struct attribute_group serio_id_attr_group = {
         .attrs  = serio_device_id_attrs,
 };
 
-static ssize_t serio_rebind_driver(struct device *dev, const char *buf, size_t count)
+static ssize_t serio_rebind_driver(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
         struct serio *serio = to_serio_port(dev);
         struct device_driver *drv;
@@ -462,13 +437,13 @@ static ssize_t serio_rebind_driver(struct device *dev, const char *buf, size_t c
         return retval;
 }
 
-static ssize_t serio_show_bind_mode(struct device *dev, char *buf)
+static ssize_t serio_show_bind_mode(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct serio *serio = to_serio_port(dev);
         return sprintf(buf, "%s\n", serio->manual_bind ? "manual" : "auto");
 }
 
-static ssize_t serio_set_bind_mode(struct device *dev, const char *buf, size_t count)
+static ssize_t serio_set_bind_mode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
         struct serio *serio = to_serio_port(dev);
         int retval;
@@ -582,7 +557,7 @@ static void serio_destroy_port(struct serio *serio)
 static void serio_reconnect_port(struct serio *serio)
 {
         do {
-                if (serio_reconnect_driver(serio)) {
+                if (!serio->drv || !serio->drv->reconnect || serio->drv->reconnect(serio)) {
                         serio_disconnect_port(serio);
                         serio_find_driver(serio);
                         /* Ok, old children are now gone, we are done */
@@ -655,19 +630,6 @@ void serio_unregister_port(struct serio *serio)
 }
 
 /*
- * Safely unregisters child port if one is present.
- */
-void serio_unregister_child_port(struct serio *serio)
-{
-        down(&serio_sem);
-        if (serio->child) {
-                serio_disconnect_port(serio->child);
-                serio_destroy_port(serio->child);
-        }
-        up(&serio_sem);
-}
-
-/*
  * Submits register request to kseriod for subsequent execution.
  * Can be used when it is not obvious whether the serio_sem is
  * taken or not and when delayed execution is feasible.
@@ -724,14 +686,15 @@ static int serio_driver_probe(struct device *dev)
         struct serio *serio = to_serio_port(dev);
         struct serio_driver *drv = to_serio_driver(dev->driver);
 
-        return serio_connect_driver(serio, drv);
+        return drv->connect(serio, drv);
 }
 
 static int serio_driver_remove(struct device *dev)
 {
         struct serio *serio = to_serio_port(dev);
+        struct serio_driver *drv = to_serio_driver(dev->driver);
 
-        serio_disconnect_driver(serio);
+        drv->disconnect(serio);
         return 0;
 }
 
@@ -767,9 +730,11 @@ start_over:
 
 static void serio_set_drv(struct serio *serio, struct serio_driver *drv)
 {
+        down(&serio->drv_sem);
         serio_pause_rx(serio);
         serio->drv = drv;
         serio_continue_rx(serio);
+        up(&serio->drv_sem);
 }
 
 static int serio_bus_match(struct device *dev, struct device_driver *drv)
@@ -829,7 +794,7 @@ static int serio_resume(struct device *dev)
 {
         struct serio *serio = to_serio_port(dev);
 
-        if (serio_reconnect_driver(serio)) {
+        if (!serio->drv || !serio->drv->reconnect || serio->drv->reconnect(serio)) {
                 /*
                  * Driver re-probing can take a while, so better let kseriod
                  * deal with it.
@@ -883,10 +848,9 @@ 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)) {
+        if (!(serio_pid = kernel_thread(serio_thread, NULL, CLONE_KERNEL))) {
                 printk(KERN_ERR "serio: Failed to start kseriod\n");
-                return PTR_ERR(serio_task);
+                return -1;
         }
 
         serio_bus.dev_attrs = serio_device_attrs;
@@ -902,7 +866,8 @@ static int __init serio_init(void)
 static void __exit serio_exit(void)
 {
         bus_unregister(&serio_bus);
-        kthread_stop(serio_task);
+        kill_proc(serio_pid, SIGTERM, 1);
+        wait_for_completion(&serio_exited);
 }
 
 module_init(serio_init);
diff --git a/drivers/input/serio/serport.c b/drivers/input/serio/serport.c
index f6b85222ba3d..79ca38469159 100644
--- a/drivers/input/serio/serport.c
+++ b/drivers/input/serio/serport.c
@@ -257,7 +257,7 @@ static int __init serport_init(void)
 
 static void __exit serport_exit(void)
 {
-        tty_register_ldisc(N_MOUSE, NULL);
+        tty_unregister_ldisc(N_MOUSE);
 }
 
 module_init(serport_init);
diff --git a/drivers/input/tsdev.c b/drivers/input/tsdev.c
index d0afba85720b..50c63a155156 100644
--- a/drivers/input/tsdev.c
+++ b/drivers/input/tsdev.c
@@ -414,9 +414,9 @@ static struct input_handle *tsdev_connect(struct input_handler *handler,
                         S_IFCHR|S_IRUGO|S_IWUSR, "input/ts%d", minor);
         devfs_mk_cdev(MKDEV(INPUT_MAJOR, TSDEV_MINOR_BASE + minor + TSDEV_MINORS/2),
                         S_IFCHR|S_IRUGO|S_IWUSR, "input/tsraw%d", minor);
-        class_simple_device_add(input_class,
-                                MKDEV(INPUT_MAJOR, TSDEV_MINOR_BASE + minor),
-                                dev->dev, "ts%d", minor);
+        class_device_create(input_class,
+                        MKDEV(INPUT_MAJOR, TSDEV_MINOR_BASE + minor),
+                        dev->dev, "ts%d", minor);
 
         return &tsdev->handle;
 }
@@ -426,7 +426,8 @@ static void tsdev_disconnect(struct input_handle *handle)
         struct tsdev *tsdev = handle->private;
         struct tsdev_list *list;
 
-        class_simple_device_remove(MKDEV(INPUT_MAJOR, TSDEV_MINOR_BASE + tsdev->minor));
+        class_device_destroy(input_class,
+                        MKDEV(INPUT_MAJOR, TSDEV_MINOR_BASE + tsdev->minor));
         devfs_remove("input/ts%d", tsdev->minor);
         devfs_remove("input/tsraw%d", tsdev->minor);
         tsdev->exist = 0;