diff options
Diffstat (limited to 'drivers/macintosh/adb.c')
-rw-r--r-- | drivers/macintosh/adb.c | 910 |
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 | |||
48 | EXPORT_SYMBOL(adb_controller); | ||
49 | EXPORT_SYMBOL(adb_client_list); | ||
50 | |||
51 | extern struct adb_driver via_macii_driver; | ||
52 | extern struct adb_driver via_maciisi_driver; | ||
53 | extern struct adb_driver via_cuda_driver; | ||
54 | extern struct adb_driver adb_iop_driver; | ||
55 | extern struct adb_driver via_pmu_driver; | ||
56 | extern struct adb_driver macio_adb_driver; | ||
57 | |||
58 | static 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 | |||
80 | static struct class_simple *adb_dev_class; | ||
81 | |||
82 | struct adb_driver *adb_controller; | ||
83 | struct notifier_block *adb_client_list = NULL; | ||
84 | static int adb_got_sleep; | ||
85 | static int adb_inited; | ||
86 | static pid_t adb_probe_task_pid; | ||
87 | static DECLARE_MUTEX(adb_probe_mutex); | ||
88 | static struct completion adb_probe_task_comp; | ||
89 | static int sleepy_trackpad; | ||
90 | static int autopoll_devs; | ||
91 | int __adb_probe_sync; | ||
92 | |||
93 | #ifdef CONFIG_PMAC_PBOOK | ||
94 | static int adb_notify_sleep(struct pmu_sleep_notifier *self, int when); | ||
95 | static struct pmu_sleep_notifier adb_sleep_notifier = { | ||
96 | adb_notify_sleep, | ||
97 | SLEEP_LEVEL_ADB, | ||
98 | }; | ||
99 | #endif | ||
100 | |||
101 | static int adb_scan_bus(void); | ||
102 | static int do_adb_reset_bus(void); | ||
103 | static void adbdev_init(void); | ||
104 | static int try_handler_change(int, int); | ||
105 | |||
106 | static 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 | */ | ||
122 | static DECLARE_MUTEX(adb_handler_sem); | ||
123 | static DEFINE_RWLOCK(adb_handler_lock); | ||
124 | |||
125 | #if 0 | ||
126 | static 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 | |||
139 | static __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 | |||
148 | static 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 | */ | ||
249 | static int | ||
250 | adb_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 | |||
270 | static void | ||
271 | __adb_probe_task(void *data) | ||
272 | { | ||
273 | adb_probe_task_pid = kernel_thread(adb_probe_task, NULL, SIGCHLD | CLONE_KERNEL); | ||
274 | } | ||
275 | |||
276 | static DECLARE_WORK(adb_reset_work, __adb_probe_task, NULL); | ||
277 | |||
278 | int | ||
279 | adb_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 | |||
291 | int __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 | */ | ||
344 | int | ||
345 | adb_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 | |||
383 | static int | ||
384 | do_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 | |||
436 | void | ||
437 | adb_poll(void) | ||
438 | { | ||
439 | if ((adb_controller == NULL)||(adb_controller->poll == NULL)) | ||
440 | return; | ||
441 | adb_controller->poll(); | ||
442 | } | ||
443 | |||
444 | static void | ||
445 | adb_probe_wakeup(struct adb_request *req) | ||
446 | { | ||
447 | complete(&adb_probe_task_comp); | ||
448 | } | ||
449 | |||
450 | /* Static request used during probe */ | ||
451 | static struct adb_request adb_sreq; | ||
452 | static unsigned long adb_sreq_lock; // Use semaphore ! */ | ||
453 | |||
454 | int | ||
455 | adb_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); | ||
507 | bail: | ||
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. */ | ||
521 | int | ||
522 | adb_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 | |||
549 | int | ||
550 | adb_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 | |||
570 | void | ||
571 | adb_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. */ | ||
606 | static 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 | |||
625 | int | ||
626 | adb_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 | |||
636 | int | ||
637 | adb_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 | |||
654 | struct 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 | |||
662 | static 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 | |||
691 | static int | ||
692 | do_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 | |||
714 | static 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 | |||
733 | static 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 | |||
755 | static 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 | |||
815 | static 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 | |||
881 | out: | ||
882 | kfree(req); | ||
883 | return ret; | ||
884 | } | ||
885 | |||
886 | static 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 | |||
895 | static void | ||
896 | adbdev_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 | } | ||