Linux 2.6.17.7
[linux/fpc-iii.git] / drivers / macintosh / adb.c
blob259fd8973ce94c076064a2323a38b467d325d9c4
1 /*
2 * Device driver for the Apple Desktop Bus
3 * and the /dev/adb device on macintoshes.
5 * Copyright (C) 1996 Paul Mackerras.
7 * Modified to declare controllers as structures, added
8 * client notification of bus reset and handles PowerBook
9 * sleep, by Benjamin Herrenschmidt.
11 * To do:
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
19 #include <linux/config.h>
20 #include <linux/types.h>
21 #include <linux/errno.h>
22 #include <linux/kernel.h>
23 #include <linux/slab.h>
24 #include <linux/module.h>
25 #include <linux/fs.h>
26 #include <linux/mm.h>
27 #include <linux/sched.h>
28 #include <linux/smp_lock.h>
29 #include <linux/adb.h>
30 #include <linux/cuda.h>
31 #include <linux/pmu.h>
32 #include <linux/notifier.h>
33 #include <linux/wait.h>
34 #include <linux/init.h>
35 #include <linux/delay.h>
36 #include <linux/spinlock.h>
37 #include <linux/completion.h>
38 #include <linux/device.h>
39 #include <linux/devfs_fs_kernel.h>
41 #include <asm/uaccess.h>
42 #include <asm/semaphore.h>
43 #ifdef CONFIG_PPC
44 #include <asm/prom.h>
45 #include <asm/machdep.h>
46 #endif
49 EXPORT_SYMBOL(adb_controller);
50 EXPORT_SYMBOL(adb_client_list);
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;
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
81 static struct class *adb_dev_class;
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 pid_t adb_probe_task_pid;
88 static DECLARE_MUTEX(adb_probe_mutex);
89 static struct completion adb_probe_task_comp;
90 static int sleepy_trackpad;
91 static int autopoll_devs;
92 int __adb_probe_sync;
94 #ifdef CONFIG_PM
95 static int adb_notify_sleep(struct pmu_sleep_notifier *self, int when);
96 static struct pmu_sleep_notifier adb_sleep_notifier = {
97 adb_notify_sleep,
98 SLEEP_LEVEL_ADB,
100 #endif
102 static int adb_scan_bus(void);
103 static int do_adb_reset_bus(void);
104 static void adbdev_init(void);
105 static int try_handler_change(int, int);
107 static struct adb_handler {
108 void (*handler)(unsigned char *, int, struct pt_regs *, int);
109 int original_address;
110 int handler_id;
111 int busy;
112 } adb_handler[16];
115 * The adb_handler_sem mutex protects all accesses to the original_address
116 * and handler_id fields of adb_handler[i] for all i, and changes to the
117 * handler field.
118 * Accesses to the handler field are protected by the adb_handler_lock
119 * rwlock. It is held across all calls to any handler, so that by the
120 * time adb_unregister returns, we know that the old handler isn't being
121 * called.
123 static DECLARE_MUTEX(adb_handler_sem);
124 static DEFINE_RWLOCK(adb_handler_lock);
126 #if 0
127 static void printADBreply(struct adb_request *req)
129 int i;
131 printk("adb reply (%d)", req->reply_len);
132 for(i = 0; i < req->reply_len; i++)
133 printk(" %x", req->reply[i]);
134 printk("\n");
137 #endif
140 static __inline__ void adb_wait_ms(unsigned int ms)
142 if (current->pid && adb_probe_task_pid &&
143 adb_probe_task_pid == current->pid)
144 msleep(ms);
145 else
146 mdelay(ms);
149 static int adb_scan_bus(void)
151 int i, highFree=0, noMovement;
152 int devmask = 0;
153 struct adb_request req;
155 /* assumes adb_handler[] is all zeroes at this point */
156 for (i = 1; i < 16; i++) {
157 /* see if there is anything at address i */
158 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
159 (i << 4) | 0xf);
160 if (req.reply_len > 1)
161 /* one or more devices at this address */
162 adb_handler[i].original_address = i;
163 else if (i > highFree)
164 highFree = i;
167 /* Note we reset noMovement to 0 each time we move a device */
168 for (noMovement = 1; noMovement < 2 && highFree > 0; noMovement++) {
169 for (i = 1; i < 16; i++) {
170 if (adb_handler[i].original_address == 0)
171 continue;
173 * Send a "talk register 3" command to address i
174 * to provoke a collision if there is more than
175 * one device at this address.
177 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
178 (i << 4) | 0xf);
180 * Move the device(s) which didn't detect a
181 * collision to address `highFree'. Hopefully
182 * this only moves one device.
184 adb_request(&req, NULL, ADBREQ_SYNC, 3,
185 (i<< 4) | 0xb, (highFree | 0x60), 0xfe);
187 * See if anybody actually moved. This is suggested
188 * by HW TechNote 01:
190 * http://developer.apple.com/technotes/hw/hw_01.html
192 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
193 (highFree << 4) | 0xf);
194 if (req.reply_len <= 1) continue;
196 * Test whether there are any device(s) left
197 * at address i.
199 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
200 (i << 4) | 0xf);
201 if (req.reply_len > 1) {
203 * There are still one or more devices
204 * left at address i. Register the one(s)
205 * we moved to `highFree', and find a new
206 * value for highFree.
208 adb_handler[highFree].original_address =
209 adb_handler[i].original_address;
210 while (highFree > 0 &&
211 adb_handler[highFree].original_address)
212 highFree--;
213 if (highFree <= 0)
214 break;
216 noMovement = 0;
218 else {
220 * No devices left at address i; move the
221 * one(s) we moved to `highFree' back to i.
223 adb_request(&req, NULL, ADBREQ_SYNC, 3,
224 (highFree << 4) | 0xb,
225 (i | 0x60), 0xfe);
230 /* Now fill in the handler_id field of the adb_handler entries. */
231 printk(KERN_DEBUG "adb devices:");
232 for (i = 1; i < 16; i++) {
233 if (adb_handler[i].original_address == 0)
234 continue;
235 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
236 (i << 4) | 0xf);
237 adb_handler[i].handler_id = req.reply[2];
238 printk(" [%d]: %d %x", i, adb_handler[i].original_address,
239 adb_handler[i].handler_id);
240 devmask |= 1 << i;
242 printk("\n");
243 return devmask;
247 * This kernel task handles ADB probing. It dies once probing is
248 * completed.
250 static int
251 adb_probe_task(void *x)
253 sigset_t blocked;
255 strcpy(current->comm, "kadbprobe");
257 sigfillset(&blocked);
258 sigprocmask(SIG_BLOCK, &blocked, NULL);
259 flush_signals(current);
261 printk(KERN_INFO "adb: starting probe task...\n");
262 do_adb_reset_bus();
263 printk(KERN_INFO "adb: finished probe task...\n");
265 adb_probe_task_pid = 0;
266 up(&adb_probe_mutex);
268 return 0;
271 static void
272 __adb_probe_task(void *data)
274 adb_probe_task_pid = kernel_thread(adb_probe_task, NULL, SIGCHLD | CLONE_KERNEL);
277 static DECLARE_WORK(adb_reset_work, __adb_probe_task, NULL);
280 adb_reset_bus(void)
282 if (__adb_probe_sync) {
283 do_adb_reset_bus();
284 return 0;
287 down(&adb_probe_mutex);
288 schedule_work(&adb_reset_work);
289 return 0;
292 int __init adb_init(void)
294 struct adb_driver *driver;
295 int i;
297 #ifdef CONFIG_PPC32
298 if (!machine_is(chrp) && !machine_is(powermac))
299 return 0;
300 #endif
301 #ifdef CONFIG_MAC
302 if (!MACH_IS_MAC)
303 return 0;
304 #endif
306 /* xmon may do early-init */
307 if (adb_inited)
308 return 0;
309 adb_inited = 1;
311 adb_controller = NULL;
313 i = 0;
314 while ((driver = adb_driver_list[i++]) != NULL) {
315 if (!driver->probe()) {
316 adb_controller = driver;
317 break;
320 if ((adb_controller == NULL) || adb_controller->init()) {
321 printk(KERN_WARNING "Warning: no ADB interface detected\n");
322 adb_controller = NULL;
323 } else {
324 #ifdef CONFIG_PM
325 pmu_register_sleep_notifier(&adb_sleep_notifier);
326 #endif /* CONFIG_PM */
327 #ifdef CONFIG_PPC
328 if (machine_is_compatible("AAPL,PowerBook1998") ||
329 machine_is_compatible("PowerBook1,1"))
330 sleepy_trackpad = 1;
331 #endif /* CONFIG_PPC */
332 init_completion(&adb_probe_task_comp);
333 adbdev_init();
334 adb_reset_bus();
336 return 0;
339 __initcall(adb_init);
341 #ifdef CONFIG_PM
343 * notify clients before sleep and reset bus afterwards
346 adb_notify_sleep(struct pmu_sleep_notifier *self, int when)
348 int ret;
350 switch (when) {
351 case PBOOK_SLEEP_REQUEST:
352 adb_got_sleep = 1;
353 /* We need to get a lock on the probe thread */
354 down(&adb_probe_mutex);
355 /* Stop autopoll */
356 if (adb_controller->autopoll)
357 adb_controller->autopoll(0);
358 ret = blocking_notifier_call_chain(&adb_client_list,
359 ADB_MSG_POWERDOWN, NULL);
360 if (ret & NOTIFY_STOP_MASK) {
361 up(&adb_probe_mutex);
362 return PBOOK_SLEEP_REFUSE;
364 break;
365 case PBOOK_SLEEP_REJECT:
366 if (adb_got_sleep) {
367 adb_got_sleep = 0;
368 up(&adb_probe_mutex);
369 adb_reset_bus();
371 break;
373 case PBOOK_SLEEP_NOW:
374 break;
375 case PBOOK_WAKE:
376 adb_got_sleep = 0;
377 up(&adb_probe_mutex);
378 adb_reset_bus();
379 break;
381 return PBOOK_SLEEP_OK;
383 #endif /* CONFIG_PM */
385 static int
386 do_adb_reset_bus(void)
388 int ret, nret;
390 if (adb_controller == NULL)
391 return -ENXIO;
393 if (adb_controller->autopoll)
394 adb_controller->autopoll(0);
396 nret = blocking_notifier_call_chain(&adb_client_list,
397 ADB_MSG_PRE_RESET, NULL);
398 if (nret & NOTIFY_STOP_MASK) {
399 if (adb_controller->autopoll)
400 adb_controller->autopoll(autopoll_devs);
401 return -EBUSY;
404 if (sleepy_trackpad) {
405 /* Let the trackpad settle down */
406 adb_wait_ms(500);
409 down(&adb_handler_sem);
410 write_lock_irq(&adb_handler_lock);
411 memset(adb_handler, 0, sizeof(adb_handler));
412 write_unlock_irq(&adb_handler_lock);
414 /* That one is still a bit synchronous, oh well... */
415 if (adb_controller->reset_bus)
416 ret = adb_controller->reset_bus();
417 else
418 ret = 0;
420 if (sleepy_trackpad) {
421 /* Let the trackpad settle down */
422 adb_wait_ms(1500);
425 if (!ret) {
426 autopoll_devs = adb_scan_bus();
427 if (adb_controller->autopoll)
428 adb_controller->autopoll(autopoll_devs);
430 up(&adb_handler_sem);
432 nret = blocking_notifier_call_chain(&adb_client_list,
433 ADB_MSG_POST_RESET, NULL);
434 if (nret & NOTIFY_STOP_MASK)
435 return -EBUSY;
437 return ret;
440 void
441 adb_poll(void)
443 if ((adb_controller == NULL)||(adb_controller->poll == NULL))
444 return;
445 adb_controller->poll();
448 static void
449 adb_probe_wakeup(struct adb_request *req)
451 complete(&adb_probe_task_comp);
454 /* Static request used during probe */
455 static struct adb_request adb_sreq;
456 static unsigned long adb_sreq_lock; // Use semaphore ! */
459 adb_request(struct adb_request *req, void (*done)(struct adb_request *),
460 int flags, int nbytes, ...)
462 va_list list;
463 int i, use_sreq;
464 int rc;
466 if ((adb_controller == NULL) || (adb_controller->send_request == NULL))
467 return -ENXIO;
468 if (nbytes < 1)
469 return -EINVAL;
470 if (req == NULL && (flags & ADBREQ_NOSEND))
471 return -EINVAL;
473 if (req == NULL) {
474 if (test_and_set_bit(0,&adb_sreq_lock)) {
475 printk("adb.c: Warning: contention on static request !\n");
476 return -EPERM;
478 req = &adb_sreq;
479 flags |= ADBREQ_SYNC;
480 use_sreq = 1;
481 } else
482 use_sreq = 0;
483 req->nbytes = nbytes+1;
484 req->done = done;
485 req->reply_expected = flags & ADBREQ_REPLY;
486 req->data[0] = ADB_PACKET;
487 va_start(list, nbytes);
488 for (i = 0; i < nbytes; ++i)
489 req->data[i+1] = va_arg(list, int);
490 va_end(list);
492 if (flags & ADBREQ_NOSEND)
493 return 0;
495 /* Synchronous requests send from the probe thread cause it to
496 * block. Beware that the "done" callback will be overriden !
498 if ((flags & ADBREQ_SYNC) &&
499 (current->pid && adb_probe_task_pid &&
500 adb_probe_task_pid == current->pid)) {
501 req->done = adb_probe_wakeup;
502 rc = adb_controller->send_request(req, 0);
503 if (rc || req->complete)
504 goto bail;
505 wait_for_completion(&adb_probe_task_comp);
506 rc = 0;
507 goto bail;
510 rc = adb_controller->send_request(req, flags & ADBREQ_SYNC);
511 bail:
512 if (use_sreq)
513 clear_bit(0, &adb_sreq_lock);
515 return rc;
518 /* Ultimately this should return the number of devices with
519 the given default id.
520 And it does it now ! Note: changed behaviour: This function
521 will now register if default_id _and_ handler_id both match
522 but handler_id can be left to 0 to match with default_id only.
523 When handler_id is set, this function will try to adjust
524 the handler_id id it doesn't match. */
526 adb_register(int default_id, int handler_id, struct adb_ids *ids,
527 void (*handler)(unsigned char *, int, struct pt_regs *, int))
529 int i;
531 down(&adb_handler_sem);
532 ids->nids = 0;
533 for (i = 1; i < 16; i++) {
534 if ((adb_handler[i].original_address == default_id) &&
535 (!handler_id || (handler_id == adb_handler[i].handler_id) ||
536 try_handler_change(i, handler_id))) {
537 if (adb_handler[i].handler != 0) {
538 printk(KERN_ERR
539 "Two handlers for ADB device %d\n",
540 default_id);
541 continue;
543 write_lock_irq(&adb_handler_lock);
544 adb_handler[i].handler = handler;
545 write_unlock_irq(&adb_handler_lock);
546 ids->id[ids->nids++] = i;
549 up(&adb_handler_sem);
550 return ids->nids;
554 adb_unregister(int index)
556 int ret = -ENODEV;
558 down(&adb_handler_sem);
559 write_lock_irq(&adb_handler_lock);
560 if (adb_handler[index].handler) {
561 while(adb_handler[index].busy) {
562 write_unlock_irq(&adb_handler_lock);
563 yield();
564 write_lock_irq(&adb_handler_lock);
566 ret = 0;
567 adb_handler[index].handler = NULL;
569 write_unlock_irq(&adb_handler_lock);
570 up(&adb_handler_sem);
571 return ret;
574 void
575 adb_input(unsigned char *buf, int nb, struct pt_regs *regs, int autopoll)
577 int i, id;
578 static int dump_adb_input = 0;
579 unsigned long flags;
581 void (*handler)(unsigned char *, int, struct pt_regs *, int);
583 /* We skip keystrokes and mouse moves when the sleep process
584 * has been started. We stop autopoll, but this is another security
586 if (adb_got_sleep)
587 return;
589 id = buf[0] >> 4;
590 if (dump_adb_input) {
591 printk(KERN_INFO "adb packet: ");
592 for (i = 0; i < nb; ++i)
593 printk(" %x", buf[i]);
594 printk(", id = %d\n", id);
596 write_lock_irqsave(&adb_handler_lock, flags);
597 handler = adb_handler[id].handler;
598 if (handler != NULL)
599 adb_handler[id].busy = 1;
600 write_unlock_irqrestore(&adb_handler_lock, flags);
601 if (handler != NULL) {
602 (*handler)(buf, nb, regs, autopoll);
603 wmb();
604 adb_handler[id].busy = 0;
609 /* Try to change handler to new_id. Will return 1 if successful. */
610 static int try_handler_change(int address, int new_id)
612 struct adb_request req;
614 if (adb_handler[address].handler_id == new_id)
615 return 1;
616 adb_request(&req, NULL, ADBREQ_SYNC, 3,
617 ADB_WRITEREG(address, 3), address | 0x20, new_id);
618 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
619 ADB_READREG(address, 3));
620 if (req.reply_len < 2)
621 return 0;
622 if (req.reply[2] != new_id)
623 return 0;
624 adb_handler[address].handler_id = req.reply[2];
626 return 1;
630 adb_try_handler_change(int address, int new_id)
632 int ret;
634 down(&adb_handler_sem);
635 ret = try_handler_change(address, new_id);
636 up(&adb_handler_sem);
637 return ret;
641 adb_get_infos(int address, int *original_address, int *handler_id)
643 down(&adb_handler_sem);
644 *original_address = adb_handler[address].original_address;
645 *handler_id = adb_handler[address].handler_id;
646 up(&adb_handler_sem);
648 return (*original_address != 0);
653 * /dev/adb device driver.
656 #define ADB_MAJOR 56 /* major number for /dev/adb */
658 struct adbdev_state {
659 spinlock_t lock;
660 atomic_t n_pending;
661 struct adb_request *completed;
662 wait_queue_head_t wait_queue;
663 int inuse;
666 static void adb_write_done(struct adb_request *req)
668 struct adbdev_state *state = (struct adbdev_state *) req->arg;
669 unsigned long flags;
671 if (!req->complete) {
672 req->reply_len = 0;
673 req->complete = 1;
675 spin_lock_irqsave(&state->lock, flags);
676 atomic_dec(&state->n_pending);
677 if (!state->inuse) {
678 kfree(req);
679 if (atomic_read(&state->n_pending) == 0) {
680 spin_unlock_irqrestore(&state->lock, flags);
681 kfree(state);
682 return;
684 } else {
685 struct adb_request **ap = &state->completed;
686 while (*ap != NULL)
687 ap = &(*ap)->next;
688 req->next = NULL;
689 *ap = req;
690 wake_up_interruptible(&state->wait_queue);
692 spin_unlock_irqrestore(&state->lock, flags);
695 static int
696 do_adb_query(struct adb_request *req)
698 int ret = -EINVAL;
700 switch(req->data[1])
702 case ADB_QUERY_GETDEVINFO:
703 if (req->nbytes < 3)
704 break;
705 down(&adb_handler_sem);
706 req->reply[0] = adb_handler[req->data[2]].original_address;
707 req->reply[1] = adb_handler[req->data[2]].handler_id;
708 up(&adb_handler_sem);
709 req->complete = 1;
710 req->reply_len = 2;
711 adb_write_done(req);
712 ret = 0;
713 break;
715 return ret;
718 static int adb_open(struct inode *inode, struct file *file)
720 struct adbdev_state *state;
722 if (iminor(inode) > 0 || adb_controller == NULL)
723 return -ENXIO;
724 state = kmalloc(sizeof(struct adbdev_state), GFP_KERNEL);
725 if (state == 0)
726 return -ENOMEM;
727 file->private_data = state;
728 spin_lock_init(&state->lock);
729 atomic_set(&state->n_pending, 0);
730 state->completed = NULL;
731 init_waitqueue_head(&state->wait_queue);
732 state->inuse = 1;
734 return 0;
737 static int adb_release(struct inode *inode, struct file *file)
739 struct adbdev_state *state = file->private_data;
740 unsigned long flags;
742 lock_kernel();
743 if (state) {
744 file->private_data = NULL;
745 spin_lock_irqsave(&state->lock, flags);
746 if (atomic_read(&state->n_pending) == 0
747 && state->completed == NULL) {
748 spin_unlock_irqrestore(&state->lock, flags);
749 kfree(state);
750 } else {
751 state->inuse = 0;
752 spin_unlock_irqrestore(&state->lock, flags);
755 unlock_kernel();
756 return 0;
759 static ssize_t adb_read(struct file *file, char __user *buf,
760 size_t count, loff_t *ppos)
762 int ret = 0;
763 struct adbdev_state *state = file->private_data;
764 struct adb_request *req;
765 wait_queue_t wait = __WAITQUEUE_INITIALIZER(wait,current);
766 unsigned long flags;
768 if (count < 2)
769 return -EINVAL;
770 if (count > sizeof(req->reply))
771 count = sizeof(req->reply);
772 if (!access_ok(VERIFY_WRITE, buf, count))
773 return -EFAULT;
775 req = NULL;
776 spin_lock_irqsave(&state->lock, flags);
777 add_wait_queue(&state->wait_queue, &wait);
778 current->state = TASK_INTERRUPTIBLE;
780 for (;;) {
781 req = state->completed;
782 if (req != NULL)
783 state->completed = req->next;
784 else if (atomic_read(&state->n_pending) == 0)
785 ret = -EIO;
786 if (req != NULL || ret != 0)
787 break;
789 if (file->f_flags & O_NONBLOCK) {
790 ret = -EAGAIN;
791 break;
793 if (signal_pending(current)) {
794 ret = -ERESTARTSYS;
795 break;
797 spin_unlock_irqrestore(&state->lock, flags);
798 schedule();
799 spin_lock_irqsave(&state->lock, flags);
802 current->state = TASK_RUNNING;
803 remove_wait_queue(&state->wait_queue, &wait);
804 spin_unlock_irqrestore(&state->lock, flags);
806 if (ret)
807 return ret;
809 ret = req->reply_len;
810 if (ret > count)
811 ret = count;
812 if (ret > 0 && copy_to_user(buf, req->reply, ret))
813 ret = -EFAULT;
815 kfree(req);
816 return ret;
819 static ssize_t adb_write(struct file *file, const char __user *buf,
820 size_t count, loff_t *ppos)
822 int ret/*, i*/;
823 struct adbdev_state *state = file->private_data;
824 struct adb_request *req;
826 if (count < 2 || count > sizeof(req->data))
827 return -EINVAL;
828 if (adb_controller == NULL)
829 return -ENXIO;
830 if (!access_ok(VERIFY_READ, buf, count))
831 return -EFAULT;
833 req = (struct adb_request *) kmalloc(sizeof(struct adb_request),
834 GFP_KERNEL);
835 if (req == NULL)
836 return -ENOMEM;
838 req->nbytes = count;
839 req->done = adb_write_done;
840 req->arg = (void *) state;
841 req->complete = 0;
843 ret = -EFAULT;
844 if (copy_from_user(req->data, buf, count))
845 goto out;
847 atomic_inc(&state->n_pending);
849 /* If a probe is in progress or we are sleeping, wait for it to complete */
850 down(&adb_probe_mutex);
852 /* Queries are special requests sent to the ADB driver itself */
853 if (req->data[0] == ADB_QUERY) {
854 if (count > 1)
855 ret = do_adb_query(req);
856 else
857 ret = -EINVAL;
858 up(&adb_probe_mutex);
860 /* Special case for ADB_BUSRESET request, all others are sent to
861 the controller */
862 else if ((req->data[0] == ADB_PACKET)&&(count > 1)
863 &&(req->data[1] == ADB_BUSRESET)) {
864 ret = do_adb_reset_bus();
865 up(&adb_probe_mutex);
866 atomic_dec(&state->n_pending);
867 if (ret == 0)
868 ret = count;
869 goto out;
870 } else {
871 req->reply_expected = ((req->data[1] & 0xc) == 0xc);
872 if (adb_controller && adb_controller->send_request)
873 ret = adb_controller->send_request(req, 0);
874 else
875 ret = -ENXIO;
876 up(&adb_probe_mutex);
879 if (ret != 0) {
880 atomic_dec(&state->n_pending);
881 goto out;
883 return count;
885 out:
886 kfree(req);
887 return ret;
890 static struct file_operations adb_fops = {
891 .owner = THIS_MODULE,
892 .llseek = no_llseek,
893 .read = adb_read,
894 .write = adb_write,
895 .open = adb_open,
896 .release = adb_release,
899 static void
900 adbdev_init(void)
902 if (register_chrdev(ADB_MAJOR, "adb", &adb_fops)) {
903 printk(KERN_ERR "adb: unable to get major %d\n", ADB_MAJOR);
904 return;
907 devfs_mk_cdev(MKDEV(ADB_MAJOR, 0), S_IFCHR | S_IRUSR | S_IWUSR, "adb");
909 adb_dev_class = class_create(THIS_MODULE, "adb");
910 if (IS_ERR(adb_dev_class))
911 return;
912 class_device_create(adb_dev_class, NULL, MKDEV(ADB_MAJOR, 0), NULL, "adb");