1/*
2 * Device driver for the via-cuda on Apple Powermacs.
3 *
4 * The VIA (versatile interface adapter) interfaces to the CUDA,
5 * a 6805 microprocessor core which controls the ADB (Apple Desktop
6 * Bus) which connects to the keyboard and mouse.  The CUDA also
7 * controls system power and the RTC (real time clock) chip.
8 *
9 * Copyright (C) 1996 Paul Mackerras.
10 */
11#include <stdarg.h>
12#include <linux/types.h>
13#include <linux/errno.h>
14#include <linux/kernel.h>
15#include <linux/delay.h>
16#include <linux/adb.h>
17#include <linux/cuda.h>
18#include <linux/spinlock.h>
19#include <linux/interrupt.h>
20#ifdef CONFIG_PPC
21#include <asm/prom.h>
22#include <asm/machdep.h>
23#else
24#include <asm/macintosh.h>
25#include <asm/macints.h>
26#include <asm/mac_via.h>
27#endif
28#include <asm/io.h>
29#include <linux/init.h>
30
31static volatile unsigned char __iomem *via;
32static DEFINE_SPINLOCK(cuda_lock);
33
34/* VIA registers - spaced 0x200 bytes apart */
35#define RS		0x200		/* skip between registers */
36#define B		0		/* B-side data */
37#define A		RS		/* A-side data */
38#define DIRB		(2*RS)		/* B-side direction (1=output) */
39#define DIRA		(3*RS)		/* A-side direction (1=output) */
40#define T1CL		(4*RS)		/* Timer 1 ctr/latch (low 8 bits) */
41#define T1CH		(5*RS)		/* Timer 1 counter (high 8 bits) */
42#define T1LL		(6*RS)		/* Timer 1 latch (low 8 bits) */
43#define T1LH		(7*RS)		/* Timer 1 latch (high 8 bits) */
44#define T2CL		(8*RS)		/* Timer 2 ctr/latch (low 8 bits) */
45#define T2CH		(9*RS)		/* Timer 2 counter (high 8 bits) */
46#define SR		(10*RS)		/* Shift register */
47#define ACR		(11*RS)		/* Auxiliary control register */
48#define PCR		(12*RS)		/* Peripheral control register */
49#define IFR		(13*RS)		/* Interrupt flag register */
50#define IER		(14*RS)		/* Interrupt enable register */
51#define ANH		(15*RS)		/* A-side data, no handshake */
52
53/* Bits in B data register: all active low */
54#define TREQ		0x08		/* Transfer request (input) */
55#define TACK		0x10		/* Transfer acknowledge (output) */
56#define TIP		0x20		/* Transfer in progress (output) */
57
58/* Bits in ACR */
59#define SR_CTRL		0x1c		/* Shift register control bits */
60#define SR_EXT		0x0c		/* Shift on external clock */
61#define SR_OUT		0x10		/* Shift out if 1 */
62
63/* Bits in IFR and IER */
64#define IER_SET		0x80		/* set bits in IER */
65#define IER_CLR		0		/* clear bits in IER */
66#define SR_INT		0x04		/* Shift register full/empty */
67
68static enum cuda_state {
69    idle,
70    sent_first_byte,
71    sending,
72    reading,
73    read_done,
74    awaiting_reply
75} cuda_state;
76
77static struct adb_request *current_req;
78static struct adb_request *last_req;
79static unsigned char cuda_rbuf[16];
80static unsigned char *reply_ptr;
81static int reading_reply;
82static int data_index;
83static int cuda_irq;
84#ifdef CONFIG_PPC
85static struct device_node *vias;
86#endif
87static int cuda_fully_inited;
88
89#ifdef CONFIG_ADB
90static int cuda_probe(void);
91static int cuda_send_request(struct adb_request *req, int sync);
92static int cuda_adb_autopoll(int devs);
93static int cuda_reset_adb_bus(void);
94#endif /* CONFIG_ADB */
95
96static int cuda_init_via(void);
97static void cuda_start(void);
98static irqreturn_t cuda_interrupt(int irq, void *arg);
99static void cuda_input(unsigned char *buf, int nb);
100void cuda_poll(void);
101static int cuda_write(struct adb_request *req);
102
103int cuda_request(struct adb_request *req,
104		 void (*done)(struct adb_request *), int nbytes, ...);
105
106#ifdef CONFIG_ADB
107struct adb_driver via_cuda_driver = {
108	.name         = "CUDA",
109	.probe        = cuda_probe,
110	.send_request = cuda_send_request,
111	.autopoll     = cuda_adb_autopoll,
112	.poll         = cuda_poll,
113	.reset_bus    = cuda_reset_adb_bus,
114};
115#endif /* CONFIG_ADB */
116
117#ifdef CONFIG_MAC
118int __init find_via_cuda(void)
119{
120    struct adb_request req;
121    int err;
122
123    if (macintosh_config->adb_type != MAC_ADB_CUDA)
124	return 0;
125
126    via = via1;
127    cuda_state = idle;
128
129    err = cuda_init_via();
130    if (err) {
131	printk(KERN_ERR "cuda_init_via() failed\n");
132	via = NULL;
133	return 0;
134    }
135
136    /* enable autopoll */
137    cuda_request(&req, NULL, 3, CUDA_PACKET, CUDA_AUTOPOLL, 1);
138    while (!req.complete)
139	cuda_poll();
140
141    return 1;
142}
143#else
144int __init find_via_cuda(void)
145{
146    struct adb_request req;
147    phys_addr_t taddr;
148    const u32 *reg;
149    int err;
150
151    if (vias != 0)
152	return 1;
153    vias = of_find_node_by_name(NULL, "via-cuda");
154    if (vias == 0)
155	return 0;
156
157    reg = of_get_property(vias, "reg", NULL);
158    if (reg == NULL) {
159	    printk(KERN_ERR "via-cuda: No \"reg\" property !\n");
160	    goto fail;
161    }
162    taddr = of_translate_address(vias, reg);
163    if (taddr == 0) {
164	    printk(KERN_ERR "via-cuda: Can't translate address !\n");
165	    goto fail;
166    }
167    via = ioremap(taddr, 0x2000);
168    if (via == NULL) {
169	    printk(KERN_ERR "via-cuda: Can't map address !\n");
170	    goto fail;
171    }
172
173    cuda_state = idle;
174    sys_ctrler = SYS_CTRLER_CUDA;
175
176    err = cuda_init_via();
177    if (err) {
178	printk(KERN_ERR "cuda_init_via() failed\n");
179	via = NULL;
180	return 0;
181    }
182
183    /* Clear and enable interrupts, but only on PPC. On 68K it's done  */
184    /* for us by the main VIA driver in arch/m68k/mac/via.c        */
185
186    out_8(&via[IFR], 0x7f);	/* clear interrupts by writing 1s */
187    out_8(&via[IER], IER_SET|SR_INT); /* enable interrupt from SR */
188
189    /* enable autopoll */
190    cuda_request(&req, NULL, 3, CUDA_PACKET, CUDA_AUTOPOLL, 1);
191    while (!req.complete)
192	cuda_poll();
193
194    return 1;
195
196 fail:
197    of_node_put(vias);
198    vias = NULL;
199    return 0;
200}
201#endif /* !defined CONFIG_MAC */
202
203static int __init via_cuda_start(void)
204{
205    if (via == NULL)
206	return -ENODEV;
207
208#ifdef CONFIG_MAC
209    cuda_irq = IRQ_MAC_ADB;
210#else
211    cuda_irq = irq_of_parse_and_map(vias, 0);
212    if (cuda_irq == NO_IRQ) {
213	printk(KERN_ERR "via-cuda: can't map interrupts for %s\n",
214	       vias->full_name);
215	return -ENODEV;
216    }
217#endif
218
219    if (request_irq(cuda_irq, cuda_interrupt, 0, "ADB", cuda_interrupt)) {
220	printk(KERN_ERR "via-cuda: can't request irq %d\n", cuda_irq);
221	return -EAGAIN;
222    }
223
224    printk("Macintosh CUDA driver v0.5 for Unified ADB.\n");
225
226    cuda_fully_inited = 1;
227    return 0;
228}
229
230device_initcall(via_cuda_start);
231
232#ifdef CONFIG_ADB
233static int
234cuda_probe(void)
235{
236#ifdef CONFIG_PPC
237    if (sys_ctrler != SYS_CTRLER_CUDA)
238	return -ENODEV;
239#else
240    if (macintosh_config->adb_type != MAC_ADB_CUDA)
241	return -ENODEV;
242#endif
243    if (via == NULL)
244	return -ENODEV;
245    return 0;
246}
247#endif /* CONFIG_ADB */
248
249#define WAIT_FOR(cond, what)					\
250    do {                                                        \
251    	int x;							\
252	for (x = 1000; !(cond); --x) {				\
253	    if (x == 0) {					\
254		printk("Timeout waiting for " what "\n");	\
255		return -ENXIO;					\
256	    }							\
257	    udelay(100);					\
258	}							\
259    } while (0)
260
261static int
262cuda_init_via(void)
263{
264    out_8(&via[DIRB], (in_8(&via[DIRB]) | TACK | TIP) & ~TREQ);	/* TACK & TIP out */
265    out_8(&via[B], in_8(&via[B]) | TACK | TIP);			/* negate them */
266    out_8(&via[ACR] ,(in_8(&via[ACR]) & ~SR_CTRL) | SR_EXT);	/* SR data in */
267    (void)in_8(&via[SR]);						/* clear any left-over data */
268#ifdef CONFIG_PPC
269    out_8(&via[IER], 0x7f);					/* disable interrupts from VIA */
270    (void)in_8(&via[IER]);
271#else
272    out_8(&via[IER], SR_INT);					/* disable SR interrupt from VIA */
273#endif
274
275    /* delay 4ms and then clear any pending interrupt */
276    mdelay(4);
277    (void)in_8(&via[SR]);
278    out_8(&via[IFR], SR_INT);
279
280    /* sync with the CUDA - assert TACK without TIP */
281    out_8(&via[B], in_8(&via[B]) & ~TACK);
282
283    /* wait for the CUDA to assert TREQ in response */
284    WAIT_FOR((in_8(&via[B]) & TREQ) == 0, "CUDA response to sync");
285
286    /* wait for the interrupt and then clear it */
287    WAIT_FOR(in_8(&via[IFR]) & SR_INT, "CUDA response to sync (2)");
288    (void)in_8(&via[SR]);
289    out_8(&via[IFR], SR_INT);
290
291    /* finish the sync by negating TACK */
292    out_8(&via[B], in_8(&via[B]) | TACK);
293
294    /* wait for the CUDA to negate TREQ and the corresponding interrupt */
295    WAIT_FOR(in_8(&via[B]) & TREQ, "CUDA response to sync (3)");
296    WAIT_FOR(in_8(&via[IFR]) & SR_INT, "CUDA response to sync (4)");
297    (void)in_8(&via[SR]);
298    out_8(&via[IFR], SR_INT);
299    out_8(&via[B], in_8(&via[B]) | TIP);	/* should be unnecessary */
300
301    return 0;
302}
303
304#ifdef CONFIG_ADB
305/* Send an ADB command */
306static int
307cuda_send_request(struct adb_request *req, int sync)
308{
309    int i;
310
311    if ((via == NULL) || !cuda_fully_inited) {
312	req->complete = 1;
313	return -ENXIO;
314    }
315
316    req->reply_expected = 1;
317
318    i = cuda_write(req);
319    if (i)
320	return i;
321
322    if (sync) {
323	while (!req->complete)
324	    cuda_poll();
325    }
326    return 0;
327}
328
329
330/* Enable/disable autopolling */
331static int
332cuda_adb_autopoll(int devs)
333{
334    struct adb_request req;
335
336    if ((via == NULL) || !cuda_fully_inited)
337	return -ENXIO;
338
339    cuda_request(&req, NULL, 3, CUDA_PACKET, CUDA_AUTOPOLL, (devs? 1: 0));
340    while (!req.complete)
341	cuda_poll();
342    return 0;
343}
344
345/* Reset adb bus - how do we do this?? */
346static int
347cuda_reset_adb_bus(void)
348{
349    struct adb_request req;
350
351    if ((via == NULL) || !cuda_fully_inited)
352	return -ENXIO;
353
354    cuda_request(&req, NULL, 2, ADB_PACKET, 0);		/* maybe? */
355    while (!req.complete)
356	cuda_poll();
357    return 0;
358}
359#endif /* CONFIG_ADB */
360/* Construct and send a cuda request */
361int
362cuda_request(struct adb_request *req, void (*done)(struct adb_request *),
363	     int nbytes, ...)
364{
365    va_list list;
366    int i;
367
368    if (via == NULL) {
369	req->complete = 1;
370	return -ENXIO;
371    }
372
373    req->nbytes = nbytes;
374    req->done = done;
375    va_start(list, nbytes);
376    for (i = 0; i < nbytes; ++i)
377	req->data[i] = va_arg(list, int);
378    va_end(list);
379    req->reply_expected = 1;
380    return cuda_write(req);
381}
382
383static int
384cuda_write(struct adb_request *req)
385{
386    unsigned long flags;
387
388    if (req->nbytes < 2 || req->data[0] > CUDA_PACKET) {
389	req->complete = 1;
390	return -EINVAL;
391    }
392    req->next = NULL;
393    req->sent = 0;
394    req->complete = 0;
395    req->reply_len = 0;
396
397    spin_lock_irqsave(&cuda_lock, flags);
398    if (current_req != 0) {
399	last_req->next = req;
400	last_req = req;
401    } else {
402	current_req = req;
403	last_req = req;
404	if (cuda_state == idle)
405	    cuda_start();
406    }
407    spin_unlock_irqrestore(&cuda_lock, flags);
408
409    return 0;
410}
411
412static void
413cuda_start(void)
414{
415    struct adb_request *req;
416
417    /* assert cuda_state == idle */
418    /* get the packet to send */
419    req = current_req;
420    if (req == 0)
421	return;
422    if ((in_8(&via[B]) & TREQ) == 0)
423	return;			/* a byte is coming in from the CUDA */
424
425    /* set the shift register to shift out and send a byte */
426    out_8(&via[ACR], in_8(&via[ACR]) | SR_OUT);
427    out_8(&via[SR], req->data[0]);
428    out_8(&via[B], in_8(&via[B]) & ~TIP);
429    cuda_state = sent_first_byte;
430}
431
432void
433cuda_poll(void)
434{
435    /* cuda_interrupt only takes a normal lock, we disable
436     * interrupts here to avoid re-entering and thus deadlocking.
437     */
438    if (cuda_irq)
439	disable_irq(cuda_irq);
440    cuda_interrupt(0, NULL);
441    if (cuda_irq)
442	enable_irq(cuda_irq);
443}
444
445static irqreturn_t
446cuda_interrupt(int irq, void *arg)
447{
448    int status;
449    struct adb_request *req = NULL;
450    unsigned char ibuf[16];
451    int ibuf_len = 0;
452    int complete = 0;
453
454    spin_lock(&cuda_lock);
455
456    /* On powermacs, this handler is registered for the VIA IRQ. But they use
457     * just the shift register IRQ -- other VIA interrupt sources are disabled.
458     * On m68k macs, the VIA IRQ sources are dispatched individually. Unless
459     * we are polling, the shift register IRQ flag has already been cleared.
460     */
461
462#ifdef CONFIG_MAC
463    if (!arg)
464#endif
465    {
466        if ((in_8(&via[IFR]) & SR_INT) == 0) {
467            spin_unlock(&cuda_lock);
468            return IRQ_NONE;
469        } else {
470            out_8(&via[IFR], SR_INT);
471        }
472    }
473
474    status = (~in_8(&via[B]) & (TIP|TREQ)) | (in_8(&via[ACR]) & SR_OUT);
475    /* printk("cuda_interrupt: state=%d status=%x\n", cuda_state, status); */
476    switch (cuda_state) {
477    case idle:
478	/* CUDA has sent us the first byte of data - unsolicited */
479	if (status != TREQ)
480	    printk("cuda: state=idle, status=%x\n", status);
481	(void)in_8(&via[SR]);
482	out_8(&via[B], in_8(&via[B]) & ~TIP);
483	cuda_state = reading;
484	reply_ptr = cuda_rbuf;
485	reading_reply = 0;
486	break;
487
488    case awaiting_reply:
489	/* CUDA has sent us the first byte of data of a reply */
490	if (status != TREQ)
491	    printk("cuda: state=awaiting_reply, status=%x\n", status);
492	(void)in_8(&via[SR]);
493	out_8(&via[B], in_8(&via[B]) & ~TIP);
494	cuda_state = reading;
495	reply_ptr = current_req->reply;
496	reading_reply = 1;
497	break;
498
499    case sent_first_byte:
500	if (status == TREQ + TIP + SR_OUT) {
501	    /* collision */
502	    out_8(&via[ACR], in_8(&via[ACR]) & ~SR_OUT);
503	    (void)in_8(&via[SR]);
504	    out_8(&via[B], in_8(&via[B]) | TIP | TACK);
505	    cuda_state = idle;
506	} else {
507	    /* assert status == TIP + SR_OUT */
508	    if (status != TIP + SR_OUT)
509		printk("cuda: state=sent_first_byte status=%x\n", status);
510	    out_8(&via[SR], current_req->data[1]);
511	    out_8(&via[B], in_8(&via[B]) ^ TACK);
512	    data_index = 2;
513	    cuda_state = sending;
514	}
515	break;
516
517    case sending:
518	req = current_req;
519	if (data_index >= req->nbytes) {
520	    out_8(&via[ACR], in_8(&via[ACR]) & ~SR_OUT);
521	    (void)in_8(&via[SR]);
522	    out_8(&via[B], in_8(&via[B]) | TACK | TIP);
523	    req->sent = 1;
524	    if (req->reply_expected) {
525		cuda_state = awaiting_reply;
526	    } else {
527		current_req = req->next;
528		complete = 1;
529		/* not sure about this */
530		cuda_state = idle;
531		cuda_start();
532	    }
533	} else {
534	    out_8(&via[SR], req->data[data_index++]);
535	    out_8(&via[B], in_8(&via[B]) ^ TACK);
536	}
537	break;
538
539    case reading:
540	*reply_ptr++ = in_8(&via[SR]);
541	if (status == TIP) {
542	    /* that's all folks */
543	    out_8(&via[B], in_8(&via[B]) | TACK | TIP);
544	    cuda_state = read_done;
545	} else {
546	    /* assert status == TIP | TREQ */
547	    if (status != TIP + TREQ)
548		printk("cuda: state=reading status=%x\n", status);
549	    out_8(&via[B], in_8(&via[B]) ^ TACK);
550	}
551	break;
552
553    case read_done:
554	(void)in_8(&via[SR]);
555	if (reading_reply) {
556	    req = current_req;
557	    req->reply_len = reply_ptr - req->reply;
558	    if (req->data[0] == ADB_PACKET) {
559		/* Have to adjust the reply from ADB commands */
560		if (req->reply_len <= 2 || (req->reply[1] & 2) != 0) {
561		    /* the 0x2 bit indicates no response */
562		    req->reply_len = 0;
563		} else {
564		    /* leave just the command and result bytes in the reply */
565		    req->reply_len -= 2;
566		    memmove(req->reply, req->reply + 2, req->reply_len);
567		}
568	    }
569	    current_req = req->next;
570	    complete = 1;
571	} else {
572	    /* This is tricky. We must break the spinlock to call
573	     * cuda_input. However, doing so means we might get
574	     * re-entered from another CPU getting an interrupt
575	     * or calling cuda_poll(). I ended up using the stack
576	     * (it's only for 16 bytes) and moving the actual
577	     * call to cuda_input to outside of the lock.
578	     */
579	    ibuf_len = reply_ptr - cuda_rbuf;
580	    memcpy(ibuf, cuda_rbuf, ibuf_len);
581	}
582	if (status == TREQ) {
583	    out_8(&via[B], in_8(&via[B]) & ~TIP);
584	    cuda_state = reading;
585	    reply_ptr = cuda_rbuf;
586	    reading_reply = 0;
587	} else {
588	    cuda_state = idle;
589	    cuda_start();
590	}
591	break;
592
593    default:
594	printk("cuda_interrupt: unknown cuda_state %d?\n", cuda_state);
595    }
596    spin_unlock(&cuda_lock);
597    if (complete && req) {
598    	void (*done)(struct adb_request *) = req->done;
599    	mb();
600    	req->complete = 1;
601    	/* Here, we assume that if the request has a done member, the
602    	 * struct request will survive to setting req->complete to 1
603    	 */
604    	if (done)
605		(*done)(req);
606    }
607    if (ibuf_len)
608	cuda_input(ibuf, ibuf_len);
609    return IRQ_HANDLED;
610}
611
612static void
613cuda_input(unsigned char *buf, int nb)
614{
615    int i;
616
617    switch (buf[0]) {
618    case ADB_PACKET:
619#ifdef CONFIG_XMON
620	if (nb == 5 && buf[2] == 0x2c) {
621	    extern int xmon_wants_key, xmon_adb_keycode;
622	    if (xmon_wants_key) {
623		xmon_adb_keycode = buf[3];
624		return;
625	    }
626	}
627#endif /* CONFIG_XMON */
628#ifdef CONFIG_ADB
629	adb_input(buf+2, nb-2, buf[1] & 0x40);
630#endif /* CONFIG_ADB */
631	break;
632
633    default:
634	printk("data from cuda (%d bytes):", nb);
635	for (i = 0; i < nb; ++i)
636	    printk(" %.2x", buf[i]);
637	printk("\n");
638    }
639}
640