Merge branch 'linus' into x86/threadinfo
[linux-2.6] / drivers / macintosh / adb.c
1 /*
2  * Device driver for the Apple Desktop Bus
3  * and the /dev/adb device on macintoshes.
4  *
5  * Copyright (C) 1996 Paul Mackerras.
6  *
7  * Modified to declare controllers as structures, added
8  * client notification of bus reset and handles PowerBook
9  * sleep, by Benjamin Herrenschmidt.
10  *
11  * To do:
12  *
13  * - /sys/bus/adb to list the devices and infos
14  * - more /dev/adb to allow userland to receive the
15  *   flow of auto-polling datas from a given device.
16  * - move bus probe to a kernel thread
17  */
18
19 #include <linux/types.h>
20 #include <linux/errno.h>
21 #include <linux/kernel.h>
22 #include <linux/slab.h>
23 #include <linux/module.h>
24 #include <linux/fs.h>
25 #include <linux/mm.h>
26 #include <linux/sched.h>
27 #include <linux/smp_lock.h>
28 #include <linux/adb.h>
29 #include <linux/cuda.h>
30 #include <linux/pmu.h>
31 #include <linux/notifier.h>
32 #include <linux/wait.h>
33 #include <linux/init.h>
34 #include <linux/delay.h>
35 #include <linux/spinlock.h>
36 #include <linux/completion.h>
37 #include <linux/device.h>
38 #include <linux/kthread.h>
39 #include <linux/platform_device.h>
40 #include <linux/mutex.h>
41
42 #include <asm/uaccess.h>
43 #ifdef CONFIG_PPC
44 #include <asm/prom.h>
45 #include <asm/machdep.h>
46 #endif
47
48
49 EXPORT_SYMBOL(adb_controller);
50 EXPORT_SYMBOL(adb_client_list);
51
52 extern struct adb_driver via_macii_driver;
53 extern struct adb_driver via_maciisi_driver;
54 extern struct adb_driver via_cuda_driver;
55 extern struct adb_driver adb_iop_driver;
56 extern struct adb_driver via_pmu_driver;
57 extern struct adb_driver macio_adb_driver;
58
59 static struct adb_driver *adb_driver_list[] = {
60 #ifdef CONFIG_ADB_MACII
61         &via_macii_driver,
62 #endif
63 #ifdef CONFIG_ADB_MACIISI
64         &via_maciisi_driver,
65 #endif
66 #ifdef CONFIG_ADB_CUDA
67         &via_cuda_driver,
68 #endif
69 #ifdef CONFIG_ADB_IOP
70         &adb_iop_driver,
71 #endif
72 #if defined(CONFIG_ADB_PMU) || defined(CONFIG_ADB_PMU68K)
73         &via_pmu_driver,
74 #endif
75 #ifdef CONFIG_ADB_MACIO
76         &macio_adb_driver,
77 #endif
78         NULL
79 };
80
81 static struct class *adb_dev_class;
82
83 struct adb_driver *adb_controller;
84 BLOCKING_NOTIFIER_HEAD(adb_client_list);
85 static int adb_got_sleep;
86 static int adb_inited;
87 static DECLARE_MUTEX(adb_probe_mutex);
88 static int sleepy_trackpad;
89 static int autopoll_devs;
90 int __adb_probe_sync;
91
92 static int adb_scan_bus(void);
93 static int do_adb_reset_bus(void);
94 static void adbdev_init(void);
95 static int try_handler_change(int, int);
96
97 static struct adb_handler {
98         void (*handler)(unsigned char *, int, int);
99         int original_address;
100         int handler_id;
101         int busy;
102 } adb_handler[16];
103
104 /*
105  * The adb_handler_mutex mutex protects all accesses to the original_address
106  * and handler_id fields of adb_handler[i] for all i, and changes to the
107  * handler field.
108  * Accesses to the handler field are protected by the adb_handler_lock
109  * rwlock.  It is held across all calls to any handler, so that by the
110  * time adb_unregister returns, we know that the old handler isn't being
111  * called.
112  */
113 static DEFINE_MUTEX(adb_handler_mutex);
114 static DEFINE_RWLOCK(adb_handler_lock);
115
116 #if 0
117 static void printADBreply(struct adb_request *req)
118 {
119         int i;
120
121         printk("adb reply (%d)", req->reply_len);
122         for(i = 0; i < req->reply_len; i++)
123                 printk(" %x", req->reply[i]);
124         printk("\n");
125
126 }
127 #endif
128
129 static int adb_scan_bus(void)
130 {
131         int i, highFree=0, noMovement;
132         int devmask = 0;
133         struct adb_request req;
134         
135         /* assumes adb_handler[] is all zeroes at this point */
136         for (i = 1; i < 16; i++) {
137                 /* see if there is anything at address i */
138                 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
139                             (i << 4) | 0xf);
140                 if (req.reply_len > 1)
141                         /* one or more devices at this address */
142                         adb_handler[i].original_address = i;
143                 else if (i > highFree)
144                         highFree = i;
145         }
146
147         /* Note we reset noMovement to 0 each time we move a device */
148         for (noMovement = 1; noMovement < 2 && highFree > 0; noMovement++) {
149                 for (i = 1; i < 16; i++) {
150                         if (adb_handler[i].original_address == 0)
151                                 continue;
152                         /*
153                          * Send a "talk register 3" command to address i
154                          * to provoke a collision if there is more than
155                          * one device at this address.
156                          */
157                         adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
158                                     (i << 4) | 0xf);
159                         /*
160                          * Move the device(s) which didn't detect a
161                          * collision to address `highFree'.  Hopefully
162                          * this only moves one device.
163                          */
164                         adb_request(&req, NULL, ADBREQ_SYNC, 3,
165                                     (i<< 4) | 0xb, (highFree | 0x60), 0xfe);
166                         /*
167                          * See if anybody actually moved. This is suggested
168                          * by HW TechNote 01:
169                          *
170                          * http://developer.apple.com/technotes/hw/hw_01.html
171                          */
172                         adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
173                                     (highFree << 4) | 0xf);
174                         if (req.reply_len <= 1) continue;
175                         /*
176                          * Test whether there are any device(s) left
177                          * at address i.
178                          */
179                         adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
180                                     (i << 4) | 0xf);
181                         if (req.reply_len > 1) {
182                                 /*
183                                  * There are still one or more devices
184                                  * left at address i.  Register the one(s)
185                                  * we moved to `highFree', and find a new
186                                  * value for highFree.
187                                  */
188                                 adb_handler[highFree].original_address =
189                                         adb_handler[i].original_address;
190                                 while (highFree > 0 &&
191                                        adb_handler[highFree].original_address)
192                                         highFree--;
193                                 if (highFree <= 0)
194                                         break;
195
196                                 noMovement = 0;
197                         }
198                         else {
199                                 /*
200                                  * No devices left at address i; move the
201                                  * one(s) we moved to `highFree' back to i.
202                                  */
203                                 adb_request(&req, NULL, ADBREQ_SYNC, 3,
204                                             (highFree << 4) | 0xb,
205                                             (i | 0x60), 0xfe);
206                         }
207                 }       
208         }
209
210         /* Now fill in the handler_id field of the adb_handler entries. */
211         printk(KERN_DEBUG "adb devices:");
212         for (i = 1; i < 16; i++) {
213                 if (adb_handler[i].original_address == 0)
214                         continue;
215                 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
216                             (i << 4) | 0xf);
217                 adb_handler[i].handler_id = req.reply[2];
218                 printk(" [%d]: %d %x", i, adb_handler[i].original_address,
219                        adb_handler[i].handler_id);
220                 devmask |= 1 << i;
221         }
222         printk("\n");
223         return devmask;
224 }
225
226 /*
227  * This kernel task handles ADB probing. It dies once probing is
228  * completed.
229  */
230 static int
231 adb_probe_task(void *x)
232 {
233         printk(KERN_INFO "adb: starting probe task...\n");
234         do_adb_reset_bus();
235         printk(KERN_INFO "adb: finished probe task...\n");
236
237         up(&adb_probe_mutex);
238
239         return 0;
240 }
241
242 static void
243 __adb_probe_task(struct work_struct *bullshit)
244 {
245         kthread_run(adb_probe_task, NULL, "kadbprobe");
246 }
247
248 static DECLARE_WORK(adb_reset_work, __adb_probe_task);
249
250 int
251 adb_reset_bus(void)
252 {
253         if (__adb_probe_sync) {
254                 do_adb_reset_bus();
255                 return 0;
256         }
257
258         down(&adb_probe_mutex);
259         schedule_work(&adb_reset_work);
260         return 0;
261 }
262
263 #ifdef CONFIG_PM
264 /*
265  * notify clients before sleep
266  */
267 static int adb_suspend(struct platform_device *dev, pm_message_t state)
268 {
269         adb_got_sleep = 1;
270         /* We need to get a lock on the probe thread */
271         down(&adb_probe_mutex);
272         /* Stop autopoll */
273         if (adb_controller->autopoll)
274                 adb_controller->autopoll(0);
275         blocking_notifier_call_chain(&adb_client_list, ADB_MSG_POWERDOWN, NULL);
276
277         return 0;
278 }
279
280 /*
281  * reset bus after sleep
282  */
283 static int adb_resume(struct platform_device *dev)
284 {
285         adb_got_sleep = 0;
286         up(&adb_probe_mutex);
287         adb_reset_bus();
288
289         return 0;
290 }
291 #endif /* CONFIG_PM */
292
293 int __init adb_init(void)
294 {
295         struct adb_driver *driver;
296         int i;
297
298 #ifdef CONFIG_PPC32
299         if (!machine_is(chrp) && !machine_is(powermac))
300                 return 0;
301 #endif
302 #ifdef CONFIG_MAC
303         if (!MACH_IS_MAC)
304                 return 0;
305 #endif
306
307         /* xmon may do early-init */
308         if (adb_inited)
309                 return 0;
310         adb_inited = 1;
311                 
312         adb_controller = NULL;
313
314         i = 0;
315         while ((driver = adb_driver_list[i++]) != NULL) {
316                 if (!driver->probe()) {
317                         adb_controller = driver;
318                         break;
319                 }
320         }
321         if ((adb_controller == NULL) || adb_controller->init()) {
322                 printk(KERN_WARNING "Warning: no ADB interface detected\n");
323                 adb_controller = NULL;
324         } else {
325 #ifdef CONFIG_PPC
326                 if (machine_is_compatible("AAPL,PowerBook1998") ||
327                         machine_is_compatible("PowerBook1,1"))
328                         sleepy_trackpad = 1;
329 #endif /* CONFIG_PPC */
330
331                 adbdev_init();
332                 adb_reset_bus();
333         }
334         return 0;
335 }
336
337 device_initcall(adb_init);
338
339 static int
340 do_adb_reset_bus(void)
341 {
342         int ret;
343         
344         if (adb_controller == NULL)
345                 return -ENXIO;
346                 
347         if (adb_controller->autopoll)
348                 adb_controller->autopoll(0);
349
350         blocking_notifier_call_chain(&adb_client_list,
351                 ADB_MSG_PRE_RESET, NULL);
352
353         if (sleepy_trackpad) {
354                 /* Let the trackpad settle down */
355                 msleep(500);
356         }
357
358         mutex_lock(&adb_handler_mutex);
359         write_lock_irq(&adb_handler_lock);
360         memset(adb_handler, 0, sizeof(adb_handler));
361         write_unlock_irq(&adb_handler_lock);
362
363         /* That one is still a bit synchronous, oh well... */
364         if (adb_controller->reset_bus)
365                 ret = adb_controller->reset_bus();
366         else
367                 ret = 0;
368
369         if (sleepy_trackpad) {
370                 /* Let the trackpad settle down */
371                 msleep(1500);
372         }
373
374         if (!ret) {
375                 autopoll_devs = adb_scan_bus();
376                 if (adb_controller->autopoll)
377                         adb_controller->autopoll(autopoll_devs);
378         }
379         mutex_unlock(&adb_handler_mutex);
380
381         blocking_notifier_call_chain(&adb_client_list,
382                 ADB_MSG_POST_RESET, NULL);
383         
384         return ret;
385 }
386
387 void
388 adb_poll(void)
389 {
390         if ((adb_controller == NULL)||(adb_controller->poll == NULL))
391                 return;
392         adb_controller->poll();
393 }
394
395 static void adb_sync_req_done(struct adb_request *req)
396 {
397         struct completion *comp = req->arg;
398
399         complete(comp);
400 }
401
402 int
403 adb_request(struct adb_request *req, void (*done)(struct adb_request *),
404             int flags, int nbytes, ...)
405 {
406         va_list list;
407         int i;
408         int rc;
409         struct completion comp;
410
411         if ((adb_controller == NULL) || (adb_controller->send_request == NULL))
412                 return -ENXIO;
413         if (nbytes < 1)
414                 return -EINVAL;
415
416         req->nbytes = nbytes+1;
417         req->done = done;
418         req->reply_expected = flags & ADBREQ_REPLY;
419         req->data[0] = ADB_PACKET;
420         va_start(list, nbytes);
421         for (i = 0; i < nbytes; ++i)
422                 req->data[i+1] = va_arg(list, int);
423         va_end(list);
424
425         if (flags & ADBREQ_NOSEND)
426                 return 0;
427
428         /* Synchronous requests block using an on-stack completion */
429         if (flags & ADBREQ_SYNC) {
430                 WARN_ON(done);
431                 req->done = adb_sync_req_done;
432                 req->arg = &comp;
433                 init_completion(&comp);
434         }
435
436         rc = adb_controller->send_request(req, 0);
437
438         if ((flags & ADBREQ_SYNC) && !rc && !req->complete)
439                 wait_for_completion(&comp);
440
441         return rc;
442 }
443
444  /* Ultimately this should return the number of devices with
445     the given default id.
446     And it does it now ! Note: changed behaviour: This function
447     will now register if default_id _and_ handler_id both match
448     but handler_id can be left to 0 to match with default_id only.
449     When handler_id is set, this function will try to adjust
450     the handler_id id it doesn't match. */
451 int
452 adb_register(int default_id, int handler_id, struct adb_ids *ids,
453              void (*handler)(unsigned char *, int, int))
454 {
455         int i;
456
457         mutex_lock(&adb_handler_mutex);
458         ids->nids = 0;
459         for (i = 1; i < 16; i++) {
460                 if ((adb_handler[i].original_address == default_id) &&
461                     (!handler_id || (handler_id == adb_handler[i].handler_id) || 
462                     try_handler_change(i, handler_id))) {
463                         if (adb_handler[i].handler != 0) {
464                                 printk(KERN_ERR
465                                        "Two handlers for ADB device %d\n",
466                                        default_id);
467                                 continue;
468                         }
469                         write_lock_irq(&adb_handler_lock);
470                         adb_handler[i].handler = handler;
471                         write_unlock_irq(&adb_handler_lock);
472                         ids->id[ids->nids++] = i;
473                 }
474         }
475         mutex_unlock(&adb_handler_mutex);
476         return ids->nids;
477 }
478
479 int
480 adb_unregister(int index)
481 {
482         int ret = -ENODEV;
483
484         mutex_lock(&adb_handler_mutex);
485         write_lock_irq(&adb_handler_lock);
486         if (adb_handler[index].handler) {
487                 while(adb_handler[index].busy) {
488                         write_unlock_irq(&adb_handler_lock);
489                         yield();
490                         write_lock_irq(&adb_handler_lock);
491                 }
492                 ret = 0;
493                 adb_handler[index].handler = NULL;
494         }
495         write_unlock_irq(&adb_handler_lock);
496         mutex_unlock(&adb_handler_mutex);
497         return ret;
498 }
499
500 void
501 adb_input(unsigned char *buf, int nb, int autopoll)
502 {
503         int i, id;
504         static int dump_adb_input = 0;
505         unsigned long flags;
506         
507         void (*handler)(unsigned char *, int, int);
508
509         /* We skip keystrokes and mouse moves when the sleep process
510          * has been started. We stop autopoll, but this is another security
511          */
512         if (adb_got_sleep)
513                 return;
514                 
515         id = buf[0] >> 4;
516         if (dump_adb_input) {
517                 printk(KERN_INFO "adb packet: ");
518                 for (i = 0; i < nb; ++i)
519                         printk(" %x", buf[i]);
520                 printk(", id = %d\n", id);
521         }
522         write_lock_irqsave(&adb_handler_lock, flags);
523         handler = adb_handler[id].handler;
524         if (handler != NULL)
525                 adb_handler[id].busy = 1;
526         write_unlock_irqrestore(&adb_handler_lock, flags);
527         if (handler != NULL) {
528                 (*handler)(buf, nb, autopoll);
529                 wmb();
530                 adb_handler[id].busy = 0;
531         }
532                 
533 }
534
535 /* Try to change handler to new_id. Will return 1 if successful. */
536 static int try_handler_change(int address, int new_id)
537 {
538         struct adb_request req;
539
540         if (adb_handler[address].handler_id == new_id)
541             return 1;
542         adb_request(&req, NULL, ADBREQ_SYNC, 3,
543             ADB_WRITEREG(address, 3), address | 0x20, new_id);
544         adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
545             ADB_READREG(address, 3));
546         if (req.reply_len < 2)
547             return 0;
548         if (req.reply[2] != new_id)
549             return 0;
550         adb_handler[address].handler_id = req.reply[2];
551
552         return 1;
553 }
554
555 int
556 adb_try_handler_change(int address, int new_id)
557 {
558         int ret;
559
560         mutex_lock(&adb_handler_mutex);
561         ret = try_handler_change(address, new_id);
562         mutex_unlock(&adb_handler_mutex);
563         return ret;
564 }
565
566 int
567 adb_get_infos(int address, int *original_address, int *handler_id)
568 {
569         mutex_lock(&adb_handler_mutex);
570         *original_address = adb_handler[address].original_address;
571         *handler_id = adb_handler[address].handler_id;
572         mutex_unlock(&adb_handler_mutex);
573
574         return (*original_address != 0);
575 }
576
577
578 /*
579  * /dev/adb device driver.
580  */
581
582 #define ADB_MAJOR       56      /* major number for /dev/adb */
583
584 struct adbdev_state {
585         spinlock_t      lock;
586         atomic_t        n_pending;
587         struct adb_request *completed;
588         wait_queue_head_t wait_queue;
589         int             inuse;
590 };
591
592 static void adb_write_done(struct adb_request *req)
593 {
594         struct adbdev_state *state = (struct adbdev_state *) req->arg;
595         unsigned long flags;
596
597         if (!req->complete) {
598                 req->reply_len = 0;
599                 req->complete = 1;
600         }
601         spin_lock_irqsave(&state->lock, flags);
602         atomic_dec(&state->n_pending);
603         if (!state->inuse) {
604                 kfree(req);
605                 if (atomic_read(&state->n_pending) == 0) {
606                         spin_unlock_irqrestore(&state->lock, flags);
607                         kfree(state);
608                         return;
609                 }
610         } else {
611                 struct adb_request **ap = &state->completed;
612                 while (*ap != NULL)
613                         ap = &(*ap)->next;
614                 req->next = NULL;
615                 *ap = req;
616                 wake_up_interruptible(&state->wait_queue);
617         }
618         spin_unlock_irqrestore(&state->lock, flags);
619 }
620
621 static int
622 do_adb_query(struct adb_request *req)
623 {
624         int     ret = -EINVAL;
625
626         switch(req->data[1])
627         {
628         case ADB_QUERY_GETDEVINFO:
629                 if (req->nbytes < 3)
630                         break;
631                 mutex_lock(&adb_handler_mutex);
632                 req->reply[0] = adb_handler[req->data[2]].original_address;
633                 req->reply[1] = adb_handler[req->data[2]].handler_id;
634                 mutex_unlock(&adb_handler_mutex);
635                 req->complete = 1;
636                 req->reply_len = 2;
637                 adb_write_done(req);
638                 ret = 0;
639                 break;
640         }
641         return ret;
642 }
643
644 static int adb_open(struct inode *inode, struct file *file)
645 {
646         struct adbdev_state *state;
647
648         if (iminor(inode) > 0 || adb_controller == NULL)
649                 return -ENXIO;
650         state = kmalloc(sizeof(struct adbdev_state), GFP_KERNEL);
651         if (state == 0)
652                 return -ENOMEM;
653         file->private_data = state;
654         spin_lock_init(&state->lock);
655         atomic_set(&state->n_pending, 0);
656         state->completed = NULL;
657         init_waitqueue_head(&state->wait_queue);
658         state->inuse = 1;
659
660         return 0;
661 }
662
663 static int adb_release(struct inode *inode, struct file *file)
664 {
665         struct adbdev_state *state = file->private_data;
666         unsigned long flags;
667
668         lock_kernel();
669         if (state) {
670                 file->private_data = NULL;
671                 spin_lock_irqsave(&state->lock, flags);
672                 if (atomic_read(&state->n_pending) == 0
673                     && state->completed == NULL) {
674                         spin_unlock_irqrestore(&state->lock, flags);
675                         kfree(state);
676                 } else {
677                         state->inuse = 0;
678                         spin_unlock_irqrestore(&state->lock, flags);
679                 }
680         }
681         unlock_kernel();
682         return 0;
683 }
684
685 static ssize_t adb_read(struct file *file, char __user *buf,
686                         size_t count, loff_t *ppos)
687 {
688         int ret = 0;
689         struct adbdev_state *state = file->private_data;
690         struct adb_request *req;
691         wait_queue_t wait = __WAITQUEUE_INITIALIZER(wait,current);
692         unsigned long flags;
693
694         if (count < 2)
695                 return -EINVAL;
696         if (count > sizeof(req->reply))
697                 count = sizeof(req->reply);
698         if (!access_ok(VERIFY_WRITE, buf, count))
699                 return -EFAULT;
700
701         req = NULL;
702         spin_lock_irqsave(&state->lock, flags);
703         add_wait_queue(&state->wait_queue, &wait);
704         current->state = TASK_INTERRUPTIBLE;
705
706         for (;;) {
707                 req = state->completed;
708                 if (req != NULL)
709                         state->completed = req->next;
710                 else if (atomic_read(&state->n_pending) == 0)
711                         ret = -EIO;
712                 if (req != NULL || ret != 0)
713                         break;
714                 
715                 if (file->f_flags & O_NONBLOCK) {
716                         ret = -EAGAIN;
717                         break;
718                 }
719                 if (signal_pending(current)) {
720                         ret = -ERESTARTSYS;
721                         break;
722                 }
723                 spin_unlock_irqrestore(&state->lock, flags);
724                 schedule();
725                 spin_lock_irqsave(&state->lock, flags);
726         }
727
728         current->state = TASK_RUNNING;
729         remove_wait_queue(&state->wait_queue, &wait);
730         spin_unlock_irqrestore(&state->lock, flags);
731         
732         if (ret)
733                 return ret;
734
735         ret = req->reply_len;
736         if (ret > count)
737                 ret = count;
738         if (ret > 0 && copy_to_user(buf, req->reply, ret))
739                 ret = -EFAULT;
740
741         kfree(req);
742         return ret;
743 }
744
745 static ssize_t adb_write(struct file *file, const char __user *buf,
746                          size_t count, loff_t *ppos)
747 {
748         int ret/*, i*/;
749         struct adbdev_state *state = file->private_data;
750         struct adb_request *req;
751
752         if (count < 2 || count > sizeof(req->data))
753                 return -EINVAL;
754         if (adb_controller == NULL)
755                 return -ENXIO;
756         if (!access_ok(VERIFY_READ, buf, count))
757                 return -EFAULT;
758
759         req = kmalloc(sizeof(struct adb_request),
760                                              GFP_KERNEL);
761         if (req == NULL)
762                 return -ENOMEM;
763
764         req->nbytes = count;
765         req->done = adb_write_done;
766         req->arg = (void *) state;
767         req->complete = 0;
768         
769         ret = -EFAULT;
770         if (copy_from_user(req->data, buf, count))
771                 goto out;
772
773         atomic_inc(&state->n_pending);
774
775         /* If a probe is in progress or we are sleeping, wait for it to complete */
776         down(&adb_probe_mutex);
777
778         /* Queries are special requests sent to the ADB driver itself */
779         if (req->data[0] == ADB_QUERY) {
780                 if (count > 1)
781                         ret = do_adb_query(req);
782                 else
783                         ret = -EINVAL;
784                 up(&adb_probe_mutex);
785         }
786         /* Special case for ADB_BUSRESET request, all others are sent to
787            the controller */
788         else if ((req->data[0] == ADB_PACKET)&&(count > 1)
789                 &&(req->data[1] == ADB_BUSRESET)) {
790                 ret = do_adb_reset_bus();
791                 up(&adb_probe_mutex);
792                 atomic_dec(&state->n_pending);
793                 if (ret == 0)
794                         ret = count;
795                 goto out;
796         } else {        
797                 req->reply_expected = ((req->data[1] & 0xc) == 0xc);
798                 if (adb_controller && adb_controller->send_request)
799                         ret = adb_controller->send_request(req, 0);
800                 else
801                         ret = -ENXIO;
802                 up(&adb_probe_mutex);
803         }
804
805         if (ret != 0) {
806                 atomic_dec(&state->n_pending);
807                 goto out;
808         }
809         return count;
810
811 out:
812         kfree(req);
813         return ret;
814 }
815
816 static const struct file_operations adb_fops = {
817         .owner          = THIS_MODULE,
818         .llseek         = no_llseek,
819         .read           = adb_read,
820         .write          = adb_write,
821         .open           = adb_open,
822         .release        = adb_release,
823 };
824
825 static struct platform_driver adb_pfdrv = {
826         .driver = {
827                 .name = "adb",
828         },
829 #ifdef CONFIG_PM
830         .suspend = adb_suspend,
831         .resume = adb_resume,
832 #endif
833 };
834
835 static struct platform_device adb_pfdev = {
836         .name = "adb",
837 };
838
839 static int __init
840 adb_dummy_probe(struct platform_device *dev)
841 {
842         if (dev == &adb_pfdev)
843                 return 0;
844         return -ENODEV;
845 }
846
847 static void __init
848 adbdev_init(void)
849 {
850         if (register_chrdev(ADB_MAJOR, "adb", &adb_fops)) {
851                 printk(KERN_ERR "adb: unable to get major %d\n", ADB_MAJOR);
852                 return;
853         }
854
855         adb_dev_class = class_create(THIS_MODULE, "adb");
856         if (IS_ERR(adb_dev_class))
857                 return;
858         device_create(adb_dev_class, NULL, MKDEV(ADB_MAJOR, 0), "adb");
859
860         platform_device_register(&adb_pfdev);
861         platform_driver_probe(&adb_pfdrv, adb_dummy_probe);
862 }