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