Release 4.7 drivers/macintosh/adb.c

/*
 * Device driver for the Apple Desktop Bus
 * and the /dev/adb device on macintoshes.
 *
 * Copyright (C) 1996 Paul Mackerras.
 *
 * Modified to declare controllers as structures, added
 * client notification of bus reset and handles PowerBook
 * sleep, by Benjamin Herrenschmidt.
 *
 * To do:
 *
 * - /sys/bus/adb to list the devices and infos
 * - more /dev/adb to allow userland to receive the
 *   flow of auto-polling datas from a given device.
 * - move bus probe to a kernel thread
 */

#include <linux/types.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/adb.h>
#include <linux/cuda.h>
#include <linux/pmu.h>
#include <linux/notifier.h>
#include <linux/wait.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/device.h>
#include <linux/kthread.h>
#include <linux/platform_device.h>
#include <linux/mutex.h>

#include <linux/uaccess.h>
#ifdef CONFIG_PPC
#include <asm/prom.h>
#include <asm/machdep.h>
#endif



EXPORT_SYMBOL(adb_client_list);

extern struct adb_driver via_macii_driver;
extern struct adb_driver via_maciisi_driver;
extern struct adb_driver via_cuda_driver;
extern struct adb_driver adb_iop_driver;
extern struct adb_driver via_pmu_driver;
extern struct adb_driver macio_adb_driver;

static DEFINE_MUTEX(adb_mutex);

static struct adb_driver *adb_driver_list[] = {
#ifdef CONFIG_ADB_MACII
	&via_macii_driver,
#endif
#ifdef CONFIG_ADB_MACIISI
	&via_maciisi_driver,
#endif
#ifdef CONFIG_ADB_CUDA
	&via_cuda_driver,
#endif
#ifdef CONFIG_ADB_IOP
	&adb_iop_driver,
#endif
#if defined(CONFIG_ADB_PMU) || defined(CONFIG_ADB_PMU68K)
	&via_pmu_driver,
#endif
#ifdef CONFIG_ADB_MACIO
	&macio_adb_driver,
#endif
	NULL
};


static struct class *adb_dev_class;


static struct adb_driver *adb_controller;

BLOCKING_NOTIFIER_HEAD(adb_client_list);

static int adb_got_sleep;

static int adb_inited;
static DEFINE_SEMAPHORE(adb_probe_mutex);

static int sleepy_trackpad;

static int autopoll_devs;

int __adb_probe_sync;

static int adb_scan_bus(void);
static int do_adb_reset_bus(void);
static void adbdev_init(void);
static int try_handler_change(int, int);


static struct adb_handler {
	
void (*handler)(unsigned char *, int, int);
	
int original_address;
	
int handler_id;
	
int busy;
} 
adb_handler[16];

/*
 * The adb_handler_mutex mutex protects all accesses to the original_address
 * and handler_id fields of adb_handler[i] for all i, and changes to the
 * handler field.
 * Accesses to the handler field are protected by the adb_handler_lock
 * rwlock.  It is held across all calls to any handler, so that by the
 * time adb_unregister returns, we know that the old handler isn't being
 * called.
 */
static DEFINE_MUTEX(adb_handler_mutex);
static DEFINE_RWLOCK(adb_handler_lock);

#if 0
static void printADBreply(struct adb_request *req)
{
        int i;

        printk("adb reply (%d)", req->reply_len);
        for(i = 0; i < req->reply_len; i++)
                printk(" %x", req->reply[i]);
        printk("\n");

}
#endif



