]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
1da177e4 LT |
2 | /* |
3 | * Device driver for the via ADB on (many) Mac II-class machines | |
4 | * | |
5 | * Based on the original ADB keyboard handler Copyright (c) 1997 Alan Cox | |
6 | * Also derived from code Copyright (C) 1996 Paul Mackerras. | |
7 | * | |
8 | * With various updates provided over the years by Michael Schmitz, | |
9 | * Guideo Koerber and others. | |
10 | * | |
11 | * Rewrite for Unified ADB by Joshua M. Thompson (funaho@jurai.org) | |
12 | * | |
13 | * 1999-08-02 (jmt) - Initial rewrite for Unified ADB. | |
14 | * 2000-03-29 Tony Mantler <tonym@mac.linux-m68k.org> | |
47fd2060 | 15 | * - Big overhaul, should actually work now. |
d0c2c269 | 16 | * 2006-12-31 Finn Thain - Another overhaul. |
d95fd5fc FT |
17 | * |
18 | * Suggested reading: | |
19 | * Inside Macintosh, ch. 5 ADB Manager | |
20 | * Guide to the Macinstosh Family Hardware, ch. 8 Apple Desktop Bus | |
21 | * Rockwell R6522 VIA datasheet | |
22 | * | |
23 | * Apple's "ADB Analyzer" bus sniffer is invaluable: | |
24 | * ftp://ftp.apple.com/developer/Tool_Chest/Devices_-_Hardware/Apple_Desktop_Bus/ | |
1da177e4 | 25 | */ |
47fd2060 | 26 | |
1da177e4 LT |
27 | #include <stdarg.h> |
28 | #include <linux/types.h> | |
29 | #include <linux/errno.h> | |
30 | #include <linux/kernel.h> | |
31 | #include <linux/delay.h> | |
1da177e4 LT |
32 | #include <linux/adb.h> |
33 | #include <linux/interrupt.h> | |
34 | #include <linux/init.h> | |
35 | #include <asm/macintosh.h> | |
36 | #include <asm/macints.h> | |
1da177e4 | 37 | #include <asm/mac_via.h> |
1da177e4 LT |
38 | |
39 | static volatile unsigned char *via; | |
40 | ||
41 | /* VIA registers - spaced 0x200 bytes apart */ | |
42 | #define RS 0x200 /* skip between registers */ | |
43 | #define B 0 /* B-side data */ | |
44 | #define A RS /* A-side data */ | |
45 | #define DIRB (2*RS) /* B-side direction (1=output) */ | |
46 | #define DIRA (3*RS) /* A-side direction (1=output) */ | |
47 | #define T1CL (4*RS) /* Timer 1 ctr/latch (low 8 bits) */ | |
48 | #define T1CH (5*RS) /* Timer 1 counter (high 8 bits) */ | |
49 | #define T1LL (6*RS) /* Timer 1 latch (low 8 bits) */ | |
50 | #define T1LH (7*RS) /* Timer 1 latch (high 8 bits) */ | |
51 | #define T2CL (8*RS) /* Timer 2 ctr/latch (low 8 bits) */ | |
52 | #define T2CH (9*RS) /* Timer 2 counter (high 8 bits) */ | |
53 | #define SR (10*RS) /* Shift register */ | |
54 | #define ACR (11*RS) /* Auxiliary control register */ | |
55 | #define PCR (12*RS) /* Peripheral control register */ | |
56 | #define IFR (13*RS) /* Interrupt flag register */ | |
57 | #define IER (14*RS) /* Interrupt enable register */ | |
58 | #define ANH (15*RS) /* A-side data, no handshake */ | |
59 | ||
60 | /* Bits in B data register: all active low */ | |
d95fd5fc | 61 | #define CTLR_IRQ 0x08 /* Controller rcv status (input) */ |
1da177e4 LT |
62 | #define ST_MASK 0x30 /* mask for selecting ADB state bits */ |
63 | ||
64 | /* Bits in ACR */ | |
65 | #define SR_CTRL 0x1c /* Shift register control bits */ | |
66 | #define SR_EXT 0x0c /* Shift on external clock */ | |
67 | #define SR_OUT 0x10 /* Shift out if 1 */ | |
68 | ||
69 | /* Bits in IFR and IER */ | |
70 | #define IER_SET 0x80 /* set bits in IER */ | |
71 | #define IER_CLR 0 /* clear bits in IER */ | |
72 | #define SR_INT 0x04 /* Shift register full/empty */ | |
1da177e4 LT |
73 | |
74 | /* ADB transaction states according to GMHW */ | |
75 | #define ST_CMD 0x00 /* ADB state: command byte */ | |
76 | #define ST_EVEN 0x10 /* ADB state: even data byte */ | |
77 | #define ST_ODD 0x20 /* ADB state: odd data byte */ | |
78 | #define ST_IDLE 0x30 /* ADB state: idle, nothing to send */ | |
79 | ||
f93bfeb5 FT |
80 | /* ADB command byte structure */ |
81 | #define ADDR_MASK 0xF0 | |
82 | #define CMD_MASK 0x0F | |
b4d76c28 FT |
83 | #define OP_MASK 0x0C |
84 | #define TALK 0x0C | |
f93bfeb5 | 85 | |
47fd2060 | 86 | static int macii_init_via(void); |
1da177e4 | 87 | static void macii_start(void); |
7d12e780 | 88 | static irqreturn_t macii_interrupt(int irq, void *arg); |
1da177e4 LT |
89 | static void macii_queue_poll(void); |
90 | ||
91 | static int macii_probe(void); | |
92 | static int macii_init(void); | |
93 | static int macii_send_request(struct adb_request *req, int sync); | |
94 | static int macii_write(struct adb_request *req); | |
95 | static int macii_autopoll(int devs); | |
96 | static void macii_poll(void); | |
97 | static int macii_reset_bus(void); | |
98 | ||
99 | struct adb_driver via_macii_driver = { | |
3a52f6f9 FT |
100 | .name = "Mac II", |
101 | .probe = macii_probe, | |
102 | .init = macii_init, | |
103 | .send_request = macii_send_request, | |
104 | .autopoll = macii_autopoll, | |
105 | .poll = macii_poll, | |
106 | .reset_bus = macii_reset_bus, | |
1da177e4 LT |
107 | }; |
108 | ||
109 | static enum macii_state { | |
110 | idle, | |
111 | sending, | |
112 | reading, | |
1da177e4 LT |
113 | } macii_state; |
114 | ||
d95fd5fc FT |
115 | static struct adb_request *current_req; /* first request struct in the queue */ |
116 | static struct adb_request *last_req; /* last request struct in the queue */ | |
117 | static unsigned char reply_buf[16]; /* storage for autopolled replies */ | |
eb4da4ce | 118 | static unsigned char *reply_ptr; /* next byte in reply_buf or req->reply */ |
f87a1625 | 119 | static bool reading_reply; /* store reply in reply_buf else req->reply */ |
d95fd5fc FT |
120 | static int data_index; /* index of the next byte to send from req->data */ |
121 | static int reply_len; /* number of bytes received in reply_buf or req->reply */ | |
122 | static int status; /* VIA's ADB status bits captured upon interrupt */ | |
b4d76c28 FT |
123 | static bool bus_timeout; /* no data was sent by the device */ |
124 | static bool srq_asserted; /* have to poll for the device that asserted it */ | |
f93bfeb5 | 125 | static u8 last_cmd; /* the most recent command byte transmitted */ |
b4d76c28 | 126 | static u8 last_talk_cmd; /* the most recent Talk command byte transmitted */ |
f93bfeb5 | 127 | static u8 last_poll_cmd; /* the most recent Talk R0 command byte transmitted */ |
5c0c15a1 | 128 | static unsigned int autopoll_devs; /* bits set are device addresses to poll */ |
d95fd5fc | 129 | |
1da177e4 LT |
130 | /* Check for MacII style ADB */ |
131 | static int macii_probe(void) | |
132 | { | |
47fd2060 FT |
133 | if (macintosh_config->adb_type != MAC_ADB_II) |
134 | return -ENODEV; | |
1da177e4 LT |
135 | |
136 | via = via1; | |
137 | ||
351e5ad3 | 138 | pr_info("adb: Mac II ADB Driver v1.0 for Unified ADB\n"); |
1da177e4 LT |
139 | return 0; |
140 | } | |
141 | ||
142 | /* Initialize the driver */ | |
3327e58a | 143 | static int macii_init(void) |
1da177e4 LT |
144 | { |
145 | unsigned long flags; | |
146 | int err; | |
47fd2060 | 147 | |
1da177e4 | 148 | local_irq_save(flags); |
47fd2060 | 149 | |
1da177e4 | 150 | err = macii_init_via(); |
47fd2060 FT |
151 | if (err) |
152 | goto out; | |
1da177e4 | 153 | |
5a239453 | 154 | err = request_irq(IRQ_MAC_ADB, macii_interrupt, 0, "ADB", |
1da177e4 | 155 | macii_interrupt); |
47fd2060 FT |
156 | if (err) |
157 | goto out; | |
1da177e4 LT |
158 | |
159 | macii_state = idle; | |
d95fd5fc | 160 | out: |
1da177e4 | 161 | local_irq_restore(flags); |
d95fd5fc | 162 | return err; |
1da177e4 LT |
163 | } |
164 | ||
47fd2060 | 165 | /* initialize the hardware */ |
1da177e4 LT |
166 | static int macii_init_via(void) |
167 | { | |
168 | unsigned char x; | |
169 | ||
d95fd5fc FT |
170 | /* We want CTLR_IRQ as input and ST_EVEN | ST_ODD as output lines. */ |
171 | via[DIRB] = (via[DIRB] | ST_EVEN | ST_ODD) & ~CTLR_IRQ; | |
1da177e4 LT |
172 | |
173 | /* Set up state: idle */ | |
174 | via[B] |= ST_IDLE; | |
1da177e4 LT |
175 | |
176 | /* Shift register on input */ | |
177 | via[ACR] = (via[ACR] & ~SR_CTRL) | SR_EXT; | |
178 | ||
179 | /* Wipe any pending data and int */ | |
180 | x = via[SR]; | |
181 | ||
182 | return 0; | |
183 | } | |
184 | ||
d95fd5fc | 185 | /* Send an ADB poll (Talk Register 0 command prepended to the request queue) */ |
1da177e4 LT |
186 | static void macii_queue_poll(void) |
187 | { | |
1da177e4 | 188 | static struct adb_request req; |
f93bfeb5 FT |
189 | unsigned char poll_command; |
190 | unsigned int poll_addr; | |
1da177e4 | 191 | |
f93bfeb5 FT |
192 | /* This only polls devices in the autopoll list, which assumes that |
193 | * unprobed devices never assert SRQ. That could happen if a device was | |
194 | * plugged in after the adb bus scan. Unplugging it again will resolve | |
195 | * the problem. This behaviour is similar to MacOS. | |
196 | */ | |
47fd2060 FT |
197 | if (!autopoll_devs) |
198 | return; | |
1da177e4 | 199 | |
f93bfeb5 FT |
200 | /* The device most recently polled may not be the best device to poll |
201 | * right now. Some other device(s) may have signalled SRQ (the active | |
202 | * device won't do that). Or the autopoll list may have been changed. | |
203 | * Try polling the next higher address. | |
204 | */ | |
205 | poll_addr = (last_poll_cmd & ADDR_MASK) >> 4; | |
206 | if ((srq_asserted && last_cmd == last_poll_cmd) || | |
207 | !(autopoll_devs & (1 << poll_addr))) { | |
208 | unsigned int higher_devs; | |
209 | ||
210 | higher_devs = autopoll_devs & -(1 << (poll_addr + 1)); | |
211 | poll_addr = ffs(higher_devs ? higher_devs : autopoll_devs) - 1; | |
212 | } | |
1da177e4 | 213 | |
f93bfeb5 FT |
214 | /* Send a Talk Register 0 command */ |
215 | poll_command = ADB_READREG(poll_addr, 0); | |
216 | ||
217 | /* No need to repeat this Talk command. The transceiver will do that | |
218 | * as long as it is idle. | |
219 | */ | |
220 | if (poll_command == last_cmd) | |
221 | return; | |
222 | ||
223 | adb_request(&req, NULL, ADBREQ_NOSEND, 1, poll_command); | |
1da177e4 | 224 | |
d95fd5fc FT |
225 | req.sent = 0; |
226 | req.complete = 0; | |
227 | req.reply_len = 0; | |
228 | req.next = current_req; | |
1da177e4 | 229 | |
f93bfeb5 | 230 | if (WARN_ON(current_req)) { |
d95fd5fc | 231 | current_req = &req; |
1da177e4 | 232 | } else { |
d95fd5fc FT |
233 | current_req = &req; |
234 | last_req = &req; | |
1da177e4 | 235 | } |
1da177e4 LT |
236 | } |
237 | ||
238 | /* Send an ADB request; if sync, poll out the reply 'till it's done */ | |
239 | static int macii_send_request(struct adb_request *req, int sync) | |
240 | { | |
d95fd5fc | 241 | int err; |
1da177e4 | 242 | |
d95fd5fc | 243 | err = macii_write(req); |
5ce6185c FT |
244 | if (err) |
245 | return err; | |
d95fd5fc | 246 | |
5ce6185c | 247 | if (sync) |
5f93d708 | 248 | while (!req->complete) |
d95fd5fc | 249 | macii_poll(); |
d95fd5fc | 250 | |
5ce6185c | 251 | return 0; |
1da177e4 LT |
252 | } |
253 | ||
d95fd5fc | 254 | /* Send an ADB request (append to request queue) */ |
1da177e4 LT |
255 | static int macii_write(struct adb_request *req) |
256 | { | |
5ce6185c FT |
257 | unsigned long flags; |
258 | ||
1da177e4 LT |
259 | if (req->nbytes < 2 || req->data[0] != ADB_PACKET || req->nbytes > 15) { |
260 | req->complete = 1; | |
261 | return -EINVAL; | |
262 | } | |
47fd2060 | 263 | |
a5d361fc | 264 | req->next = NULL; |
1da177e4 LT |
265 | req->sent = 0; |
266 | req->complete = 0; | |
267 | req->reply_len = 0; | |
268 | ||
5ce6185c FT |
269 | local_irq_save(flags); |
270 | ||
1da177e4 LT |
271 | if (current_req != NULL) { |
272 | last_req->next = req; | |
273 | last_req = req; | |
274 | } else { | |
275 | current_req = req; | |
276 | last_req = req; | |
47fd2060 FT |
277 | if (macii_state == idle) |
278 | macii_start(); | |
1da177e4 | 279 | } |
5ce6185c FT |
280 | |
281 | local_irq_restore(flags); | |
282 | ||
1da177e4 LT |
283 | return 0; |
284 | } | |
285 | ||
286 | /* Start auto-polling */ | |
287 | static int macii_autopoll(int devs) | |
288 | { | |
d95fd5fc | 289 | unsigned long flags; |
d95fd5fc | 290 | |
59ea38f6 FT |
291 | local_irq_save(flags); |
292 | ||
d95fd5fc | 293 | /* bit 1 == device 1, and so on. */ |
5c0c15a1 | 294 | autopoll_devs = (unsigned int)devs & 0xFFFE; |
d95fd5fc | 295 | |
f93bfeb5 FT |
296 | if (!current_req) { |
297 | macii_queue_poll(); | |
298 | if (current_req && macii_state == idle) | |
299 | macii_start(); | |
d95fd5fc FT |
300 | } |
301 | ||
302 | local_irq_restore(flags); | |
d95fd5fc | 303 | |
f93bfeb5 | 304 | return 0; |
1da177e4 LT |
305 | } |
306 | ||
307 | /* Prod the chip without interrupts */ | |
308 | static void macii_poll(void) | |
309 | { | |
d95fd5fc | 310 | macii_interrupt(0, NULL); |
1da177e4 LT |
311 | } |
312 | ||
313 | /* Reset the bus */ | |
314 | static int macii_reset_bus(void) | |
315 | { | |
046ace82 | 316 | struct adb_request req; |
47fd2060 | 317 | |
1da177e4 | 318 | /* Command = 0, Address = ignored */ |
b52dce87 FT |
319 | adb_request(&req, NULL, ADBREQ_NOSEND, 1, ADB_BUSRESET); |
320 | macii_send_request(&req, 1); | |
1da177e4 | 321 | |
d95fd5fc FT |
322 | /* Don't want any more requests during the Global Reset low time. */ |
323 | udelay(3000); | |
324 | ||
1da177e4 LT |
325 | return 0; |
326 | } | |
327 | ||
328 | /* Start sending ADB packet */ | |
329 | static void macii_start(void) | |
330 | { | |
1da177e4 LT |
331 | struct adb_request *req; |
332 | ||
333 | req = current_req; | |
1da177e4 | 334 | |
d95fd5fc FT |
335 | /* Now send it. Be careful though, that first byte of the request |
336 | * is actually ADB_PACKET; the real data begins at index 1! | |
337 | * And req->nbytes is the number of bytes of real data plus one. | |
1da177e4 | 338 | */ |
1da177e4 | 339 | |
1da177e4 LT |
340 | /* Output mode */ |
341 | via[ACR] |= SR_OUT; | |
342 | /* Load data */ | |
343 | via[SR] = req->data[1]; | |
344 | /* set ADB state to 'command' */ | |
345 | via[B] = (via[B] & ~ST_MASK) | ST_CMD; | |
346 | ||
347 | macii_state = sending; | |
348 | data_index = 2; | |
b4d76c28 FT |
349 | |
350 | bus_timeout = false; | |
351 | srq_asserted = false; | |
1da177e4 LT |
352 | } |
353 | ||
354 | /* | |
d95fd5fc FT |
355 | * The notorious ADB interrupt handler - does all of the protocol handling. |
356 | * Relies on the ADB controller sending and receiving data, thereby | |
357 | * generating shift register interrupts (SR_INT) for us. This means there has | |
358 | * to be activity on the ADB bus. The chip will poll to achieve this. | |
1da177e4 | 359 | * |
b4d76c28 FT |
360 | * The VIA Port B output signalling works as follows. After the ADB transceiver |
361 | * sees a transition on the PB4 and PB5 lines it will crank over the VIA shift | |
362 | * register which eventually raises the SR_INT interrupt. The PB4/PB5 outputs | |
363 | * are toggled with each byte as the ADB transaction progresses. | |
364 | * | |
365 | * Request with no reply expected (and empty transceiver buffer): | |
366 | * CMD -> IDLE | |
367 | * Request with expected reply packet (or with buffered autopoll packet): | |
368 | * CMD -> EVEN -> ODD -> EVEN -> ... -> IDLE | |
369 | * Unsolicited packet: | |
370 | * IDLE -> EVEN -> ODD -> EVEN -> ... -> IDLE | |
1da177e4 | 371 | */ |
7d12e780 | 372 | static irqreturn_t macii_interrupt(int irq, void *arg) |
1da177e4 | 373 | { |
d95fd5fc | 374 | int x; |
1da177e4 | 375 | struct adb_request *req; |
5ce6185c FT |
376 | unsigned long flags; |
377 | ||
378 | local_irq_save(flags); | |
1da177e4 | 379 | |
d95fd5fc FT |
380 | if (!arg) { |
381 | /* Clear the SR IRQ flag when polling. */ | |
382 | if (via[IFR] & SR_INT) | |
383 | via[IFR] = SR_INT; | |
5ce6185c FT |
384 | else { |
385 | local_irq_restore(flags); | |
d95fd5fc | 386 | return IRQ_NONE; |
5ce6185c | 387 | } |
1da177e4 LT |
388 | } |
389 | ||
47fd2060 | 390 | status = via[B] & (ST_MASK | CTLR_IRQ); |
1da177e4 LT |
391 | |
392 | switch (macii_state) { | |
47fd2060 | 393 | case idle: |
b4d76c28 FT |
394 | WARN_ON((status & ST_MASK) != ST_IDLE); |
395 | ||
396 | reply_ptr = reply_buf; | |
f87a1625 | 397 | reading_reply = false; |
b4d76c28 FT |
398 | |
399 | bus_timeout = false; | |
400 | srq_asserted = false; | |
d95fd5fc | 401 | |
47fd2060 | 402 | x = via[SR]; |
1da177e4 | 403 | |
b4d76c28 FT |
404 | if (!(status & CTLR_IRQ)) { |
405 | /* /CTLR_IRQ asserted in idle state means we must | |
406 | * read an autopoll reply from the transceiver buffer. | |
47fd2060 | 407 | */ |
47fd2060 FT |
408 | macii_state = reading; |
409 | *reply_ptr = x; | |
410 | reply_len = 1; | |
b4d76c28 FT |
411 | } else { |
412 | /* bus timeout */ | |
b4d76c28 | 413 | reply_len = 0; |
b16b6768 | 414 | break; |
47fd2060 | 415 | } |
1da177e4 | 416 | |
47fd2060 FT |
417 | /* set ADB state = even for first data byte */ |
418 | via[B] = (via[B] & ~ST_MASK) | ST_EVEN; | |
419 | break; | |
1da177e4 | 420 | |
47fd2060 FT |
421 | case sending: |
422 | req = current_req; | |
b4d76c28 FT |
423 | |
424 | if (status == (ST_CMD | CTLR_IRQ)) { | |
425 | /* /CTLR_IRQ de-asserted after the command byte means | |
426 | * the host can continue with the transaction. | |
427 | */ | |
428 | ||
429 | /* Store command byte */ | |
430 | last_cmd = req->data[1]; | |
431 | if ((last_cmd & OP_MASK) == TALK) { | |
432 | last_talk_cmd = last_cmd; | |
433 | if ((last_cmd & CMD_MASK) == ADB_READREG(0, 0)) | |
434 | last_poll_cmd = last_cmd; | |
435 | } | |
436 | } | |
437 | ||
438 | if (status == ST_CMD) { | |
439 | /* /CTLR_IRQ asserted after the command byte means we | |
440 | * must read an autopoll reply. The first byte was | |
441 | * lost because the shift register was an output. | |
442 | */ | |
443 | macii_state = reading; | |
444 | ||
f87a1625 | 445 | reading_reply = false; |
b4d76c28 FT |
446 | reply_ptr = reply_buf; |
447 | *reply_ptr = last_talk_cmd; | |
448 | reply_len = 1; | |
449 | ||
450 | /* reset to shift in */ | |
451 | via[ACR] &= ~SR_OUT; | |
452 | x = via[SR]; | |
453 | } else if (data_index >= req->nbytes) { | |
47fd2060 | 454 | req->sent = 1; |
d95fd5fc | 455 | |
47fd2060 | 456 | if (req->reply_expected) { |
b4d76c28 FT |
457 | macii_state = reading; |
458 | ||
f87a1625 | 459 | reading_reply = true; |
b4d76c28 FT |
460 | reply_ptr = req->reply; |
461 | *reply_ptr = req->data[1]; | |
462 | reply_len = 1; | |
463 | ||
464 | via[ACR] &= ~SR_OUT; | |
465 | x = via[SR]; | |
624cf5b5 FT |
466 | } else if ((req->data[1] & OP_MASK) == TALK) { |
467 | macii_state = reading; | |
468 | ||
f87a1625 | 469 | reading_reply = false; |
624cf5b5 FT |
470 | reply_ptr = reply_buf; |
471 | *reply_ptr = req->data[1]; | |
472 | reply_len = 1; | |
473 | ||
474 | via[ACR] &= ~SR_OUT; | |
475 | x = via[SR]; | |
476 | ||
477 | req->complete = 1; | |
478 | current_req = req->next; | |
479 | if (req->done) | |
480 | (*req->done)(req); | |
1da177e4 | 481 | } else { |
b4d76c28 FT |
482 | macii_state = idle; |
483 | ||
47fd2060 FT |
484 | req->complete = 1; |
485 | current_req = req->next; | |
486 | if (req->done) | |
487 | (*req->done)(req); | |
b4d76c28 | 488 | break; |
1da177e4 | 489 | } |
47fd2060 FT |
490 | } else { |
491 | via[SR] = req->data[data_index++]; | |
b4d76c28 | 492 | } |
1da177e4 | 493 | |
b4d76c28 FT |
494 | if ((via[B] & ST_MASK) == ST_CMD) { |
495 | /* just sent the command byte, set to EVEN */ | |
496 | via[B] = (via[B] & ~ST_MASK) | ST_EVEN; | |
497 | } else { | |
498 | /* invert state bits, toggle ODD/EVEN */ | |
499 | via[B] ^= ST_MASK; | |
47fd2060 FT |
500 | } |
501 | break; | |
1da177e4 | 502 | |
47fd2060 FT |
503 | case reading: |
504 | x = via[SR]; | |
505 | WARN_ON((status & ST_MASK) == ST_CMD || | |
506 | (status & ST_MASK) == ST_IDLE); | |
507 | ||
47fd2060 | 508 | if (!(status & CTLR_IRQ)) { |
b4d76c28 FT |
509 | if (status == ST_EVEN && reply_len == 1) { |
510 | bus_timeout = true; | |
511 | } else if (status == ST_ODD && reply_len == 2) { | |
512 | srq_asserted = true; | |
513 | } else { | |
b16b6768 FT |
514 | macii_state = idle; |
515 | ||
516 | if (bus_timeout) | |
517 | reply_len = 0; | |
518 | ||
519 | if (reading_reply) { | |
520 | struct adb_request *req = current_req; | |
521 | ||
522 | req->reply_len = reply_len; | |
523 | ||
524 | req->complete = 1; | |
525 | current_req = req->next; | |
526 | if (req->done) | |
527 | (*req->done)(req); | |
624cf5b5 FT |
528 | } else if (reply_len && autopoll_devs && |
529 | reply_buf[0] == last_poll_cmd) { | |
530 | adb_input(reply_buf, reply_len, 1); | |
b16b6768 FT |
531 | } |
532 | break; | |
47fd2060 FT |
533 | } |
534 | } | |
1da177e4 | 535 | |
b16b6768 | 536 | if (reply_len < ARRAY_SIZE(reply_buf)) { |
47fd2060 FT |
537 | reply_ptr++; |
538 | *reply_ptr = x; | |
539 | reply_len++; | |
540 | } | |
1da177e4 | 541 | |
47fd2060 FT |
542 | /* invert state bits, toggle ODD/EVEN */ |
543 | via[B] ^= ST_MASK; | |
544 | break; | |
1da177e4 | 545 | |
b16b6768 FT |
546 | default: |
547 | break; | |
548 | } | |
47fd2060 | 549 | |
b16b6768 | 550 | if (macii_state == idle) { |
f93bfeb5 | 551 | if (!current_req) |
47fd2060 FT |
552 | macii_queue_poll(); |
553 | ||
554 | if (current_req) | |
555 | macii_start(); | |
47fd2060 | 556 | |
b16b6768 FT |
557 | if (macii_state == idle) { |
558 | via[ACR] &= ~SR_OUT; | |
559 | x = via[SR]; | |
47fd2060 | 560 | via[B] = (via[B] & ~ST_MASK) | ST_IDLE; |
b16b6768 | 561 | } |
1da177e4 | 562 | } |
d95fd5fc | 563 | |
5ce6185c | 564 | local_irq_restore(flags); |
1da177e4 LT |
565 | return IRQ_HANDLED; |
566 | } |