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