1 files changed, 78 insertions, 96 deletions

diff --git a/drivers/macintosh/adb.c b/drivers/macintosh/adb.c
index b7adde4324e4..7ce0ea64465c 100644
--- a/drivers/macintosh/adb.c
+++ b/drivers/macintosh/adb.c
@@ -35,6 +35,7 @@
 #include <linux/spinlock.h>
 #include <linux/completion.h>
 #include <linux/device.h>
+#include <linux/kthread.h>
 
 #include <asm/uaccess.h>
 #include <asm/semaphore.h>
@@ -82,21 +83,11 @@ struct adb_driver *adb_controller;
 BLOCKING_NOTIFIER_HEAD(adb_client_list);
 static int adb_got_sleep;
 static int adb_inited;
-static pid_t adb_probe_task_pid;
 static DECLARE_MUTEX(adb_probe_mutex);
-static struct completion adb_probe_task_comp;
 static int sleepy_trackpad;
 static int autopoll_devs;
 int __adb_probe_sync;
 
-#ifdef CONFIG_PM_SLEEP
-static void adb_notify_sleep(struct pmu_sleep_notifier *self, int when);
-static struct pmu_sleep_notifier adb_sleep_notifier = {
-        adb_notify_sleep,
-        SLEEP_LEVEL_ADB,
-};
-#endif
-
 static int adb_scan_bus(void);
 static int do_adb_reset_bus(void);
 static void adbdev_init(void);
@@ -134,16 +125,6 @@ static void printADBreply(struct adb_request *req)
 }
 #endif
 