static int adb_scan_bus(void)
{
	int i, highFree=0, noMovement;
	int devmask = 0;
	struct adb_request req;
	
	/* assumes adb_handler[] is all zeroes at this point */
	for (i = 1; i < 16; i++) {
		/* see if there is anything at address i */
		adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
                            (i << 4) | 0xf);
		if (req.reply_len > 1)
			/* one or more devices at this address */
			adb_handler[i].original_address = i;
		else if (i > highFree)
			highFree = i;
	}

	/* Note we reset noMovement to 0 each time we move a device */
	for (noMovement = 1; noMovement < 2 && highFree > 0; noMovement++) {
		for (i = 1; i < 16; i++) {
			if (adb_handler[i].original_address == 0)
				continue;
			/*
                         * Send a "talk register 3" command to address i
                         * to provoke a collision if there is more than
                         * one device at this address.
                         */
			adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
				    (i << 4) | 0xf);
			/*
                         * Move the device(s) which didn't detect a
                         * collision to address `highFree'.  Hopefully
                         * this only moves one device.
                         */
			adb_request(&req, NULL, ADBREQ_SYNC, 3,
				    (i<< 4) | 0xb, (highFree | 0x60), 0xfe);
			/*
                         * See if anybody actually moved. This is suggested
                         * by HW TechNote 01:
                         *
                         * http://developer.apple.com/technotes/hw/hw_01.html
                         */
			adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
				    (highFree << 4) | 0xf);
			if (req.reply_len <= 1) continue;
			/*
                         * Test whether there are any device(s) left
                         * at address i.
                         */
			adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
				    (i << 4) | 0xf);
			if (req.reply_len > 1) {
				/*
                                 * There are still one or more devices
                                 * left at address i.  Register the one(s)
                                 * we moved to `highFree', and find a new
                                 * value for highFree.
                                 */
				adb_handler[highFree].original_address =
					adb_handler[i].original_address;
				while (highFree > 0 &&
				       adb_handler[highFree].original_address)
					highFree--;
				if (highFree <= 0)
					break;

				noMovement = 0;
			} else {
				/*
                                 * No devices left at address i; move the
                                 * one(s) we moved to `highFree' back to i.
                                 */
				adb_request(&req, NULL, ADBREQ_SYNC, 3,
					    (highFree << 4) | 0xb,
					    (i | 0x60), 0xfe);
			}
		}	
	}

	/* Now fill in the handler_id field of the adb_handler entries. */
	printk(KERN_DEBUG "adb devices:");
	for (i = 1; i < 16; i++) {
		if (adb_handler[i].original_address == 0)
			continue;
		adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
			    (i << 4) | 0xf);
		adb_handler[i].handler_id = req.reply[2];
		printk(" [%d]: %d %x", i, adb_handler[i].original_address,
		       adb_handler[i].handler_id);
		devmask |= 1 << i;
	}
	printk("\n");
	return devmask;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
437
100.00%
3
100.00%
Total
437
100.00%
3
100.00%

/*
 * This kernel task handles ADB probing. It dies once probing is
 * completed.
 */

static int

