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