[mirror_ubuntu-artful-kernel.git] / drivers / macintosh / macio-adb.c

/*
 * Driver for the ADB controller in the Mac I/O (Hydra) chip.
 */
#include <stdarg.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/sched.h>
#include <linux/spinlock.h>
#include <linux/interrupt.h>
#include <asm/prom.h>
#include <linux/adb.h>
#include <asm/io.h>
#include <asm/pgtable.h>
#include <asm/hydra.h>
#include <asm/irq.h>
#include <asm/system.h>
#include <linux/init.h>

struct preg {
	unsigned char r;
	char pad[15];
};

struct adb_regs {
	struct preg intr;
	struct preg data[9];
	struct preg intr_enb;
	struct preg dcount;
	struct preg error;
	struct preg ctrl;
	struct preg autopoll;
	struct preg active_hi;
	struct preg active_lo;
	struct preg test;
};

/* Bits in intr and intr_enb registers */
#define DFB	1		/* data from bus */
#define TAG	2		/* transfer access grant */

/* Bits in dcount register */
#define HMB	0x0f		/* how many bytes */
#define APD	0x10		/* auto-poll data */

/* Bits in error register */
#define NRE	1		/* no response error */
#define DLE	2		/* data lost error */

/* Bits in ctrl register */
#define TAR	1		/* transfer access request */
#define DTB	2		/* data to bus */
#define CRE	4		/* command response expected */
#define ADB_RST	8		/* ADB reset */

/* Bits in autopoll register */
#define APE	1		/* autopoll enable */

static volatile struct adb_regs __iomem *adb;
static struct adb_request *current_req, *last_req;
static DEFINE_SPINLOCK(macio_lock);

static int macio_probe(void);
static int macio_init(void);
static irqreturn_t macio_adb_interrupt(int irq, void *arg, struct pt_regs *regs);
static int macio_send_request(struct adb_request *req, int sync);
static int macio_adb_autopoll(int devs);
static void macio_adb_poll(void);
static int macio_adb_reset_bus(void);

struct adb_driver macio_adb_driver = {
	"MACIO",
	macio_probe,
	macio_init,
	macio_send_request,
	/*macio_write,*/
	macio_adb_autopoll,
	macio_adb_poll,
	macio_adb_reset_bus
};

int macio_probe(void)
{
	return find_compatible_devices("adb", "chrp,adb0")? 0: -ENODEV;
}

int macio_init(void)
{
	struct device_node *adbs;

	adbs = find_compatible_devices("adb", "chrp,adb0");
	if (adbs == 0)
		return -ENXIO;

#if 0
	{ int i;

	printk("macio_adb_init: node = %p, addrs =", adbs->node);
	for (i = 0; i < adbs->n_addrs; ++i)
		printk(" %x(%x)", adbs->addrs[i].address, adbs->addrs[i].size);
	printk(", intrs =");
	for (i = 0; i < adbs->n_intrs; ++i)
		printk(" %x", adbs->intrs[i].line);
	printk("\n"); }
#endif
	
	adb = ioremap(adbs->addrs->address, sizeof(struct adb_regs));

	out_8(&adb->ctrl.r, 0);
	out_8(&adb->intr.r, 0);
	out_8(&adb->error.r, 0);
	out_8(&adb->active_hi.r, 0xff); /* for now, set all devices active */
	out_8(&adb->active_lo.r, 0xff);
	out_8(&adb->autopoll.r, APE);

	if (request_irq(adbs->intrs[0].line, macio_adb_interrupt,
			0, "ADB", (void *)0)) {
		printk(KERN_ERR "ADB: can't get irq %d\n",
		       adbs->intrs[0].line);
		return -EAGAIN;
	}
	out_8(&adb->intr_enb.r, DFB | TAG);

	printk("adb: mac-io driver 1.0 for unified ADB\n");

	return 0;
}

static int macio_adb_autopoll(int devs)
{
	unsigned long flags;
	
	spin_lock_irqsave(&macio_lock, flags);
	out_8(&adb->active_hi.r, devs >> 8);
	out_8(&adb->active_lo.r, devs);
	out_8(&adb->autopoll.r, devs? APE: 0);
	spin_unlock_irqrestore(&macio_lock, flags);
	return 0;
}

static int macio_adb_reset_bus(void)
{
	unsigned long flags;
	int timeout = 1000000;

	/* Hrm... we may want to not lock interrupts for so
	 * long ... oh well, who uses that chip anyway ? :)
	 * That function will be seldomly used during boot
	 * on rare machines, so...
	 */
	spin_lock_irqsave(&macio_lock, flags);
	out_8(&adb->ctrl.r, in_8(&adb->ctrl.r) | ADB_RST);
	while ((in_8(&adb->ctrl.r) & ADB_RST) != 0) {
		if (--timeout == 0) {
			out_8(&adb->ctrl.r, in_8(&adb->ctrl.r) & ~ADB_RST);
			return -1;
		}
	}
	spin_unlock_irqrestore(&macio_lock, flags);
	return 0;
}

