blob: 23741cec45e3e43210fdbac7e11c6ecc9c4eb1d5 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/types.h>
20#include <linux/errno.h>
21#include <linux/kernel.h>
22#include <linux/slab.h>
23#include <linux/module.h>
24#include <linux/fs.h>
25#include <linux/mm.h>
26#include <linux/sched.h>
27#include <linux/smp_lock.h>
28#include <linux/adb.h>
29#include <linux/cuda.h>
30#include <linux/pmu.h>
31#include <linux/notifier.h>
32#include <linux/wait.h>
33#include <linux/init.h>
34#include <linux/delay.h>
35#include <linux/spinlock.h>
36#include <linux/completion.h>
37#include <linux/device.h>
Paul Mackerrasc61dace2007-12-13 15:11:22 +110038#include <linux/kthread.h>
Geert Uytterhoevenfe2528b2008-02-03 16:49:09 +010039#include <linux/platform_device.h>
Daniel Walkeraf3ce512008-05-03 06:34:03 +100040#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
42#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#ifdef CONFIG_PPC
44#include <asm/prom.h>
Benjamin Herrenschmidte8222502006-03-28 23:15:54 +110045#include <asm/machdep.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046#endif
47
48
Linus Torvalds1da177e2005-04-16 15:20:36 -070049EXPORT_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
gregkh@suse.de56b22932005-03-23 10:01:41 -080080static struct class *adb_dev_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -070081
Adrian Bunk9b4a8dd2008-06-24 03:46:57 +100082static struct adb_driver *adb_controller;
Alan Sterne041c682006-03-27 01:16:30 -080083BLOCKING_NOTIFIER_HEAD(adb_client_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -070084static int adb_got_sleep;
85static int adb_inited;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086static DECLARE_MUTEX(adb_probe_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070087static int sleepy_trackpad;
88static int autopoll_devs;
89int __adb_probe_sync;
90
Linus Torvalds1da177e2005-04-16 15:20:36 -070091static int adb_scan_bus(void);
92static int do_adb_reset_bus(void);
93static void adbdev_init(void);
94static int try_handler_change(int, int);
95
96static struct adb_handler {
David Howells7d12e782006-10-05 14:55:46 +010097 void (*handler)(unsigned char *, int, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 int original_address;
99 int handler_id;
100 int busy;
101} adb_handler[16];
102
103/*
Daniel Walkeraf3ce512008-05-03 06:34:03 +1000104 * The adb_handler_mutex mutex protects all accesses to the original_address
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 * and handler_id fields of adb_handler[i] for all i, and changes to the
106 * handler field.
107 * Accesses to the handler field are protected by the adb_handler_lock
108 * rwlock. It is held across all calls to any handler, so that by the
109 * time adb_unregister returns, we know that the old handler isn't being
110 * called.
111 */
Daniel Walkeraf3ce512008-05-03 06:34:03 +1000112static DEFINE_MUTEX(adb_handler_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113static DEFINE_RWLOCK(adb_handler_lock);
114
115#if 0
116static void printADBreply(struct adb_request *req)
117{
118 int i;
119
120 printk("adb reply (%d)", req->reply_len);
121 for(i = 0; i < req->reply_len; i++)
122 printk(" %x", req->reply[i]);
123 printk("\n");
124
125}
126#endif
127
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128static int adb_scan_bus(void)
129{
130 int i, highFree=0, noMovement;
131 int devmask = 0;
132 struct adb_request req;
133
134 /* assumes adb_handler[] is all zeroes at this point */
135 for (i = 1; i < 16; i++) {
136 /* see if there is anything at address i */
137 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
138 (i << 4) | 0xf);
139 if (req.reply_len > 1)
140 /* one or more devices at this address */
141 adb_handler[i].original_address = i;
142 else if (i > highFree)
143 highFree = i;
144 }
145
146 /* Note we reset noMovement to 0 each time we move a device */
147 for (noMovement = 1; noMovement < 2 && highFree > 0; noMovement++) {
148 for (i = 1; i < 16; i++) {
149 if (adb_handler[i].original_address == 0)
150 continue;
151 /*
152 * Send a "talk register 3" command to address i
153 * to provoke a collision if there is more than
154 * one device at this address.
155 */
156 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
157 (i << 4) | 0xf);
158 /*
159 * Move the device(s) which didn't detect a
160 * collision to address `highFree'. Hopefully
161 * this only moves one device.
162 */
163 adb_request(&req, NULL, ADBREQ_SYNC, 3,
164 (i<< 4) | 0xb, (highFree | 0x60), 0xfe);
165 /*
166 * See if anybody actually moved. This is suggested
167 * by HW TechNote 01:
168 *
169 * http://developer.apple.com/technotes/hw/hw_01.html
170 */
171 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
172 (highFree << 4) | 0xf);
173 if (req.reply_len <= 1) continue;
174 /*
175 * Test whether there are any device(s) left
176 * at address i.
177 */
178 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
179 (i << 4) | 0xf);
180 if (req.reply_len > 1) {
181 /*
182 * There are still one or more devices
183 * left at address i. Register the one(s)
184 * we moved to `highFree', and find a new
185 * value for highFree.
186 */
187 adb_handler[highFree].original_address =
188 adb_handler[i].original_address;
189 while (highFree > 0 &&
190 adb_handler[highFree].original_address)
191 highFree--;
192 if (highFree <= 0)
193 break;
194
195 noMovement = 0;
196 }
197 else {
198 /*
199 * No devices left at address i; move the
200 * one(s) we moved to `highFree' back to i.
201 */
202 adb_request(&req, NULL, ADBREQ_SYNC, 3,
203 (highFree << 4) | 0xb,
204 (i | 0x60), 0xfe);
205 }
206 }
207 }
208
209 /* Now fill in the handler_id field of the adb_handler entries. */
210 printk(KERN_DEBUG "adb devices:");
211 for (i = 1; i < 16; i++) {
212 if (adb_handler[i].original_address == 0)
213 continue;
214 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
215 (i << 4) | 0xf);
216 adb_handler[i].handler_id = req.reply[2];
217 printk(" [%d]: %d %x", i, adb_handler[i].original_address,
218 adb_handler[i].handler_id);
219 devmask |= 1 << i;
220 }
221 printk("\n");
222 return devmask;
223}
224
225/*
226 * This kernel task handles ADB probing. It dies once probing is
227 * completed.
228 */
229static int
230adb_probe_task(void *x)
231{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 printk(KERN_INFO "adb: starting probe task...\n");
233 do_adb_reset_bus();
234 printk(KERN_INFO "adb: finished probe task...\n");
Oleg Nesterov1b6dd9b2007-07-15 23:41:29 -0700235
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 up(&adb_probe_mutex);
Oleg Nesterov1b6dd9b2007-07-15 23:41:29 -0700237
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 return 0;
239}
240
241static void
Al Viro3e577a82006-12-06 18:41:45 +0000242__adb_probe_task(struct work_struct *bullshit)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243{
Paul Mackerrasc61dace2007-12-13 15:11:22 +1100244 kthread_run(adb_probe_task, NULL, "kadbprobe");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245}
246
Al Viro3e577a82006-12-06 18:41:45 +0000247static DECLARE_WORK(adb_reset_work, __adb_probe_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248
249int
250adb_reset_bus(void)
251{
252 if (__adb_probe_sync) {
253 do_adb_reset_bus();
254 return 0;
255 }
256
257 down(&adb_probe_mutex);
258 schedule_work(&adb_reset_work);
259 return 0;
260}
261
Johannes Bergc9f6d3d2007-12-12 01:21:25 +1100262#ifdef CONFIG_PM
263/*
264 * notify clients before sleep
265 */
266static int adb_suspend(struct platform_device *dev, pm_message_t state)
267{
268 adb_got_sleep = 1;
269 /* We need to get a lock on the probe thread */
270 down(&adb_probe_mutex);
271 /* Stop autopoll */
272 if (adb_controller->autopoll)
273 adb_controller->autopoll(0);
274 blocking_notifier_call_chain(&adb_client_list, ADB_MSG_POWERDOWN, NULL);
275
276 return 0;
277}
278
279/*
280 * reset bus after sleep
281 */
282static int adb_resume(struct platform_device *dev)
283{
284 adb_got_sleep = 0;
285 up(&adb_probe_mutex);
286 adb_reset_bus();
287
288 return 0;
289}
290#endif /* CONFIG_PM */
291
Adrian Bunk9b4a8dd2008-06-24 03:46:57 +1000292static int __init adb_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293{
294 struct adb_driver *driver;
295 int i;
296
297#ifdef CONFIG_PPC32
Benjamin Herrenschmidte8222502006-03-28 23:15:54 +1100298 if (!machine_is(chrp) && !machine_is(powermac))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 return 0;
300#endif
301#ifdef CONFIG_MAC
302 if (!MACH_IS_MAC)
303 return 0;
304#endif
305
306 /* xmon may do early-init */
307 if (adb_inited)
308 return 0;
309 adb_inited = 1;
310
311 adb_controller = NULL;
312
313 i = 0;
314 while ((driver = adb_driver_list[i++]) != NULL) {
315 if (!driver->probe()) {
316 adb_controller = driver;
317 break;
318 }
319 }
320 if ((adb_controller == NULL) || adb_controller->init()) {
321 printk(KERN_WARNING "Warning: no ADB interface detected\n");
322 adb_controller = NULL;
323 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324#ifdef CONFIG_PPC
325 if (machine_is_compatible("AAPL,PowerBook1998") ||
326 machine_is_compatible("PowerBook1,1"))
327 sleepy_trackpad = 1;
328#endif /* CONFIG_PPC */
Johannes Bergc9f6d3d2007-12-12 01:21:25 +1100329
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 adbdev_init();
331 adb_reset_bus();
332 }
333 return 0;
334}
335
Robert P. J. Dayfaa5b9d2008-05-15 09:12:53 +1000336device_initcall(adb_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338static int
339do_adb_reset_bus(void)
340{
Johannes Berg70b52b32007-03-19 11:53:55 +0100341 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342
343 if (adb_controller == NULL)
344 return -ENXIO;
345
346 if (adb_controller->autopoll)
347 adb_controller->autopoll(0);
348
Johannes Berg70b52b32007-03-19 11:53:55 +0100349 blocking_notifier_call_chain(&adb_client_list,
350 ADB_MSG_PRE_RESET, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351
352 if (sleepy_trackpad) {
353 /* Let the trackpad settle down */
Paul Mackerrasc61dace2007-12-13 15:11:22 +1100354 msleep(500);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 }
356
Daniel Walkeraf3ce512008-05-03 06:34:03 +1000357 mutex_lock(&adb_handler_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 write_lock_irq(&adb_handler_lock);
359 memset(adb_handler, 0, sizeof(adb_handler));
360 write_unlock_irq(&adb_handler_lock);
361
362 /* That one is still a bit synchronous, oh well... */
363 if (adb_controller->reset_bus)
364 ret = adb_controller->reset_bus();
365 else
366 ret = 0;
367
368 if (sleepy_trackpad) {
369 /* Let the trackpad settle down */
Paul Mackerrasc61dace2007-12-13 15:11:22 +1100370 msleep(1500);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 }
372
373 if (!ret) {
374 autopoll_devs = adb_scan_bus();
375 if (adb_controller->autopoll)
376 adb_controller->autopoll(autopoll_devs);
377 }
Daniel Walkeraf3ce512008-05-03 06:34:03 +1000378 mutex_unlock(&adb_handler_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379
Johannes Berg70b52b32007-03-19 11:53:55 +0100380 blocking_notifier_call_chain(&adb_client_list,
381 ADB_MSG_POST_RESET, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382
383 return ret;
384}
385
386void
387adb_poll(void)
388{
389 if ((adb_controller == NULL)||(adb_controller->poll == NULL))
390 return;
391 adb_controller->poll();
392}
393
Paul Mackerrasc61dace2007-12-13 15:11:22 +1100394static void adb_sync_req_done(struct adb_request *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395{
Paul Mackerrasc61dace2007-12-13 15:11:22 +1100396 struct completion *comp = req->arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397
Paul Mackerrasc61dace2007-12-13 15:11:22 +1100398 complete(comp);
399}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400
401int
402adb_request(struct adb_request *req, void (*done)(struct adb_request *),
403 int flags, int nbytes, ...)
404{
405 va_list list;
Paul Mackerrasc61dace2007-12-13 15:11:22 +1100406 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 int rc;
Paul Mackerrasc61dace2007-12-13 15:11:22 +1100408 struct completion comp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409
410 if ((adb_controller == NULL) || (adb_controller->send_request == NULL))
411 return -ENXIO;
412 if (nbytes < 1)
413 return -EINVAL;
Paul Mackerrasc61dace2007-12-13 15:11:22 +1100414
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 req->nbytes = nbytes+1;
416 req->done = done;
417 req->reply_expected = flags & ADBREQ_REPLY;
418 req->data[0] = ADB_PACKET;
419 va_start(list, nbytes);
420 for (i = 0; i < nbytes; ++i)
421 req->data[i+1] = va_arg(list, int);
422 va_end(list);
423
424 if (flags & ADBREQ_NOSEND)
425 return 0;
426
Paul Mackerrasc61dace2007-12-13 15:11:22 +1100427 /* Synchronous requests block using an on-stack completion */
428 if (flags & ADBREQ_SYNC) {
429 WARN_ON(done);
430 req->done = adb_sync_req_done;
431 req->arg = &comp;
432 init_completion(&comp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 }
434
Paul Mackerrasc61dace2007-12-13 15:11:22 +1100435 rc = adb_controller->send_request(req, 0);
436
437 if ((flags & ADBREQ_SYNC) && !rc && !req->complete)
438 wait_for_completion(&comp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439
440 return rc;
441}
442
443 /* Ultimately this should return the number of devices with
444 the given default id.
445 And it does it now ! Note: changed behaviour: This function
446 will now register if default_id _and_ handler_id both match
447 but handler_id can be left to 0 to match with default_id only.
448 When handler_id is set, this function will try to adjust
449 the handler_id id it doesn't match. */
450int
451adb_register(int default_id, int handler_id, struct adb_ids *ids,
David Howells7d12e782006-10-05 14:55:46 +0100452 void (*handler)(unsigned char *, int, int))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453{
454 int i;
455
Daniel Walkeraf3ce512008-05-03 06:34:03 +1000456 mutex_lock(&adb_handler_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 ids->nids = 0;
458 for (i = 1; i < 16; i++) {
459 if ((adb_handler[i].original_address == default_id) &&
460 (!handler_id || (handler_id == adb_handler[i].handler_id) ||
461 try_handler_change(i, handler_id))) {
462 if (adb_handler[i].handler != 0) {
463 printk(KERN_ERR
464 "Two handlers for ADB device %d\n",
465 default_id);
466 continue;
467 }
468 write_lock_irq(&adb_handler_lock);
469 adb_handler[i].handler = handler;
470 write_unlock_irq(&adb_handler_lock);
471 ids->id[ids->nids++] = i;
472 }
473 }
Daniel Walkeraf3ce512008-05-03 06:34:03 +1000474 mutex_unlock(&adb_handler_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 return ids->nids;
476}
477
478int
479adb_unregister(int index)
480{
481 int ret = -ENODEV;
482
Daniel Walkeraf3ce512008-05-03 06:34:03 +1000483 mutex_lock(&adb_handler_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 write_lock_irq(&adb_handler_lock);
485 if (adb_handler[index].handler) {
486 while(adb_handler[index].busy) {
487 write_unlock_irq(&adb_handler_lock);
488 yield();
489 write_lock_irq(&adb_handler_lock);
490 }
491 ret = 0;
492 adb_handler[index].handler = NULL;
493 }
494 write_unlock_irq(&adb_handler_lock);
Daniel Walkeraf3ce512008-05-03 06:34:03 +1000495 mutex_unlock(&adb_handler_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 return ret;
497}
498
499void
David Howells7d12e782006-10-05 14:55:46 +0100500adb_input(unsigned char *buf, int nb, int autopoll)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501{
502 int i, id;
503 static int dump_adb_input = 0;
504 unsigned long flags;
505
David Howells7d12e782006-10-05 14:55:46 +0100506 void (*handler)(unsigned char *, int, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507
508 /* We skip keystrokes and mouse moves when the sleep process
509 * has been started. We stop autopoll, but this is another security
510 */
511 if (adb_got_sleep)
512 return;
513
514 id = buf[0] >> 4;
515 if (dump_adb_input) {
516 printk(KERN_INFO "adb packet: ");
517 for (i = 0; i < nb; ++i)
518 printk(" %x", buf[i]);
519 printk(", id = %d\n", id);
520 }
521 write_lock_irqsave(&adb_handler_lock, flags);
522 handler = adb_handler[id].handler;
523 if (handler != NULL)
524 adb_handler[id].busy = 1;
525 write_unlock_irqrestore(&adb_handler_lock, flags);
526 if (handler != NULL) {
David Howells7d12e782006-10-05 14:55:46 +0100527 (*handler)(buf, nb, autopoll);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 wmb();
529 adb_handler[id].busy = 0;
530 }
531
532}
533
534/* Try to change handler to new_id. Will return 1 if successful. */
535static int try_handler_change(int address, int new_id)
536{
537 struct adb_request req;
538
539 if (adb_handler[address].handler_id == new_id)
540 return 1;
541 adb_request(&req, NULL, ADBREQ_SYNC, 3,
542 ADB_WRITEREG(address, 3), address | 0x20, new_id);
543 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
544 ADB_READREG(address, 3));
545 if (req.reply_len < 2)
546 return 0;
547 if (req.reply[2] != new_id)
548 return 0;
549 adb_handler[address].handler_id = req.reply[2];
550
551 return 1;
552}
553
554int
555adb_try_handler_change(int address, int new_id)
556{
557 int ret;
558
Daniel Walkeraf3ce512008-05-03 06:34:03 +1000559 mutex_lock(&adb_handler_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 ret = try_handler_change(address, new_id);
Daniel Walkeraf3ce512008-05-03 06:34:03 +1000561 mutex_unlock(&adb_handler_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 return ret;
563}
564
565int
566adb_get_infos(int address, int *original_address, int *handler_id)
567{
Daniel Walkeraf3ce512008-05-03 06:34:03 +1000568 mutex_lock(&adb_handler_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 *original_address = adb_handler[address].original_address;
570 *handler_id = adb_handler[address].handler_id;
Daniel Walkeraf3ce512008-05-03 06:34:03 +1000571 mutex_unlock(&adb_handler_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572
573 return (*original_address != 0);
574}
575
576
577/*
578 * /dev/adb device driver.
579 */
580
581#define ADB_MAJOR 56 /* major number for /dev/adb */
582
583struct adbdev_state {
584 spinlock_t lock;
585 atomic_t n_pending;
586 struct adb_request *completed;
587 wait_queue_head_t wait_queue;
588 int inuse;
589};
590
591static void adb_write_done(struct adb_request *req)
592{
593 struct adbdev_state *state = (struct adbdev_state *) req->arg;
594 unsigned long flags;
595
596 if (!req->complete) {
597 req->reply_len = 0;
598 req->complete = 1;
599 }
600 spin_lock_irqsave(&state->lock, flags);
601 atomic_dec(&state->n_pending);
602 if (!state->inuse) {
603 kfree(req);
604 if (atomic_read(&state->n_pending) == 0) {
605 spin_unlock_irqrestore(&state->lock, flags);
606 kfree(state);
607 return;
608 }
609 } else {
610 struct adb_request **ap = &state->completed;
611 while (*ap != NULL)
612 ap = &(*ap)->next;
613 req->next = NULL;
614 *ap = req;
615 wake_up_interruptible(&state->wait_queue);
616 }
617 spin_unlock_irqrestore(&state->lock, flags);
618}
619
620static int
621do_adb_query(struct adb_request *req)
622{
623 int ret = -EINVAL;
624
625 switch(req->data[1])
626 {
627 case ADB_QUERY_GETDEVINFO:
628 if (req->nbytes < 3)
629 break;
Daniel Walkeraf3ce512008-05-03 06:34:03 +1000630 mutex_lock(&adb_handler_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 req->reply[0] = adb_handler[req->data[2]].original_address;
632 req->reply[1] = adb_handler[req->data[2]].handler_id;
Daniel Walkeraf3ce512008-05-03 06:34:03 +1000633 mutex_unlock(&adb_handler_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 req->complete = 1;
635 req->reply_len = 2;
636 adb_write_done(req);
637 ret = 0;
638 break;
639 }
640 return ret;
641}
642
643static int adb_open(struct inode *inode, struct file *file)
644{
645 struct adbdev_state *state;
Jonathan Corbet26ce4f02008-05-16 14:19:56 -0600646 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647
Jonathan Corbet26ce4f02008-05-16 14:19:56 -0600648 lock_kernel();
649 if (iminor(inode) > 0 || adb_controller == NULL) {
650 ret = -ENXIO;
651 goto out;
652 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 state = kmalloc(sizeof(struct adbdev_state), GFP_KERNEL);
Jonathan Corbet26ce4f02008-05-16 14:19:56 -0600654 if (state == 0) {
655 ret = -ENOMEM;
656 goto out;
657 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 file->private_data = state;
659 spin_lock_init(&state->lock);
660 atomic_set(&state->n_pending, 0);
661 state->completed = NULL;
662 init_waitqueue_head(&state->wait_queue);
663 state->inuse = 1;
664
Jonathan Corbet26ce4f02008-05-16 14:19:56 -0600665out:
666 unlock_kernel();
667 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668}
669
670static int adb_release(struct inode *inode, struct file *file)
671{
672 struct adbdev_state *state = file->private_data;
673 unsigned long flags;
674
675 lock_kernel();
676 if (state) {
677 file->private_data = NULL;
678 spin_lock_irqsave(&state->lock, flags);
679 if (atomic_read(&state->n_pending) == 0
680 && state->completed == NULL) {
681 spin_unlock_irqrestore(&state->lock, flags);
682 kfree(state);
683 } else {
684 state->inuse = 0;
685 spin_unlock_irqrestore(&state->lock, flags);
686 }
687 }
688 unlock_kernel();
689 return 0;
690}
691
692static ssize_t adb_read(struct file *file, char __user *buf,
693 size_t count, loff_t *ppos)
694{
695 int ret = 0;
696 struct adbdev_state *state = file->private_data;
697 struct adb_request *req;
698 wait_queue_t wait = __WAITQUEUE_INITIALIZER(wait,current);
699 unsigned long flags;
700
701 if (count < 2)
702 return -EINVAL;
703 if (count > sizeof(req->reply))
704 count = sizeof(req->reply);
705 if (!access_ok(VERIFY_WRITE, buf, count))
706 return -EFAULT;
707
708 req = NULL;
709 spin_lock_irqsave(&state->lock, flags);
710 add_wait_queue(&state->wait_queue, &wait);
711 current->state = TASK_INTERRUPTIBLE;
712
713 for (;;) {
714 req = state->completed;
715 if (req != NULL)
716 state->completed = req->next;
717 else if (atomic_read(&state->n_pending) == 0)
718 ret = -EIO;
719 if (req != NULL || ret != 0)
720 break;
721
722 if (file->f_flags & O_NONBLOCK) {
723 ret = -EAGAIN;
724 break;
725 }
726 if (signal_pending(current)) {
727 ret = -ERESTARTSYS;
728 break;
729 }
730 spin_unlock_irqrestore(&state->lock, flags);
731 schedule();
732 spin_lock_irqsave(&state->lock, flags);
733 }
734
735 current->state = TASK_RUNNING;
736 remove_wait_queue(&state->wait_queue, &wait);
737 spin_unlock_irqrestore(&state->lock, flags);
738
739 if (ret)
740 return ret;
741
742 ret = req->reply_len;
743 if (ret > count)
744 ret = count;
745 if (ret > 0 && copy_to_user(buf, req->reply, ret))
746 ret = -EFAULT;
747
748 kfree(req);
749 return ret;
750}
751
752static ssize_t adb_write(struct file *file, const char __user *buf,
753 size_t count, loff_t *ppos)
754{
755 int ret/*, i*/;
756 struct adbdev_state *state = file->private_data;
757 struct adb_request *req;
758
759 if (count < 2 || count > sizeof(req->data))
760 return -EINVAL;
761 if (adb_controller == NULL)
762 return -ENXIO;
763 if (!access_ok(VERIFY_READ, buf, count))
764 return -EFAULT;
765
Robert P. J. Day5cbded52006-12-13 00:35:56 -0800766 req = kmalloc(sizeof(struct adb_request),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 GFP_KERNEL);
768 if (req == NULL)
769 return -ENOMEM;
770
771 req->nbytes = count;
772 req->done = adb_write_done;
773 req->arg = (void *) state;
774 req->complete = 0;
775
776 ret = -EFAULT;
777 if (copy_from_user(req->data, buf, count))
778 goto out;
779
780 atomic_inc(&state->n_pending);
781
782 /* If a probe is in progress or we are sleeping, wait for it to complete */
783 down(&adb_probe_mutex);
784
785 /* Queries are special requests sent to the ADB driver itself */
786 if (req->data[0] == ADB_QUERY) {
787 if (count > 1)
788 ret = do_adb_query(req);
789 else
790 ret = -EINVAL;
791 up(&adb_probe_mutex);
792 }
793 /* Special case for ADB_BUSRESET request, all others are sent to
794 the controller */
795 else if ((req->data[0] == ADB_PACKET)&&(count > 1)
796 &&(req->data[1] == ADB_BUSRESET)) {
797 ret = do_adb_reset_bus();
798 up(&adb_probe_mutex);
799 atomic_dec(&state->n_pending);
800 if (ret == 0)
801 ret = count;
802 goto out;
803 } else {
804 req->reply_expected = ((req->data[1] & 0xc) == 0xc);
805 if (adb_controller && adb_controller->send_request)
806 ret = adb_controller->send_request(req, 0);
807 else
808 ret = -ENXIO;
809 up(&adb_probe_mutex);
810 }
811
812 if (ret != 0) {
813 atomic_dec(&state->n_pending);
814 goto out;
815 }
816 return count;
817
818out:
819 kfree(req);
820 return ret;
821}
822
Arjan van de Venfa027c22007-02-12 00:55:33 -0800823static const struct file_operations adb_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 .owner = THIS_MODULE,
825 .llseek = no_llseek,
826 .read = adb_read,
827 .write = adb_write,
828 .open = adb_open,
829 .release = adb_release,
830};
831
Johannes Bergc9f6d3d2007-12-12 01:21:25 +1100832static struct platform_driver adb_pfdrv = {
833 .driver = {
834 .name = "adb",
835 },
836#ifdef CONFIG_PM
837 .suspend = adb_suspend,
838 .resume = adb_resume,
839#endif
840};
841
842static struct platform_device adb_pfdev = {
843 .name = "adb",
844};
845
846static int __init
847adb_dummy_probe(struct platform_device *dev)
848{
849 if (dev == &adb_pfdev)
850 return 0;
851 return -ENODEV;
852}
853
854static void __init
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855adbdev_init(void)
856{
857 if (register_chrdev(ADB_MAJOR, "adb", &adb_fops)) {
858 printk(KERN_ERR "adb: unable to get major %d\n", ADB_MAJOR);
859 return;
860 }
861
gregkh@suse.de56b22932005-03-23 10:01:41 -0800862 adb_dev_class = class_create(THIS_MODULE, "adb");
863 if (IS_ERR(adb_dev_class))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 return;
Greg Kroah-Hartmana9b12612008-07-21 20:03:34 -0700865 device_create(adb_dev_class, NULL, MKDEV(ADB_MAJOR, 0), NULL, "adb");
Johannes Bergc9f6d3d2007-12-12 01:21:25 +1100866
867 platform_device_register(&adb_pfdev);
868 platform_driver_probe(&adb_pfdrv, adb_dummy_probe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869}