-
-static __inline__ void adb_wait_ms(unsigned int ms)
-{
-        if (current->pid && adb_probe_task_pid &&
-          adb_probe_task_pid == current->pid)
-                msleep(ms);
-        else
-                mdelay(ms);
-}
-
 static int adb_scan_bus(void)
 {
         int i, highFree=0, noMovement;
@@ -248,13 +229,10 @@ static int adb_scan_bus(void)
 static int
 adb_probe_task(void *x)
 {
-        strcpy(current->comm, "kadbprobe");
-
         printk(KERN_INFO "adb: starting probe task...\n");
         do_adb_reset_bus();
         printk(KERN_INFO "adb: finished probe task...\n");
 
-        adb_probe_task_pid = 0;
         up(&adb_probe_mutex);
 
         return 0;
@@ -263,7 +241,7 @@ adb_probe_task(void *x)
 static void
 __adb_probe_task(struct work_struct *bullshit)
 {
-        adb_probe_task_pid = kernel_thread(adb_probe_task, NULL, SIGCHLD | CLONE_KERNEL);
+        kthread_run(adb_probe_task, NULL, "kadbprobe");
 }
 
 static DECLARE_WORK(adb_reset_work, __adb_probe_task);
@@ -281,6 +259,36 @@ adb_reset_bus(void)
         return 0;
 }
 
+#ifdef CONFIG_PM
+/*
+ * notify clients before sleep
+ */
+static int adb_suspend(struct platform_device *dev, pm_message_t state)
+{
+        adb_got_sleep = 1;
+        /* We need to get a lock on the probe thread */
+        down(&adb_probe_mutex);
+        /* Stop autopoll */
+        if (adb_controller->autopoll)
+                adb_controller->autopoll(0);
+        blocking_notifier_call_chain(&adb_client_list, ADB_MSG_POWERDOWN, NULL);
+
+        return 0;
+}
+
+/*
+ * reset bus after sleep
+ */
+static int adb_resume(struct platform_device *dev)
+{
+        adb_got_sleep = 0;
+        up(&adb_probe_mutex);
+        adb_reset_bus();
+
+        return 0;
+}
+#endif /* CONFIG_PM */
+
 int __init adb_init(void)
 {
         struct adb_driver *driver;
@@ -313,15 +321,12 @@ int __init adb_init(void)
                 printk(KERN_WARNING "Warning: no ADB interface detected\n");
                 adb_controller = NULL;
         } else {
-#ifdef CONFIG_PM_SLEEP
-                pmu_register_sleep_notifier(&adb_sleep_notifier);
-#endif /* CONFIG_PM */
 #ifdef CONFIG_PPC
                 if (machine_is_compatible("AAPL,PowerBook1998") ||
                         machine_is_compatible("PowerBook1,1"))
                         sleepy_trackpad = 1;
 #endif /* CONFIG_PPC */
-                init_completion(&adb_probe_task_comp);
+
                 adbdev_init();
                 adb_reset_bus();
         }
@@ -330,33 +335,6 @@ int __init adb_init(void)
 
 __initcall(adb_init);
 
-#ifdef CONFIG_PM
-/*
- * notify clients before sleep and reset bus afterwards
- */
-void
-adb_notify_sleep(struct pmu_sleep_notifier *self, int when)
-{
-        switch (when) {
-        case PBOOK_SLEEP_REQUEST:
-                adb_got_sleep = 1;
-                /* We need to get a lock on the probe thread */
-                down(&adb_probe_mutex);
-                /* Stop autopoll */
-                if (adb_controller->autopoll)
-                        adb_controller->autopoll(0);
-                blocking_notifier_call_chain(&adb_client_list,
-                        ADB_MSG_POWERDOWN, NULL);
-                break;
-        case PBOOK_WAKE:
-                adb_got_sleep = 0;
-                up(&adb_probe_mutex);
-                adb_reset_bus();
-                break;
-        }
-}
-#endif /* CONFIG_PM */
-
 static int
 do_adb_reset_bus(void)
 {
@@ -373,7 +351,7 @@ do_adb_reset_bus(void)
 
         if (sleepy_trackpad) {
                 /* Let the trackpad settle down */
-                adb_wait_ms(500);
+                msleep(500);
         }
 
         down(&adb_handler_sem);
@@ -389,7 +367,7 @@ do_adb_reset_bus(void)
 
         if (sleepy_trackpad) {
                 /* Let the trackpad settle down */
-                adb_wait_ms(1500);
+                msleep(1500);
         }
 
         if (!ret) {
@@ -413,41 +391,27 @@ adb_poll(void)
         adb_controller->poll();
 }
 
-static void
-adb_probe_wakeup(struct adb_request *req)
+static void adb_sync_req_done(struct adb_request *req)
 {
-        complete(&adb_probe_task_comp);
-}
+        struct completion *comp = req->arg;
 
-/* Static request used during probe */
-static struct adb_request adb_sreq;
-static unsigned long adb_sreq_lock; // Use semaphore ! */ 
+        complete(comp);
+}
 
 int
 adb_request(struct adb_request *req, void (*done)(struct adb_request *),
             int flags, int nbytes, ...)
 {
         va_list list;
-        int i, use_sreq;
+        int i;
         int rc;
+        struct completion comp;
 
         if ((adb_controller == NULL) || (adb_controller->send_request == NULL))
                 return -ENXIO;
         if (nbytes < 1)
                 return -EINVAL;
-        if (req == NULL && (flags & ADBREQ_NOSEND))
-                return -EINVAL;
-        
-        if (req == NULL) {
-                if (test_and_set_bit(0,&adb_sreq_lock)) {
-                        printk("adb.c: Warning: contention on static request !\n");
-                        return -EPERM;
-                }
-                req = &adb_sreq;
-                flags |= ADBREQ_SYNC;
-                use_sreq = 1;
-        } else
-                use_sreq = 0;
+
         req->nbytes = nbytes+1;
         req->done = done;
         req->reply_expected = flags & ADBREQ_REPLY;
@@ -460,25 +424,18 @@ adb_request(struct adb_request *req, void (*done)(struct adb_request *),
         if (flags & ADBREQ_NOSEND)
                 return 0;
 
-        /* Synchronous requests send from the probe thread cause it to
-         * block. Beware that the "done" callback will be overriden !
-         */
-        if ((flags & ADBREQ_SYNC) &&
-            (current->pid && adb_probe_task_pid &&
-            adb_probe_task_pid == current->pid)) {
-                req->done = adb_probe_wakeup;
-                rc = adb_controller->send_request(req, 0);
-                if (rc || req->complete)
-                        goto bail;
-                wait_for_completion(&adb_probe_task_comp);
-                rc = 0;
-                goto bail;
+        /* Synchronous requests block using an on-stack completion */
+        if (flags & ADBREQ_SYNC) {
+                WARN_ON(done);
+                req->done = adb_sync_req_done;
+                req->arg = &comp;
+                init_completion(&comp);
         }
 
-        rc = adb_controller->send_request(req, flags & ADBREQ_SYNC);
-bail:
-        if (use_sreq)
-                clear_bit(0, &adb_sreq_lock);
+        rc = adb_controller->send_request(req, 0);
+
+        if ((flags & ADBREQ_SYNC) && !rc && !req->complete)
+                wait_for_completion(&comp);
 
         return rc;
 }
@@ -864,7 +821,29 @@ static const struct file_operations adb_fops = {
         .release        = adb_release,
 };
 
-static void
+static struct platform_driver adb_pfdrv = {
+        .driver = {
+                .name = "adb",
+        },
+#ifdef CONFIG_PM
+        .suspend = adb_suspend,
+        .resume = adb_resume,
+#endif
+};
+
+static struct platform_device adb_pfdev = {
+        .name = "adb",
+};
+
+static int __init
+adb_dummy_probe(struct platform_device *dev)
+{
+        if (dev == &adb_pfdev)
+                return 0;
+        return -ENODEV;
+}
+
+static void __init
 adbdev_init(void)
 {
         if (register_chrdev(ADB_MAJOR, "adb", &adb_fops)) {
@@ -876,4 +855,7 @@ adbdev_init(void)
         if (IS_ERR(adb_dev_class))
                 return;
         device_create(adb_dev_class, NULL, MKDEV(ADB_MAJOR, 0), "adb");
+
+        platform_device_register(&adb_pfdev);
+        platform_driver_probe(&adb_pfdrv, adb_dummy_probe);
 }