/* Send an ADB command */
static int macio_send_request(struct adb_request *req, int sync)
{
	unsigned long flags;
	int i;
	
	if (req->data[0] != ADB_PACKET)
		return -EINVAL;
	
	for (i = 0; i < req->nbytes - 1; ++i)
		req->data[i] = req->data[i+1];
	--req->nbytes;
	
	req->next = NULL;
	req->sent = 0;
	req->complete = 0;
	req->reply_len = 0;

	spin_lock_irqsave(&macio_lock, flags);
	if (current_req != 0) {
		last_req->next = req;
		last_req = req;
	} else {
		current_req = last_req = req;
		out_8(&adb->ctrl.r, in_8(&adb->ctrl.r) | TAR);
	}
	spin_unlock_irqrestore(&macio_lock, flags);
	
	if (sync) {
		while (!req->complete)
			macio_adb_poll();
	}

	return 0;
}

static irqreturn_t macio_adb_interrupt(int irq, void *arg,
				       struct pt_regs *regs)
{
	int i, n, err;
	struct adb_request *req = NULL;
	unsigned char ibuf[16];
	int ibuf_len = 0;
	int complete = 0;
	int autopoll = 0;
	int handled = 0;

	spin_lock(&macio_lock);
	if (in_8(&adb->intr.r) & TAG) {
		handled = 1;
		if ((req = current_req) != 0) {
			/* put the current request in */
			for (i = 0; i < req->nbytes; ++i)
				out_8(&adb->data[i].r, req->data[i]);
			out_8(&adb->dcount.r, req->nbytes & HMB);
			req->sent = 1;
			if (req->reply_expected) {
				out_8(&adb->ctrl.r, DTB + CRE);
			} else {
				out_8(&adb->ctrl.r, DTB);
				current_req = req->next;
				complete = 1;
				if (current_req)
					out_8(&adb->ctrl.r, in_8(&adb->ctrl.r) | TAR);
			}
		}
		out_8(&adb->intr.r, 0);
	}

	if (in_8(&adb->intr.r) & DFB) {
		handled = 1;
		err = in_8(&adb->error.r);
		if (current_req && current_req->sent) {
			/* this is the response to a command */
			req = current_req;
			if (err == 0) {
				req->reply_len = in_8(&adb->dcount.r) & HMB;
				for (i = 0; i < req->reply_len; ++i)
					req->reply[i] = in_8(&adb->data[i].r);
			}
			current_req = req->next;
			complete = 1;
			if (current_req)
				out_8(&adb->ctrl.r, in_8(&adb->ctrl.r) | TAR);
		} else if (err == 0) {
			/* autopoll data */
			n = in_8(&adb->dcount.r) & HMB;
			for (i = 0; i < n; ++i)
				ibuf[i] = in_8(&adb->data[i].r);
			ibuf_len = n;
			autopoll = (in_8(&adb->dcount.r) & APD) != 0;
		}
		out_8(&adb->error.r, 0);
		out_8(&adb->intr.r, 0);
	}
	spin_unlock(&macio_lock);
	if (complete && req) {
	    void (*done)(struct adb_request *) = req->done;
	    mb();
	    req->complete = 1;
	    /* Here, we assume that if the request has a done member, the
    	     * struct request will survive to setting req->complete to 1
	     */
	    if (done)
		(*done)(req);
	}
	if (ibuf_len)
		adb_input(ibuf, ibuf_len, regs, autopoll);

	return IRQ_RETVAL(handled);
}