adb_probe_task(void *x)
{
	printk(KERN_INFO "adb: starting probe task...\n");
	do_adb_reset_bus();
	printk(KERN_INFO "adb: finished probe task...\n");

	up(&adb_probe_mutex);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus torvalds
linus torvalds
32
94.12%
1
50.00%
paul mackerras
paul mackerras
2
5.88%
1
50.00%
Total
34
100.00%
2
100.00%


static void

__adb_probe_task(struct work_struct *bullshit)
{
	kthread_run(adb_probe_task, NULL, "kadbprobe");
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus torvalds
linus torvalds
15
75.00%
1
33.33%
al viro
al viro
3
15.00%
1
33.33%
paul mackerras
paul mackerras
2
10.00%
1
33.33%
Total
20
100.00%
3
100.00%

static DECLARE_WORK(adb_reset_work, __adb_probe_task);


int

adb_reset_bus(void)
{
	if (__adb_probe_sync) {
		do_adb_reset_bus();
		return 0;
	}

	down(&adb_probe_mutex);
	schedule_work(&adb_reset_work);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus torvalds
linus torvalds
30
88.24%
1
33.33%
paul mackerras
paul mackerras
4
11.76%
2
66.67%
Total
34
100.00%
3
100.00%

#ifdef CONFIG_PM
/*
 * notify clients before sleep
 */


static int __adb_suspend(struct platform_device *dev, pm_message_t state)
{
	adb_got_sleep = 1;
	/* We need to get a lock on the probe thread */
	down(&adb_probe_mutex);
	/* Stop autopoll */
	if (adb_controller->autopoll)
		adb_controller->autopoll(0);
	blocking_notifier_call_chain(&adb_client_list, ADB_MSG_POWERDOWN, NULL);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
johannes berg
johannes berg
51
98.08%
1
50.00%
shuah khan
shuah khan
1
1.92%
1
50.00%
Total
52
100.00%
2
100.00%



static int adb_suspend(struct device *dev)
{
	return __adb_suspend(to_platform_device(dev), PMSG_SUSPEND);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
shuah khan
shuah khan
22
100.00%
1
100.00%
Total
22
100.00%
1
100.00%



static int adb_freeze(struct device *dev)
{
	return __adb_suspend(to_platform_device(dev), PMSG_FREEZE);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
shuah khan
shuah khan
22
100.00%
1
100.00%
Total
22
100.00%
1
100.00%



static int adb_poweroff(struct device *dev)
{
	return __adb_suspend(to_platform_device(dev), PMSG_HIBERNATE);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
shuah khan
shuah khan
22
100.00%
1
100.00%
Total
22
100.00%
1
100.00%

/*
 * reset bus after sleep
 */


static int __adb_resume(struct platform_device *dev)
{
	adb_got_sleep = 0;
	up(&adb_probe_mutex);
	adb_reset_bus();

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
johannes berg
johannes berg
26
96.30%
1
50.00%
shuah khan
shuah khan
1
3.70%
1
50.00%
Total
27
100.00%
2
100.00%



static int adb_resume(struct device *dev)
{
	return __adb_resume(to_platform_device(dev));
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
shuah khan
shuah khan
20
100.00%
1
100.00%
Total
20
100.00%
1
100.00%

#endif /* CONFIG_PM */



static int __init adb_init(void)
{
	struct adb_driver *driver;
	int i;

#ifdef CONFIG_PPC32
	if (!machine_is(chrp) && !machine_is(powermac))
		return 0;
#endif
#ifdef CONFIG_MAC
	if (!MACH_IS_MAC)
		return 0;
#endif

	/* xmon may do early-init */
	if (adb_inited)
		return 0;
	adb_inited = 1;
		
	adb_controller = NULL;

	i = 0;
	while ((driver = adb_driver_list[i++]) != NULL) {
		if (!driver->probe()) {
			adb_controller = driver;
			break;
		}
	}
	if (adb_controller != NULL && adb_controller->init &&
	    adb_controller->init())
		adb_controller = NULL;
	if (adb_controller == NULL) {
		printk(KERN_WARNING "Warning: no ADB interface detected\n");
	} else {
#ifdef CONFIG_PPC
		if (of_machine_is_compatible("AAPL,PowerBook1998") ||
			of_machine_is_compatible("PowerBook1,1"))
			sleepy_trackpad = 1;
#endif /* CONFIG_PPC */

		adbdev_init();
		adb_reset_bus();
	}
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
119
70.00%
5
41.67%
linus torvalds
linus torvalds
17
10.00%
1
8.33%
finn thain
finn thain
16
9.41%
1
8.33%
benjamin herrenschmidt
benjamin herrenschmidt
11
6.47%
2
16.67%
geert uytterhoeven
geert uytterhoeven
4
2.35%
1
8.33%
grant likely
grant likely
2
1.18%
1
8.33%
adrian bunk
adrian bunk
1
0.59%
1
8.33%
Total
170
100.00%
12
100.00%


device_initcall(adb_init);


static int

do_adb_reset_bus(void)
{
	int ret;
	
	if (adb_controller == NULL)
		return -ENXIO;
		
	if (adb_controller->autopoll)
		adb_controller->autopoll(0);

	blocking_notifier_call_chain(&adb_client_list,
		ADB_MSG_PRE_RESET, NULL);

	if (sleepy_trackpad) {
		/* Let the trackpad settle down */
		msleep(500);
	}

	mutex_lock(&adb_handler_mutex);
	write_lock_irq(&adb_handler_lock);
	memset(adb_handler, 0, sizeof(adb_handler));
	write_unlock_irq(&adb_handler_lock);

	/* That one is still a bit synchronous, oh well... */
	if (adb_controller->reset_bus)
		ret = adb_controller->reset_bus();
	else
		ret = 0;

	if (sleepy_trackpad) {
		/* Let the trackpad settle down */
		msleep(1500);
	}

	if (!ret) {
		autopoll_devs = adb_scan_bus();
		if (adb_controller->autopoll)
			adb_controller->autopoll(autopoll_devs);
	}
	mutex_unlock(&adb_handler_mutex);

	blocking_notifier_call_chain(&adb_client_list,
		ADB_MSG_POST_RESET, NULL);
	
	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
115
71.43%
5
45.45%
linus torvalds
linus torvalds
23
14.29%
1
9.09%
paul mackerras
paul mackerras
15
9.32%
2
18.18%
daniel walker
daniel walker
4
2.48%
1
9.09%
alan stern
alan stern
2
1.24%
1
9.09%
benjamin herrenschmidt
benjamin herrenschmidt
2
1.24%
1
9.09%
Total
161
100.00%
11
100.00%


void

adb_poll(void)
{
	if ((adb_controller == NULL)||(adb_controller->poll == NULL))
		return;
	adb_controller->poll();
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
29
100.00%
2
100.00%
Total
29
100.00%
2
100.00%


EXPORT_SYMBOL(adb_poll);



static void adb_sync_req_done(struct adb_request *req)
{
	struct completion *comp = req->arg;

	complete(comp);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus torvalds
linus torvalds
13
52.00%
1
33.33%
paul mackerras
paul mackerras
12
48.00%
2
66.67%
Total
25
100.00%
3
100.00%


int

adb_request(struct adb_request *req, void (*done)(struct adb_request *),
	    int flags, int nbytes, ...)
{
	va_list list;
	int i;
	int rc;
	struct completion comp;

	if ((adb_controller == NULL) || (adb_controller->send_request == NULL))
		return -ENXIO;
	if (nbytes < 1)
		return -EINVAL;

	req->nbytes = nbytes+1;
	req->done = done;
	req->reply_expected = flags & ADBREQ_REPLY;
	req->data[0] = ADB_PACKET;
	va_start(list, nbytes);
	for (i = 0; i < nbytes; ++i)
		req->data[i+1] = va_arg(list, int);
	va_end(list);

	if (flags & ADBREQ_NOSEND)
		return 0;

	/* Synchronous requests block using an on-stack completion */
	if (flags & ADBREQ_SYNC) {
		WARN_ON(done);
		req->done = adb_sync_req_done;
		req->arg = &comp;
		init_completion(&comp);
	}

	rc = adb_controller->send_request(req, 0);

	if ((flags & ADBREQ_SYNC) && !rc && !req->complete)
		wait_for_completion(&comp);

	return rc;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
155
69.82%
3
60.00%
paul mackerras
paul mackerras
34
15.32%
1
20.00%
linus torvalds
linus torvalds
33
14.86%
1
20.00%
Total
222
100.00%
5
100.00%


EXPORT_SYMBOL(adb_request);

 /* Ultimately this should return the number of devices with
    the given default id.
    And it does it now ! Note: changed behaviour: This function
    will now register if default_id _and_ handler_id both match
    but handler_id can be left to 0 to match with default_id only.
    When handler_id is set, this function will try to adjust
    the handler_id id it doesn't match. */

int

adb_register(int default_id, int handler_id, struct adb_ids *ids,
	     void (*handler)(unsigned char *, int, int))
{
	int i;

	mutex_lock(&adb_handler_mutex);
	ids->nids = 0;
	for (i = 1; i < 16; i++) {
		if ((adb_handler[i].original_address == default_id) &&
		    (!handler_id || (handler_id == adb_handler[i].handler_id) || 
		    try_handler_change(i, handler_id))) {
			if (adb_handler[i].handler != 0) {
				printk(KERN_ERR
				       "Two handlers for ADB device %d\n",
				       default_id);
				continue;
			}
			write_lock_irq(&adb_handler_lock);
			adb_handler[i].handler = handler;
			write_unlock_irq(&adb_handler_lock);
			ids->id[ids->nids++] = i;
		}
	}
	mutex_unlock(&adb_handler_mutex);
	return ids->nids;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
140
84.85%
3
60.00%
paul mackerras
paul mackerras
21
12.73%
1
20.00%
daniel walker
daniel walker
4
2.42%
1
20.00%
Total
165
100.00%
5
100.00%


EXPORT_SYMBOL(adb_register);


int

adb_unregister(int index)
{
	int ret = -ENODEV;

	mutex_lock(&adb_handler_mutex);
	write_lock_irq(&adb_handler_lock);
	if (adb_handler[index].handler) {
		while(adb_handler[index].busy) {
			write_unlock_irq(&adb_handler_lock);
			yield();
			write_lock_irq(&adb_handler_lock);
		}
		ret = 0;
		adb_handler[index].handler = NULL;
	}
	write_unlock_irq(&adb_handler_lock);
	mutex_unlock(&adb_handler_mutex);
	return ret;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
paul mackerras
paul mackerras
59
64.84%
2
40.00%
pre-git
pre-git
27
29.67%
1
20.00%
daniel walker
daniel walker
4
4.40%
1
20.00%
al viro
al viro
1
1.10%
1
20.00%
Total
91
100.00%
5
100.00%


EXPORT_SYMBOL(adb_unregister);


void

adb_input(unsigned char *buf, int nb, int autopoll)
{
	int i, id;
	static int dump_adb_input;
	unsigned long flags;
	
	void (*handler)(unsigned char *, int, int);

	/* We skip keystrokes and mouse moves when the sleep process
         * has been started. We stop autopoll, but this is another security
         */
	if (adb_got_sleep)
		return;
		
	id = buf[0] >> 4;
	if (dump_adb_input) {
		printk(KERN_INFO "adb packet: ");
		for (i = 0; i < nb; ++i)
			printk(" %x", buf[i]);
		printk(", id = %d\n", id);
	}
	write_lock_irqsave(&adb_handler_lock, flags);
	handler = adb_handler[id].handler;
	if (handler != NULL)
		adb_handler[id].busy = 1;
	write_unlock_irqrestore(&adb_handler_lock, flags);
	if (handler != NULL) {
		(*handler)(buf, nb, autopoll);
		wmb();
		adb_handler[id].busy = 0;
	}
		
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
95
54.91%
2
50.00%
paul mackerras
paul mackerras
78
45.09%
2
50.00%
Total
173
100.00%
4
100.00%

/* Try to change handler to new_id. Will return 1 if successful. */


static int try_handler_change(int address, int new_id)
{
	struct adb_request req;

	if (adb_handler[address].handler_id == new_id)
	    return 1;
	adb_request(&req, NULL, ADBREQ_SYNC, 3,
	    ADB_WRITEREG(address, 3), address | 0x20, new_id);
	adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
	    ADB_READREG(address, 3));
	if (req.reply_len < 2)
	    return 0;
	if (req.reply[2] != new_id)
	    return 0;
	adb_handler[address].handler_id = req.reply[2];

	return 1;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
116
98.31%
2
66.67%
paul mackerras
paul mackerras
2
1.69%
1
33.33%
Total
118
100.00%
3
100.00%


int

adb_try_handler_change(int address, int new_id)
{
	int ret;

	mutex_lock(&adb_handler_mutex);
	ret = try_handler_change(address, new_id);
	mutex_unlock(&adb_handler_mutex);
	return ret;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
paul mackerras
paul mackerras
33
86.84%
1
33.33%
daniel walker
daniel walker
4
10.53%
1
33.33%
pre-git
pre-git
1
2.63%
1
33.33%
Total
38
100.00%
3
100.00%


EXPORT_SYMBOL(adb_try_handler_change);


int

adb_get_infos(int address, int *original_address, int *handler_id)
{
	mutex_lock(&adb_handler_mutex);
	*original_address = adb_handler[address].original_address;
	*handler_id = adb_handler[address].handler_id;
	mutex_unlock(&adb_handler_mutex);

	return (*original_address != 0);
}


Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
43
76.79%
1
33.33%
paul mackerras
paul mackerras
9
16.07%
1
33.33%
daniel walker
daniel walker
4
7.14%
1
33.33%
Total
56
100.00%
3
100.00%

/*
 * /dev/adb device driver.
 */


#define ADB_MAJOR	56	
/* major number for /dev/adb */


struct adbdev_state {
	
spinlock_t	lock;
	
atomic_t	n_pending;
	
struct adb_request *completed;
  	
wait_queue_head_t wait_queue;
	
int		inuse;
};



static void adb_write_done(struct adb_request *req)
{
	struct adbdev_state *state = (struct adbdev_state *) req->arg;
	unsigned long flags;

	if (!req->complete) {
		req->reply_len = 0;
		req->complete = 1;
	}
	spin_lock_irqsave(&state->lock, flags);
	atomic_dec(&state->n_pending);
	if (!state->inuse) {
		kfree(req);
		if (atomic_read(&state->n_pending) == 0) {
			spin_unlock_irqrestore(&state->lock, flags);
			kfree(state);
			return;
		}
	} else {
		struct adb_request **ap = &state->completed;
		while (*ap != NULL)
			ap = &(*ap)->next;
		req->next = NULL;
		*ap = req;
		wake_up_interruptible(&state->wait_queue);
	}
	spin_unlock_irqrestore(&state->lock, flags);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
172
100.00%
4
100.00%
Total
172
100.00%
4
100.00%


static int

do_adb_query(struct adb_request *req)
{
	int	ret = -EINVAL;

	switch(req->data[1]) {
	case ADB_QUERY_GETDEVINFO:
		if (req->nbytes < 3)
			break;
		mutex_lock(&adb_handler_mutex);
		req->reply[0] = adb_handler[req->data[2]].original_address;
		req->reply[1] = adb_handler[req->data[2]].handler_id;
		mutex_unlock(&adb_handler_mutex);
		req->complete = 1;
		req->reply_len = 2;
		adb_write_done(req);
		ret = 0;
		break;
	}
	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
paul mackerras
paul mackerras
111
96.52%
1
50.00%
daniel walker
daniel walker
4
3.48%
1
50.00%
Total
115
100.00%
2
100.00%



static int adb_open(struct inode *inode, struct file *file)
{
	struct adbdev_state *state;
	int ret = 0;

	mutex_lock(&adb_mutex);
	if (iminor(inode) > 0 || adb_controller == NULL) {
		ret = -ENXIO;
		goto out;
	}
	state = kmalloc(sizeof(struct adbdev_state), GFP_KERNEL);
	if (state == 0) {
		ret = -ENOMEM;
		goto out;
	}
	file->private_data = state;
	spin_lock_init(&state->lock);
	atomic_set(&state->n_pending, 0);
	state->completed = NULL;
	init_waitqueue_head(&state->wait_queue);
	state->inuse = 1;

out:
	mutex_unlock(&adb_mutex);
	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
102
73.38%
5
62.50%
jonathan corbet
jonathan corbet
26
18.71%
1
12.50%
arnd bergmann
arnd bergmann
10
7.19%
1
12.50%
al viro
al viro
1
0.72%
1
12.50%
Total
139
100.00%
8
100.00%



static int adb_release(struct inode *inode, struct file *file)
{
	struct adbdev_state *state = file->private_data;
	unsigned long flags;

	mutex_lock(&adb_mutex);
	if (state) {
		file->private_data = NULL;
		spin_lock_irqsave(&state->lock, flags);
		if (atomic_read(&state->n_pending) == 0
		    && state->completed == NULL) {
			spin_unlock_irqrestore(&state->lock, flags);
			kfree(state);
		} else {
			state->inuse = 0;
			spin_unlock_irqrestore(&state->lock, flags);
		}
	}
	mutex_unlock(&adb_mutex);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
108
90.00%
2
50.00%
arnd bergmann
arnd bergmann
10
8.33%
1
25.00%
paul mackerras
paul mackerras
2
1.67%
1
25.00%
Total
120
100.00%
4
100.00%



static ssize_t adb_read(struct file *file, char __user *buf,
			size_t count, loff_t *ppos)
{
	int ret = 0;
	struct adbdev_state *state = file->private_data;
	struct adb_request *req;
	DECLARE_WAITQUEUE(wait, current);
	unsigned long flags;

	if (count < 2)
		return -EINVAL;
	if (count > sizeof(req->reply))
		count = sizeof(req->reply);
	if (!access_ok(VERIFY_WRITE, buf, count))
		return -EFAULT;

	req = NULL;
	spin_lock_irqsave(&state->lock, flags);
	add_wait_queue(&state->wait_queue, &wait);
	set_current_state(TASK_INTERRUPTIBLE);

	for (;;) {
		req = state->completed;
		if (req != NULL)
			state->completed = req->next;
		else if (atomic_read(&state->n_pending) == 0)
			ret = -EIO;
		if (req != NULL || ret != 0)
			break;
		
		if (file->f_flags & O_NONBLOCK) {
			ret = -EAGAIN;
			break;
		}
		if (signal_pending(current)) {
			ret = -ERESTARTSYS;
			break;
		}
		spin_unlock_irqrestore(&state->lock, flags);
		schedule();
		spin_lock_irqsave(&state->lock, flags);
	}

	set_current_state(TASK_RUNNING);
	remove_wait_queue(&state->wait_queue, &wait);
	spin_unlock_irqrestore(&state->lock, flags);
	
	if (ret)
		return ret;

	ret = req->reply_len;
	if (ret > count)
		ret = count;
	if (ret > 0 && copy_to_user(buf, req->reply, ret))
		ret = -EFAULT;

	kfree(req);
	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
261
82.08%
4
44.44%
paul mackerras
paul mackerras
41
12.89%
2
22.22%
jesper juhl
jesper juhl
8
2.52%
1
11.11%
ma jianpeng
ma jianpeng
6
1.89%
1
11.11%
robert p. j. day
robert p. j. day
2
0.63%
1
11.11%
Total
318
100.00%
9
100.00%



static ssize_t adb_write(struct file *file, const char __user *buf,
			 size_t count, loff_t *ppos)
{
	int ret/*, i*/;
	struct adbdev_state *state = file->private_data;
	struct adb_request *req;

	if (count < 2 || count > sizeof(req->data))
		return -EINVAL;
	if (adb_controller == NULL)
		return -ENXIO;
	if (!access_ok(VERIFY_READ, buf, count))
		return -EFAULT;

	req = kmalloc(sizeof(struct adb_request),
					     GFP_KERNEL);
	if (req == NULL)
		return -ENOMEM;

	req->nbytes = count;
	req->done = adb_write_done;
	req->arg = (void *) state;
	req->complete = 0;
	
	ret = -EFAULT;
	if (copy_from_user(req->data, buf, count))
		goto out;

	atomic_inc(&state->n_pending);

	/* If a probe is in progress or we are sleeping, wait for it to complete */
	down(&adb_probe_mutex);

	/* Queries are special requests sent to the ADB driver itself */
	if (req->data[0] == ADB_QUERY) {
		if (count > 1)
			ret = do_adb_query(req);
		else
			ret = -EINVAL;
		up(&adb_probe_mutex);
	}
	/* Special case for ADB_BUSRESET request, all others are sent to
           the controller */
	else if ((req->data[0] == ADB_PACKET) && (count > 1)
		&& (req->data[1] == ADB_BUSRESET)) {
		ret = do_adb_reset_bus();
		up(&adb_probe_mutex);
		atomic_dec(&state->n_pending);
		if (ret == 0)
			ret = count;
		goto out;
	} else {	
		req->reply_expected = ((req->data[1] & 0xc) == 0xc);
		if (adb_controller && adb_controller->send_request)
			ret = adb_controller->send_request(req, 0);
		else
			ret = -ENXIO;
		up(&adb_probe_mutex);
	}

	if (ret != 0) {
		atomic_dec(&state->n_pending);
		goto out;
	}
	return count;

out:
	kfree(req);
	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
277
76.10%
5
50.00%
paul mackerras
paul mackerras
80
21.98%
3
30.00%
jesper juhl
jesper juhl
6
1.65%
1
10.00%
linus torvalds
linus torvalds
1
0.27%
1
10.00%
Total
364
100.00%
10
100.00%


static const struct file_operations adb_fops = {
	.owner		= THIS_MODULE,
	.llseek		= no_llseek,
	.read		= adb_read,
	.write		= adb_write,
	.open		= adb_open,
	.release	= adb_release,
};

#ifdef CONFIG_PM

static const struct dev_pm_ops adb_dev_pm_ops = {
	.suspend = adb_suspend,
	.resume = adb_resume,
	/* Hibernate hooks */
	.freeze = adb_freeze,
	.thaw = adb_resume,
	.poweroff = adb_poweroff,
	.restore = adb_resume,
};
#endif


static struct platform_driver adb_pfdrv = {
	.driver = {
		.name = "adb",
#ifdef CONFIG_PM
		.pm = &adb_dev_pm_ops,
#endif
	},
};


static struct platform_device adb_pfdev = {
	.name = "adb",
};


static int __init

adb_dummy_probe(struct platform_device *dev)
{
	if (dev == &adb_pfdev)
		return 0;
	return -ENODEV;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
johannes berg
johannes berg
26
100.00%
1
100.00%
Total
26
100.00%
1
100.00%


static void __init

adbdev_init(void)
{
	if (register_chrdev(ADB_MAJOR, "adb", &adb_fops)) {
		printk(KERN_ERR "adb: unable to get major %d\n", ADB_MAJOR);
		return;
	}

	adb_dev_class = class_create(THIS_MODULE, "adb");
	if (IS_ERR(adb_dev_class))
		return;
	device_create(adb_dev_class, NULL, MKDEV(ADB_MAJOR, 0), NULL, "adb");

	platform_device_register(&adb_pfdev);
	platform_driver_probe(&adb_pfdrv, adb_dummy_probe);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
30
37.04%
3
25.00%
olaf hering
olaf hering
21
25.93%
1
8.33%
johannes berg
johannes berg
15
18.52%
1
8.33%
greg kroah-hartman
greg kroah-hartman
7
8.64%
5
41.67%
linus torvalds
linus torvalds
4
4.94%
1
8.33%
andrew morton
andrew morton
4
4.94%
1
8.33%
Total
81
100.00%
12
100.00%

Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
2482
65.59%
15
26.32%
paul mackerras
paul mackerras
547
14.46%
5
8.77%
linus torvalds
linus torvalds
196
5.18%
3
5.26%
johannes berg
johannes berg
163
4.31%
1
1.75%
shuah khan
shuah khan
136
3.59%
1
1.75%
olaf hering
olaf hering
35
0.92%
1
1.75%
daniel walker
daniel walker
28
0.74%
1
1.75%
jonathan corbet
jonathan corbet
26
0.69%
1
1.75%
arnd bergmann
arnd bergmann
26
0.69%
1
1.75%
anton blanchard
anton blanchard
25
0.66%
1
1.75%
benjamin herrenschmidt
benjamin herrenschmidt
20
0.53%
3
5.26%
geert uytterhoeven
geert uytterhoeven
17
0.45%
2
3.51%
finn thain
finn thain
16
0.42%
1
1.75%
jesper juhl
jesper juhl
14
0.37%
1
1.75%
art haas
art haas
10
0.26%
1
1.75%
greg kroah-hartman
greg kroah-hartman
8
0.21%
5
8.77%
alan stern
alan stern
6
0.16%
1
1.75%
ma jianpeng
ma jianpeng
6
0.16%
1
1.75%
thomas gleixner
thomas gleixner
5
0.13%
2
3.51%
al viro
al viro
5
0.13%
3
5.26%
andrew morton
andrew morton
4
0.11%
1
1.75%
robert p. j. day
robert p. j. day
3
0.08%
2
3.51%
adrian bunk
adrian bunk
2
0.05%
1
1.75%
grant likely
grant likely
2
0.05%
1
1.75%
brandon stewart
brandon stewart
1
0.03%
1
1.75%
arjan van de ven
arjan van de ven
1
0.03%
1
1.75%
Total
3784
100.00%
57
100.00%
  
Directory: drivers/macintosh

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.