2 * Device driver for the via ADB on (many) Mac II-class machines
4 * Based on the original ADB keyboard handler Copyright (c) 1997 Alan Cox
5 * Also derived from code Copyright (C) 1996 Paul Mackerras.
7 * With various updates provided over the years by Michael Schmitz,
8 * Guideo Koerber and others.
10 * Rewrite for Unified ADB by Joshua M. Thompson (funaho@jurai.org)
12 * 1999-08-02 (jmt) - Initial rewrite for Unified ADB.
13 * 2000-03-29 Tony Mantler <tonym@mac.linux-m68k.org>
14 * - Big overhaul, should actually work now.
18 #include <linux/types.h>
19 #include <linux/errno.h>
20 #include <linux/kernel.h>
21 #include <linux/delay.h>
22 #include <linux/sched.h>
23 #include <linux/adb.h>
24 #include <linux/init.h>
25 #include <asm/macintosh.h>
26 #include <asm/macints.h>
27 #include <asm/machw.h>
28 #include <asm/mac_via.h>
30 #include <asm/system.h>
32 static volatile unsigned char *via;
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 */
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 #define ST_MASK 0x30 /* mask for selecting ADB state bits */
60 #define SR_CTRL 0x1c /* Shift register control bits */
61 #define SR_EXT 0x0c /* Shift on external clock */
62 #define SR_OUT 0x10 /* Shift out if 1 */
64 /* Bits in IFR and IER */
65 #define IER_SET 0x80 /* set bits in IER */
66 #define IER_CLR 0 /* clear bits in IER */
67 #define SR_INT 0x04 /* Shift register full/empty */
68 #define SR_DATA 0x08 /* Shift register data */
69 #define SR_CLOCK 0x10 /* Shift register clock */
71 /* ADB transaction states according to GMHW */
72 #define ST_CMD 0x00 /* ADB state: command byte */
73 #define ST_EVEN 0x10 /* ADB state: even data byte */
74 #define ST_ODD 0x20 /* ADB state: odd data byte */
75 #define ST_IDLE 0x30 /* ADB state: idle, nothing to send */
77 static int macii_init_via(void);
78 static void macii_start(void);
79 static void macii_interrupt(int irq, void *arg, struct pt_regs *regs);
80 static void macii_retransmit(int);
81 static void macii_queue_poll(void);
83 static int macii_probe(void);
84 static int macii_init(void);
85 static int macii_send_request(struct adb_request *req, int sync);
86 static int macii_write(struct adb_request *req);
87 static int macii_autopoll(int devs);
88 static void macii_poll(void);
89 static int macii_reset_bus(void);
91 struct adb_driver via_macii_driver = {
101 static enum macii_state {
109 static int need_poll = 0;
110 static int command_byte = 0;
111 static int last_reply = 0;
112 static int last_active = 0;
114 static struct adb_request *current_req;
115 static struct adb_request *last_req;
116 static struct adb_request *retry_req;
117 static unsigned char reply_buf[16];
118 static unsigned char *reply_ptr;
119 static int reply_len;
120 static int reading_reply;
121 static int data_index;
122 static int first_byte;
123 static int prefix_len;
124 static int status = ST_IDLE|TREQ;
125 static int last_status;
126 static int driver_running = 0;
128 /* debug level 10 required for ADB logging (should be && debug_adb, ideally) */
130 /* Check for MacII style ADB */
131 static int macii_probe(void)
133 if (macintosh_config->adb_type != MAC_ADB_II) return -ENODEV;
137 printk("adb: Mac II ADB Driver v1.0 for Unified ADB\n");
141 /* Initialize the driver */
150 err = macii_init_via();
153 err = request_irq(IRQ_MAC_ADB, macii_interrupt, IRQ_FLG_LOCK, "ADB",
158 restore_flags(flags);
162 /* initialize the hardware */
163 static int macii_init_via(void)
167 /* Set the lines up. We want TREQ as input TACK|TIP as output */
168 via[DIRB] = (via[DIRB] | TACK | TIP) & ~TREQ;
170 /* Set up state: idle */
172 last_status = via[B] & (ST_MASK|TREQ);
174 /* Shift register on input */
175 via[ACR] = (via[ACR] & ~SR_CTRL) | SR_EXT;
177 /* Wipe any pending data and int */
183 /* Send an ADB poll (Talk Register 0 command, tagged on the front of the request queue) */
184 static void macii_queue_poll(void)
186 static int device = 0;
187 static int in_poll=0;
188 static struct adb_request req;
191 if (in_poll) printk("macii_queue_poll: double poll!\n");
194 if (++device > 15) device = 1;
196 adb_request(&req, NULL, ADBREQ_REPLY|ADBREQ_NOSEND, 1,
197 ADB_READREG(device, 0));
202 req.next = current_req;
205 restore_flags(flags);
210 /* Send an ADB retransmit (Talk, appended to the request queue) */
211 static void macii_retransmit(int device)
213 static int in_retransmit = 0;
214 static struct adb_request rt;
217 if (in_retransmit) printk("macii_retransmit: double retransmit!\n");
221 adb_request(&rt, NULL, ADBREQ_REPLY|ADBREQ_NOSEND, 1,
222 ADB_READREG(device, 0));
227 if (current_req != NULL) {
228 last_req->next = &rt;
235 if (macii_state == idle) macii_start();
237 restore_flags(flags);
241 /* Send an ADB request; if sync, poll out the reply 'till it's done */
242 static int macii_send_request(struct adb_request *req, int sync)
246 i = macii_write(req);
250 while (!req->complete) macii_poll();
255 /* Send an ADB request */
256 static int macii_write(struct adb_request *req)
260 if (req->nbytes < 2 || req->data[0] != ADB_PACKET || req->nbytes > 15) {
270 save_flags(flags); cli();
272 if (current_req != NULL) {
273 last_req->next = req;
278 if (macii_state == idle) macii_start();
281 restore_flags(flags);
285 /* Start auto-polling */
286 static int macii_autopoll(int devs)
288 /* Just ping a random default address */
289 if (!(current_req || retry_req))
290 macii_retransmit( (last_active < 16 && last_active > 0) ? last_active : 3);
294 /* Prod the chip without interrupts */
295 static void macii_poll(void)
299 save_flags(flags); cli();
300 if (via[IFR] & SR_INT) macii_interrupt(0, 0, 0);
301 restore_flags(flags);
305 static int macii_reset_bus(void)
307 static struct adb_request req;
309 /* Command = 0, Address = ignored */
310 adb_request(&req, NULL, 0, 1, ADB_BUSRESET);
315 /* Start sending ADB packet */
316 static void macii_start(void)
319 struct adb_request *req;
324 /* assert macii_state == idle */
325 if (macii_state != idle) {
326 printk("macii_start: called while driver busy (%p %x %x)!\n",
327 req, macii_state, (uint) via1[B] & (ST_MASK|TREQ));
331 save_flags(flags); cli();
334 * IRQ signaled ?? (means ADB controller wants to send, or might
335 * be end of packet if we were reading)
337 #if 0 /* FIXME: This is broke broke broke, for some reason */
338 if ((via[B] & TREQ) == 0) {
339 printk("macii_start: weird poll stuff. huh?\n");
341 * FIXME - we need to restart this on a timer
342 * or a collision at boot hangs us.
343 * Never set macii_state to idle here, or macii_start
344 * won't be called again from send_request!
345 * (need to re-check other cases ...)
348 * if the interrupt handler set the need_poll
349 * flag, it's hopefully a SRQ poll or re-Talk
350 * so we try to send here anyway
353 if (console_loglevel == 10)
354 printk("macii_start: device busy - retry %p state %d status %x!\n",
356 (uint) via[B] & (ST_MASK|TREQ));
358 /* set ADB status here ? */
359 restore_flags(flags);
367 * Another retry pending? (sanity check)
373 /* Now send it. Be careful though, that first byte of the request */
374 /* is actually ADB_PACKET; the real data begins at index 1! */
376 /* store command byte */
377 command_byte = req->data[1];
381 via[SR] = req->data[1];
382 /* set ADB state to 'command' */
383 via[B] = (via[B] & ~ST_MASK) | ST_CMD;
385 macii_state = sending;
388 restore_flags(flags);
392 * The notorious ADB interrupt handler - does all of the protocol handling,
393 * except for starting new send operations. Relies heavily on the ADB
394 * controller sending and receiving data, thereby generating SR interrupts
395 * for us. This means there has to be always activity on the ADB bus, otherwise
396 * the whole process dies and has to be re-kicked by sending TALK requests ...
397 * CUDA-based Macs seem to solve this with the autopoll option, for MacII-type
398 * ADB the problem isn't solved yet (retransmit of the latest active TALK seems
399 * a good choice; either on timeout or on a timer interrupt).
401 * The basic ADB state machine was left unchanged from the original MacII code
402 * by Alan Cox, which was based on the CUDA driver for PowerMac.
403 * The syntax of the ADB status lines seems to be totally different on MacII,
404 * though. MacII uses the states Command -> Even -> Odd -> Even ->...-> Idle for
405 * sending, and Idle -> Even -> Odd -> Even ->...-> Idle for receiving. Start
406 * and end of a receive packet are signaled by asserting /IRQ on the interrupt
407 * line. Timeouts are signaled by a sequence of 4 0xFF, with /IRQ asserted on
408 * every other byte. SRQ is probably signaled by 3 or more 0xFF tacked on the
409 * end of a packet. (Thanks to Guido Koerber for eavesdropping on the ADB
410 * protocol with a logic analyzer!!)
412 * Note: As of 21/10/97, the MacII ADB part works including timeout detection
413 * and retransmit (Talk to the last active device).
415 void macii_interrupt(int irq, void *arg, struct pt_regs *regs)
419 struct adb_request *req;
421 last_status = status;
423 /* prevent races due to SCSI enabling ints */
424 save_flags(flags); cli();
426 if (driver_running) {
427 restore_flags(flags);
433 status = via[B] & (ST_MASK|TREQ);
434 adbdir = via[ACR] & SR_OUT;
436 switch (macii_state) {
440 /* set ADB state = even for first data byte */
441 via[B] = (via[B] & ~ST_MASK) | ST_EVEN;
443 reply_buf[0] = first_byte; /* was command_byte?? */
444 reply_ptr = reply_buf + 1;
449 macii_state = reading;
453 /* handshake etc. for II ?? */
456 /* set ADB state = even for first data byte */
457 via[B] = (via[B] & ~ST_MASK) | ST_EVEN;
459 current_req->reply[0] = first_byte;
460 reply_ptr = current_req->reply + 1;
465 macii_state = reading;
470 if (data_index >= req->nbytes) {
471 /* print an error message if a listen command has no data */
472 if (((command_byte & 0x0C) == 0x08)
473 /* && (console_loglevel == 10) */
474 && (data_index == 2))
475 printk("MacII ADB: listen command with no data: %x!\n",
477 /* reset to shift in */
480 /* set ADB state idle - might get SRQ */
481 via[B] = (via[B] & ~ST_MASK) | ST_IDLE;
485 if (req->reply_expected) {
486 macii_state = awaiting_reply;
489 current_req = req->next;
490 if (req->done) (*req->done)(req);
492 if (current_req || retry_req)
495 macii_retransmit((command_byte & 0xF0) >> 4);
498 via[SR] = req->data[data_index++];
500 if ( (via[B] & ST_MASK) == ST_CMD ) {
501 /* just sent the command byte, set to EVEN */
502 via[B] = (via[B] & ~ST_MASK) | ST_EVEN;
504 /* invert state bits, toggle ODD/EVEN */
512 /* timeout / SRQ handling for II hw */
513 if( (first_byte == 0xFF && (reply_len-prefix_len)==2
514 && memcmp(reply_ptr-2,"\xFF\xFF",2)==0) ||
515 ((reply_len-prefix_len)==3
516 && memcmp(reply_ptr-3,"\xFF\xFF\xFF",3)==0))
519 * possible timeout (in fact, most probably a
520 * timeout, since SRQ can't be signaled without
521 * transfer on the bus).
522 * The last three bytes seen were FF, together
523 * with the starting byte (in case we started
524 * on 'idle' or 'awaiting_reply') this probably
525 * makes four. So this is mostl likely #5!
526 * The timeout signal is a pattern 1 0 1 0 0..
527 * on /INT, meaning we missed it :-(
530 if (x != 0xFF) printk("MacII ADB: mistaken timeout/SRQ!\n");
532 if ((status & TREQ) == (last_status & TREQ)) {
533 /* Not a timeout. Unsolicited SRQ? weird. */
534 /* Terminate the SRQ packet and poll */
537 /* There's no packet to get, so reply is blank */
539 reply_ptr -= (reply_len-prefix_len);
540 reply_len = prefix_len;
541 macii_state = read_done;
543 } /* end timeout / SRQ handling for II hw. */
545 if((reply_len-prefix_len)>3
546 && memcmp(reply_ptr-3,"\xFF\xFF\xFF",3)==0)
548 /* SRQ tacked on data packet */
549 /* Terminate the packet (SRQ never ends) */
551 macii_state = read_done;
555 /* need to continue; next byte not seen else */
558 if (reply_len > 15) reply_len = 0;
565 /* The usual handshake ... */
568 * NetBSD hints that the next to last byte
569 * is sent with IRQ !!
570 * Guido found out it's the last one (0x0),
571 * but IRQ should be asserted already.
572 * Problem with timeout detection: First
573 * transition to /IRQ might be second
574 * byte of timeout packet!
575 * Timeouts are signaled by 4x FF.
577 if (((status & TREQ) == 0) && (x == 0x00)) { /* != 0xFF */
578 /* invert state bits, toggle ODD/EVEN */
581 /* adjust packet length */
584 macii_state = read_done;
586 /* not caught: ST_CMD */
587 /* required for re-entry 'reading'! */
588 if ((status & ST_MASK) == ST_IDLE) {
589 /* (in)sanity check - set even */
590 via[B] = (via[B] & ~ST_MASK) | ST_EVEN;
592 /* invert state bits */
602 req->reply_len = reply_ptr - req->reply;
604 current_req = req->next;
605 if (req->done) (*req->done)(req);
607 adb_input(reply_buf, reply_ptr - reply_buf,
612 * remember this device ID; it's the latest we got a
615 last_reply = command_byte;
616 last_active = (command_byte & 0xF0) >> 4;
618 /* SRQ seen before, initiate poll now */
626 /* set ADB state to idle */
627 via[B] = (via[B] & ~ST_MASK) | ST_IDLE;
629 /* /IRQ seen, so the ADB controller has data for us */
630 if ((via[B] & TREQ) != 0) {
631 macii_state = reading;
633 reply_buf[0] = command_byte;
634 reply_ptr = reply_buf + 1;
639 /* no IRQ, send next packet or wait */
644 macii_retransmit(last_active);
651 /* reset mutex and interrupts */
653 restore_flags(flags);