static void macio_adb_poll(void)
{
	unsigned long flags;

	local_irq_save(flags);
	if (in_8(&adb->intr.r) != 0)
		macio_adb_interrupt(0, NULL, NULL);
	local_irq_restore(flags);
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Driver for the ADB controller in the Mac I/O (Hydra) chip.
	3	*/
	4	#include <stdarg.h>
	5	#include <linux/types.h>
	6	#include <linux/errno.h>
	7	#include <linux/kernel.h>
	8	#include <linux/delay.h>
	9	#include <linux/sched.h>
	10	#include <linux/spinlock.h>
	11	#include <linux/interrupt.h>
	12	#include <asm/prom.h>
	13	#include <linux/adb.h>
	14	#include <asm/io.h>
	15	#include <asm/pgtable.h>
	16	#include <asm/hydra.h>
	17	#include <asm/irq.h>
	18	#include <asm/system.h>
	19	#include <linux/init.h>
	20
	21	struct preg {
	22	unsigned char r;
	23	char pad[15];
	24	};
	25
	26	struct adb_regs {
	27	struct preg intr;
	28	struct preg data[9];
	29	struct preg intr_enb;
	30	struct preg dcount;
	31	struct preg error;
	32	struct preg ctrl;
	33	struct preg autopoll;
	34	struct preg active_hi;
	35	struct preg active_lo;
	36	struct preg test;
	37	};
	38
	39	/* Bits in intr and intr_enb registers */
	40	#define DFB 1 /* data from bus */
	41	#define TAG 2 /* transfer access grant */
	42
	43	/* Bits in dcount register */
	44	#define HMB 0x0f /* how many bytes */
	45	#define APD 0x10 /* auto-poll data */
	46
	47	/* Bits in error register */
	48	#define NRE 1 /* no response error */
	49	#define DLE 2 /* data lost error */
	50
	51	/* Bits in ctrl register */
	52	#define TAR 1 /* transfer access request */
	53	#define DTB 2 /* data to bus */
	54	#define CRE 4 /* command response expected */
	55	#define ADB_RST 8 /* ADB reset */
	56
	57	/* Bits in autopoll register */
	58	#define APE 1 /* autopoll enable */
	59
	60	static volatile struct adb_regs __iomem *adb;
	61	static struct adb_request current_req, last_req;
	62	static DEFINE_SPINLOCK(macio_lock);
	63
	64	static int macio_probe(void);
65	static int macio_init(void);
66	static irqreturn_t macio_adb_interrupt(int irq, void arg, struct pt_regs regs);
67	static int macio_send_request(struct adb_request *req, int sync);
68	static int macio_adb_autopoll(int devs);
69	static void macio_adb_poll(void);
70	static int macio_adb_reset_bus(void);
71
72	struct adb_driver macio_adb_driver = {
73	"MACIO",
74	macio_probe,
75	macio_init,
76	macio_send_request,
77	/macio_write,/
78	macio_adb_autopoll,
79	macio_adb_poll,
80	macio_adb_reset_bus
81	};
82
83	int macio_probe(void)
84	{
85	return find_compatible_devices("adb", "chrp,adb0")? 0: -ENODEV;
86	}
87
88	int macio_init(void)
89	{
90	struct device_node *adbs;
91
92	adbs = find_compatible_devices("adb", "chrp,adb0");
93	if (adbs == 0)
94	return -ENXIO;
95
96	#if 0
97	{ int i;
98
99	printk("macio_adb_init: node = %p, addrs =", adbs->node);
100	for (i = 0; i < adbs->n_addrs; ++i)
101	printk(" %x(%x)", adbs->addrs[i].address, adbs->addrs[i].size);
102	printk(", intrs =");
103	for (i = 0; i < adbs->n_intrs; ++i)
104	printk(" %x", adbs->intrs[i].line);
105	printk("\n"); }
106	#endif
107
108	adb = ioremap(adbs->addrs->address, sizeof(struct adb_regs));
109
110	out_8(&adb->ctrl.r, 0);
111	out_8(&adb->intr.r, 0);
112	out_8(&adb->error.r, 0);
113	out_8(&adb->active_hi.r, 0xff); /* for now, set all devices active */
114	out_8(&adb->active_lo.r, 0xff);
115	out_8(&adb->autopoll.r, APE);
116
117	if (request_irq(adbs->intrs[0].line, macio_adb_interrupt,
118	0, "ADB", (void *)0)) {
119	printk(KERN_ERR "ADB: can't get irq %d\n",
120	adbs->intrs[0].line);
121	return -EAGAIN;
122	}
123	out_8(&adb->intr_enb.r, DFB \| TAG);
124
125	printk("adb: mac-io driver 1.0 for unified ADB\n");
126
127	return 0;
128	}
129
130	static int macio_adb_autopoll(int devs)
131	{
132	unsigned long flags;
133
134	spin_lock_irqsave(&macio_lock, flags);
135	out_8(&adb->active_hi.r, devs >> 8);
136	out_8(&adb->active_lo.r, devs);
137	out_8(&adb->autopoll.r, devs? APE: 0);
138	spin_unlock_irqrestore(&macio_lock, flags);
139	return 0;
140	}
141
142	static int macio_adb_reset_bus(void)
143	{
144	unsigned long flags;
145	int timeout = 1000000;
146
147	/* Hrm... we may want to not lock interrupts for so
148	* long ... oh well, who uses that chip anyway ? :)
149	* That function will be seldomly used during boot
150	* on rare machines, so...
151	*/
152	spin_lock_irqsave(&macio_lock, flags);
153	out_8(&adb->ctrl.r, in_8(&adb->ctrl.r) \| ADB_RST);
154	while ((in_8(&adb->ctrl.r) & ADB_RST) != 0) {
155	if (--timeout == 0) {
156	out_8(&adb->ctrl.r, in_8(&adb->ctrl.r) & ~ADB_RST);
157	return -1;
158	}
159	}
160	spin_unlock_irqrestore(&macio_lock, flags);
161	return 0;
162	}
163
164	/* Send an ADB command */
165	static int macio_send_request(struct adb_request *req, int sync)
166	{
167	unsigned long flags;
168	int i;
169
170	if (req->data[0] != ADB_PACKET)
171	return -EINVAL;
172
173	for (i = 0; i < req->nbytes - 1; ++i)
174	req->data[i] = req->data[i+1];
175	--req->nbytes;
176
177	req->next = NULL;
178	req->sent = 0;
179	req->complete = 0;
180	req->reply_len = 0;
181
182	spin_lock_irqsave(&macio_lock, flags);
183	if (current_req != 0) {
184	last_req->next = req;
185	last_req = req;
186	} else {
187	current_req = last_req = req;
188	out_8(&adb->ctrl.r, in_8(&adb->ctrl.r) \| TAR);
189	}
190	spin_unlock_irqrestore(&macio_lock, flags);
191
192	if (sync) {
193	while (!req->complete)
194	macio_adb_poll();
195	}
196
197	return 0;
198	}
199
200	static irqreturn_t macio_adb_interrupt(int irq, void *arg,
201	struct pt_regs *regs)
202	{
203	int i, n, err;
204	struct adb_request *req = NULL;
205	unsigned char ibuf[16];
206	int ibuf_len = 0;
207	int complete = 0;
208	int autopoll = 0;
209	int handled = 0;
210
211	spin_lock(&macio_lock);
212	if (in_8(&adb->intr.r) & TAG) {
213	handled = 1;
214	if ((req = current_req) != 0) {
215	/* put the current request in */
216	for (i = 0; i < req->nbytes; ++i)
217	out_8(&adb->data[i].r, req->data[i]);
218	out_8(&adb->dcount.r, req->nbytes & HMB);
219	req->sent = 1;
220	if (req->reply_expected) {
221	out_8(&adb->ctrl.r, DTB + CRE);
222	} else {
223	out_8(&adb->ctrl.r, DTB);
224	current_req = req->next;
225	complete = 1;
226	if (current_req)
227	out_8(&adb->ctrl.r, in_8(&adb->ctrl.r) \| TAR);
228	}
229	}
230	out_8(&adb->intr.r, 0);
231	}
232
233	if (in_8(&adb->intr.r) & DFB) {
234	handled = 1;
235	err = in_8(&adb->error.r);
236	if (current_req && current_req->sent) {
237	/* this is the response to a command */
238	req = current_req;
239	if (err == 0) {
240	req->reply_len = in_8(&adb->dcount.r) & HMB;
241	for (i = 0; i < req->reply_len; ++i)
242	req->reply[i] = in_8(&adb->data[i].r);
243	}
244	current_req = req->next;
245	complete = 1;
246	if (current_req)
247	out_8(&adb->ctrl.r, in_8(&adb->ctrl.r) \| TAR);
248	} else if (err == 0) {
249	/* autopoll data */
250	n = in_8(&adb->dcount.r) & HMB;
251	for (i = 0; i < n; ++i)
252	ibuf[i] = in_8(&adb->data[i].r);
253	ibuf_len = n;
254	autopoll = (in_8(&adb->dcount.r) & APD) != 0;
255	}
256	out_8(&adb->error.r, 0);
257	out_8(&adb->intr.r, 0);
258	}
259	spin_unlock(&macio_lock);
260	if (complete && req) {
261	void (done)(struct adb_request ) = req->done;
262	mb();
263	req->complete = 1;
264	/* Here, we assume that if the request has a done member, the
265	* struct request will survive to setting req->complete to 1
266	*/
267	if (done)
268	(*done)(req);
269	}
270	if (ibuf_len)
271	adb_input(ibuf, ibuf_len, regs, autopoll);
272
273	return IRQ_RETVAL(handled);
274	}
275
276	static void macio_adb_poll(void)
277	{
278	unsigned long flags;
279
280	local_irq_save(flags);
281	if (in_8(&adb->intr.r) != 0)
282	macio_adb_interrupt(0, NULL, NULL);
283	local_irq_restore(flags);
284	}