Blame view
drivers/macintosh/via-macii.c
14.1 KB
1da177e4c Linux-2.6.12-rc2 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
/* * Device driver for the via ADB on (many) Mac II-class machines * * Based on the original ADB keyboard handler Copyright (c) 1997 Alan Cox * Also derived from code Copyright (C) 1996 Paul Mackerras. * * With various updates provided over the years by Michael Schmitz, * Guideo Koerber and others. * * Rewrite for Unified ADB by Joshua M. Thompson (funaho@jurai.org) * * 1999-08-02 (jmt) - Initial rewrite for Unified ADB. * 2000-03-29 Tony Mantler <tonym@mac.linux-m68k.org> * - Big overhaul, should actually work now. |
d95fd5fce m68k: Mac II ADB ... |
15 16 17 18 19 20 21 22 23 |
* 2006-12-31 Finn Thain <fthain@telegraphics.com.au> - Another overhaul. * * Suggested reading: * Inside Macintosh, ch. 5 ADB Manager * Guide to the Macinstosh Family Hardware, ch. 8 Apple Desktop Bus * Rockwell R6522 VIA datasheet * * Apple's "ADB Analyzer" bus sniffer is invaluable: * ftp://ftp.apple.com/developer/Tool_Chest/Devices_-_Hardware/Apple_Desktop_Bus/ |
1da177e4c Linux-2.6.12-rc2 |
24 25 26 27 28 29 30 |
*/ #include <stdarg.h> #include <linux/types.h> #include <linux/errno.h> #include <linux/kernel.h> #include <linux/delay.h> |
1da177e4c Linux-2.6.12-rc2 |
31 32 33 34 35 |
#include <linux/adb.h> #include <linux/interrupt.h> #include <linux/init.h> #include <asm/macintosh.h> #include <asm/macints.h> |
1da177e4c Linux-2.6.12-rc2 |
36 |
#include <asm/mac_via.h> |
1da177e4c Linux-2.6.12-rc2 |
37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 |
#include <asm/system.h> static volatile unsigned char *via; /* VIA registers - spaced 0x200 bytes apart */ #define RS 0x200 /* skip between registers */ #define B 0 /* B-side data */ #define A RS /* A-side data */ #define DIRB (2*RS) /* B-side direction (1=output) */ #define DIRA (3*RS) /* A-side direction (1=output) */ #define T1CL (4*RS) /* Timer 1 ctr/latch (low 8 bits) */ #define T1CH (5*RS) /* Timer 1 counter (high 8 bits) */ #define T1LL (6*RS) /* Timer 1 latch (low 8 bits) */ #define T1LH (7*RS) /* Timer 1 latch (high 8 bits) */ #define T2CL (8*RS) /* Timer 2 ctr/latch (low 8 bits) */ #define T2CH (9*RS) /* Timer 2 counter (high 8 bits) */ #define SR (10*RS) /* Shift register */ #define ACR (11*RS) /* Auxiliary control register */ #define PCR (12*RS) /* Peripheral control register */ #define IFR (13*RS) /* Interrupt flag register */ #define IER (14*RS) /* Interrupt enable register */ #define ANH (15*RS) /* A-side data, no handshake */ /* Bits in B data register: all active low */ |
d95fd5fce m68k: Mac II ADB ... |
61 |
#define CTLR_IRQ 0x08 /* Controller rcv status (input) */ |
1da177e4c Linux-2.6.12-rc2 |
62 63 64 65 66 67 68 69 70 71 72 |
#define ST_MASK 0x30 /* mask for selecting ADB state bits */ /* Bits in ACR */ #define SR_CTRL 0x1c /* Shift register control bits */ #define SR_EXT 0x0c /* Shift on external clock */ #define SR_OUT 0x10 /* Shift out if 1 */ /* Bits in IFR and IER */ #define IER_SET 0x80 /* set bits in IER */ #define IER_CLR 0 /* clear bits in IER */ #define SR_INT 0x04 /* Shift register full/empty */ |
1da177e4c Linux-2.6.12-rc2 |
73 74 75 76 77 78 79 80 81 |
/* ADB transaction states according to GMHW */ #define ST_CMD 0x00 /* ADB state: command byte */ #define ST_EVEN 0x10 /* ADB state: even data byte */ #define ST_ODD 0x20 /* ADB state: odd data byte */ #define ST_IDLE 0x30 /* ADB state: idle, nothing to send */ static int macii_init_via(void); static void macii_start(void); |
7d12e780e IRQ: Maintain reg... |
82 |
static irqreturn_t macii_interrupt(int irq, void *arg); |
1da177e4c Linux-2.6.12-rc2 |
83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 |
static void macii_queue_poll(void); static int macii_probe(void); static int macii_init(void); static int macii_send_request(struct adb_request *req, int sync); static int macii_write(struct adb_request *req); static int macii_autopoll(int devs); static void macii_poll(void); static int macii_reset_bus(void); struct adb_driver via_macii_driver = { "Mac II", macii_probe, macii_init, macii_send_request, macii_autopoll, macii_poll, macii_reset_bus }; static enum macii_state { idle, sending, reading, read_done, |
1da177e4c Linux-2.6.12-rc2 |
108 |
} macii_state; |
d95fd5fce m68k: Mac II ADB ... |
109 110 111 |
static struct adb_request *current_req; /* first request struct in the queue */ static struct adb_request *last_req; /* last request struct in the queue */ static unsigned char reply_buf[16]; /* storage for autopolled replies */ |
eb4da4cec mac68k: macii adb... |
112 |
static unsigned char *reply_ptr; /* next byte in reply_buf or req->reply */ |
d95fd5fce m68k: Mac II ADB ... |
113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 |
static int reading_reply; /* store reply in reply_buf else req->reply */ static int data_index; /* index of the next byte to send from req->data */ static int reply_len; /* number of bytes received in reply_buf or req->reply */ static int status; /* VIA's ADB status bits captured upon interrupt */ static int last_status; /* status bits as at previous interrupt */ static int srq_asserted; /* have to poll for the device that asserted it */ static int command_byte; /* the most recent command byte transmitted */ static int autopoll_devs; /* bits set are device addresses to be polled */ /* Sanity check for request queue. Doesn't check for cycles. */ static int request_is_queued(struct adb_request *req) { struct adb_request *cur; unsigned long flags; local_irq_save(flags); cur = current_req; while (cur) { if (cur == req) { local_irq_restore(flags); return 1; } cur = cur->next; } local_irq_restore(flags); return 0; } |
1da177e4c Linux-2.6.12-rc2 |
138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 |
/* Check for MacII style ADB */ static int macii_probe(void) { if (macintosh_config->adb_type != MAC_ADB_II) return -ENODEV; via = via1; printk("adb: Mac II ADB Driver v1.0 for Unified ADB "); return 0; } /* Initialize the driver */ int macii_init(void) { unsigned long flags; int err; local_irq_save(flags); err = macii_init_via(); |
d95fd5fce m68k: Mac II ADB ... |
160 |
if (err) goto out; |
1da177e4c Linux-2.6.12-rc2 |
161 |
|
5a2394534 m68k/irq: Remove ... |
162 |
err = request_irq(IRQ_MAC_ADB, macii_interrupt, 0, "ADB", |
1da177e4c Linux-2.6.12-rc2 |
163 |
macii_interrupt); |
d95fd5fce m68k: Mac II ADB ... |
164 |
if (err) goto out; |
1da177e4c Linux-2.6.12-rc2 |
165 166 |
macii_state = idle; |
d95fd5fce m68k: Mac II ADB ... |
167 |
out: |
1da177e4c Linux-2.6.12-rc2 |
168 |
local_irq_restore(flags); |
d95fd5fce m68k: Mac II ADB ... |
169 |
return err; |
1da177e4c Linux-2.6.12-rc2 |
170 171 172 173 174 175 |
} /* initialize the hardware */ static int macii_init_via(void) { unsigned char x; |
d95fd5fce m68k: Mac II ADB ... |
176 177 |
/* We want CTLR_IRQ as input and ST_EVEN | ST_ODD as output lines. */ via[DIRB] = (via[DIRB] | ST_EVEN | ST_ODD) & ~CTLR_IRQ; |
1da177e4c Linux-2.6.12-rc2 |
178 179 180 |
/* Set up state: idle */ via[B] |= ST_IDLE; |
d95fd5fce m68k: Mac II ADB ... |
181 |
last_status = via[B] & (ST_MASK|CTLR_IRQ); |
1da177e4c Linux-2.6.12-rc2 |
182 183 184 185 186 187 188 189 190 |
/* Shift register on input */ via[ACR] = (via[ACR] & ~SR_CTRL) | SR_EXT; /* Wipe any pending data and int */ x = via[SR]; return 0; } |
d95fd5fce m68k: Mac II ADB ... |
191 |
/* Send an ADB poll (Talk Register 0 command prepended to the request queue) */ |
1da177e4c Linux-2.6.12-rc2 |
192 193 |
static void macii_queue_poll(void) { |
d95fd5fce m68k: Mac II ADB ... |
194 195 196 197 198 199 200 201 202 203 |
/* No point polling the active device as it will never assert SRQ, so * poll the next device in the autopoll list. This could leave us * stuck in a polling loop if an unprobed device is asserting SRQ. * In theory, that could only happen if a device was plugged in after * probing started. Unplugging it again will break the cycle. * (Simply polling the next higher device often ends up polling almost * every device (after wrapping around), which takes too long.) */ int device_mask; int next_device; |
1da177e4c Linux-2.6.12-rc2 |
204 |
static struct adb_request req; |
1da177e4c Linux-2.6.12-rc2 |
205 |
|
d95fd5fce m68k: Mac II ADB ... |
206 |
if (!autopoll_devs) return; |
1da177e4c Linux-2.6.12-rc2 |
207 |
|
d95fd5fce m68k: Mac II ADB ... |
208 209 210 211 212 |
device_mask = (1 << (((command_byte & 0xF0) >> 4) + 1)) - 1; if (autopoll_devs & ~device_mask) next_device = ffs(autopoll_devs & ~device_mask) - 1; else next_device = ffs(autopoll_devs) - 1; |
1da177e4c Linux-2.6.12-rc2 |
213 |
|
d95fd5fce m68k: Mac II ADB ... |
214 |
BUG_ON(request_is_queued(&req)); |
1da177e4c Linux-2.6.12-rc2 |
215 |
|
d95fd5fce m68k: Mac II ADB ... |
216 217 |
adb_request(&req, NULL, ADBREQ_NOSEND, 1, ADB_READREG(next_device, 0)); |
1da177e4c Linux-2.6.12-rc2 |
218 |
|
d95fd5fce m68k: Mac II ADB ... |
219 220 221 222 |
req.sent = 0; req.complete = 0; req.reply_len = 0; req.next = current_req; |
1da177e4c Linux-2.6.12-rc2 |
223 224 |
if (current_req != NULL) { |
d95fd5fce m68k: Mac II ADB ... |
225 |
current_req = &req; |
1da177e4c Linux-2.6.12-rc2 |
226 |
} else { |
d95fd5fce m68k: Mac II ADB ... |
227 228 |
current_req = &req; last_req = &req; |
1da177e4c Linux-2.6.12-rc2 |
229 |
} |
1da177e4c Linux-2.6.12-rc2 |
230 231 232 233 234 |
} /* Send an ADB request; if sync, poll out the reply 'till it's done */ static int macii_send_request(struct adb_request *req, int sync) { |
d95fd5fce m68k: Mac II ADB ... |
235 236 |
int err; unsigned long flags; |
1da177e4c Linux-2.6.12-rc2 |
237 |
|
d95fd5fce m68k: Mac II ADB ... |
238 |
BUG_ON(request_is_queued(req)); |
1da177e4c Linux-2.6.12-rc2 |
239 |
|
d95fd5fce m68k: Mac II ADB ... |
240 241 242 243 244 245 246 247 248 |
local_irq_save(flags); err = macii_write(req); local_irq_restore(flags); if (!err && sync) { while (!req->complete) { macii_poll(); } BUG_ON(request_is_queued(req)); |
1da177e4c Linux-2.6.12-rc2 |
249 |
} |
d95fd5fce m68k: Mac II ADB ... |
250 251 |
return err; |
1da177e4c Linux-2.6.12-rc2 |
252 |
} |
d95fd5fce m68k: Mac II ADB ... |
253 |
/* Send an ADB request (append to request queue) */ |
1da177e4c Linux-2.6.12-rc2 |
254 255 |
static int macii_write(struct adb_request *req) { |
1da177e4c Linux-2.6.12-rc2 |
256 257 258 259 260 |
if (req->nbytes < 2 || req->data[0] != ADB_PACKET || req->nbytes > 15) { req->complete = 1; return -EINVAL; } |
a5d361fc2 [PATCH] m68k: NUL... |
261 |
req->next = NULL; |
1da177e4c Linux-2.6.12-rc2 |
262 263 264 |
req->sent = 0; req->complete = 0; req->reply_len = 0; |
1da177e4c Linux-2.6.12-rc2 |
265 266 267 268 269 270 271 272 |
if (current_req != NULL) { last_req->next = req; last_req = req; } else { current_req = req; last_req = req; if (macii_state == idle) macii_start(); } |
1da177e4c Linux-2.6.12-rc2 |
273 274 275 276 277 278 |
return 0; } /* Start auto-polling */ static int macii_autopoll(int devs) { |
d95fd5fce m68k: Mac II ADB ... |
279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 |
static struct adb_request req; unsigned long flags; int err = 0; /* bit 1 == device 1, and so on. */ autopoll_devs = devs & 0xFFFE; if (!autopoll_devs) return 0; local_irq_save(flags); if (current_req == NULL) { /* Send a Talk Reg 0. The controller will repeatedly transmit * this as long as it is idle. */ adb_request(&req, NULL, ADBREQ_NOSEND, 1, ADB_READREG(ffs(autopoll_devs) - 1, 0)); err = macii_write(&req); } local_irq_restore(flags); return err; } static inline int need_autopoll(void) { /* Was the last command Talk Reg 0 * and is the target on the autopoll list? */ if ((command_byte & 0x0F) == 0x0C && ((1 << ((command_byte & 0xF0) >> 4)) & autopoll_devs)) return 0; return 1; |
1da177e4c Linux-2.6.12-rc2 |
311 312 313 314 315 |
} /* Prod the chip without interrupts */ static void macii_poll(void) { |
d95fd5fce m68k: Mac II ADB ... |
316 317 318 |
disable_irq(IRQ_MAC_ADB); macii_interrupt(0, NULL); enable_irq(IRQ_MAC_ADB); |
1da177e4c Linux-2.6.12-rc2 |
319 320 321 322 323 324 325 |
} /* Reset the bus */ static int macii_reset_bus(void) { static struct adb_request req; |
d95fd5fce m68k: Mac II ADB ... |
326 327 |
if (request_is_queued(&req)) return 0; |
1da177e4c Linux-2.6.12-rc2 |
328 329 |
/* Command = 0, Address = ignored */ adb_request(&req, NULL, 0, 1, ADB_BUSRESET); |
d95fd5fce m68k: Mac II ADB ... |
330 331 |
/* Don't want any more requests during the Global Reset low time. */ udelay(3000); |
1da177e4c Linux-2.6.12-rc2 |
332 333 334 335 336 337 |
return 0; } /* Start sending ADB packet */ static void macii_start(void) { |
1da177e4c Linux-2.6.12-rc2 |
338 339 340 |
struct adb_request *req; req = current_req; |
1da177e4c Linux-2.6.12-rc2 |
341 |
|
d95fd5fce m68k: Mac II ADB ... |
342 343 344 345 346 347 348 |
BUG_ON(req == NULL); BUG_ON(macii_state != idle); /* Now send it. Be careful though, that first byte of the request * is actually ADB_PACKET; the real data begins at index 1! * And req->nbytes is the number of bytes of real data plus one. |
1da177e4c Linux-2.6.12-rc2 |
349 |
*/ |
1da177e4c Linux-2.6.12-rc2 |
350 |
|
1da177e4c Linux-2.6.12-rc2 |
351 352 353 354 355 356 357 358 359 360 361 |
/* store command byte */ command_byte = req->data[1]; /* Output mode */ via[ACR] |= SR_OUT; /* Load data */ via[SR] = req->data[1]; /* set ADB state to 'command' */ via[B] = (via[B] & ~ST_MASK) | ST_CMD; macii_state = sending; data_index = 2; |
1da177e4c Linux-2.6.12-rc2 |
362 363 364 |
} /* |
d95fd5fce m68k: Mac II ADB ... |
365 366 367 368 |
* The notorious ADB interrupt handler - does all of the protocol handling. * Relies on the ADB controller sending and receiving data, thereby * generating shift register interrupts (SR_INT) for us. This means there has * to be activity on the ADB bus. The chip will poll to achieve this. |
1da177e4c Linux-2.6.12-rc2 |
369 370 371 |
* * The basic ADB state machine was left unchanged from the original MacII code * by Alan Cox, which was based on the CUDA driver for PowerMac. |
d95fd5fce m68k: Mac II ADB ... |
372 373 374 375 376 377 378 |
* The syntax of the ADB status lines is totally different on MacII, * though. MacII uses the states Command -> Even -> Odd -> Even ->...-> Idle * for sending and Idle -> Even -> Odd -> Even ->...-> Idle for receiving. * Start and end of a receive packet are signalled by asserting /IRQ on the * interrupt line (/IRQ means the CTLR_IRQ bit in port B; not to be confused * with the VIA shift register interrupt. /IRQ never actually interrupts the * processor, it's just an ordinary input.) |
1da177e4c Linux-2.6.12-rc2 |
379 |
*/ |
7d12e780e IRQ: Maintain reg... |
380 |
static irqreturn_t macii_interrupt(int irq, void *arg) |
1da177e4c Linux-2.6.12-rc2 |
381 |
{ |
d95fd5fce m68k: Mac II ADB ... |
382 383 |
int x; static int entered; |
1da177e4c Linux-2.6.12-rc2 |
384 |
struct adb_request *req; |
d95fd5fce m68k: Mac II ADB ... |
385 386 387 388 389 390 |
if (!arg) { /* Clear the SR IRQ flag when polling. */ if (via[IFR] & SR_INT) via[IFR] = SR_INT; else return IRQ_NONE; |
1da177e4c Linux-2.6.12-rc2 |
391 |
} |
d95fd5fce m68k: Mac II ADB ... |
392 393 394 395 |
BUG_ON(entered++); last_status = status; status = via[B] & (ST_MASK|CTLR_IRQ); |
1da177e4c Linux-2.6.12-rc2 |
396 397 398 |
switch (macii_state) { case idle: |
d95fd5fce m68k: Mac II ADB ... |
399 400 401 402 403 404 |
if (reading_reply) { reply_ptr = current_req->reply; } else { BUG_ON(current_req != NULL); reply_ptr = reply_buf; } |
1da177e4c Linux-2.6.12-rc2 |
405 |
x = via[SR]; |
1da177e4c Linux-2.6.12-rc2 |
406 |
|
d95fd5fce m68k: Mac II ADB ... |
407 408 409 410 411 412 413 414 415 416 417 418 |
if ((status & CTLR_IRQ) && (x == 0xFF)) { /* Bus timeout without SRQ sequence: * data is "FF" while CTLR_IRQ is "H" */ reply_len = 0; srq_asserted = 0; macii_state = read_done; } else { macii_state = reading; *reply_ptr = x; reply_len = 1; } |
1da177e4c Linux-2.6.12-rc2 |
419 |
|
1da177e4c Linux-2.6.12-rc2 |
420 421 |
/* set ADB state = even for first data byte */ via[B] = (via[B] & ~ST_MASK) | ST_EVEN; |
1da177e4c Linux-2.6.12-rc2 |
422 423 424 425 426 |
break; case sending: req = current_req; if (data_index >= req->nbytes) { |
1da177e4c Linux-2.6.12-rc2 |
427 |
req->sent = 1; |
d95fd5fce m68k: Mac II ADB ... |
428 |
macii_state = idle; |
1da177e4c Linux-2.6.12-rc2 |
429 430 |
if (req->reply_expected) { |
d95fd5fce m68k: Mac II ADB ... |
431 |
reading_reply = 1; |
1da177e4c Linux-2.6.12-rc2 |
432 433 434 435 |
} else { req->complete = 1; current_req = req->next; if (req->done) (*req->done)(req); |
d95fd5fce m68k: Mac II ADB ... |
436 437 |
if (current_req) |
1da177e4c Linux-2.6.12-rc2 |
438 439 |
macii_start(); else |
d95fd5fce m68k: Mac II ADB ... |
440 441 442 443 444 445 446 447 448 449 |
if (need_autopoll()) macii_autopoll(autopoll_devs); } if (macii_state == idle) { /* reset to shift in */ via[ACR] &= ~SR_OUT; x = via[SR]; /* set ADB state idle - might get SRQ */ via[B] = (via[B] & ~ST_MASK) | ST_IDLE; |
1da177e4c Linux-2.6.12-rc2 |
450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 |
} } else { via[SR] = req->data[data_index++]; if ( (via[B] & ST_MASK) == ST_CMD ) { /* just sent the command byte, set to EVEN */ via[B] = (via[B] & ~ST_MASK) | ST_EVEN; } else { /* invert state bits, toggle ODD/EVEN */ via[B] ^= ST_MASK; } } break; case reading: |
d95fd5fce m68k: Mac II ADB ... |
465 466 467 468 469 470 471 472 473 474 475 476 477 |
x = via[SR]; BUG_ON((status & ST_MASK) == ST_CMD || (status & ST_MASK) == ST_IDLE); /* Bus timeout with SRQ sequence: * data is "XX FF" while CTLR_IRQ is "L L" * End of packet without SRQ sequence: * data is "XX...YY 00" while CTLR_IRQ is "L...H L" * End of packet SRQ sequence: * data is "XX...YY 00" while CTLR_IRQ is "L...L L" * (where XX is the first response byte and * YY is the last byte of valid response data.) */ |
1da177e4c Linux-2.6.12-rc2 |
478 |
|
d95fd5fce m68k: Mac II ADB ... |
479 480 481 482 483 484 485 486 487 488 489 490 |
srq_asserted = 0; if (!(status & CTLR_IRQ)) { if (x == 0xFF) { if (!(last_status & CTLR_IRQ)) { macii_state = read_done; reply_len = 0; srq_asserted = 1; } } else if (x == 0x00) { macii_state = read_done; if (!(last_status & CTLR_IRQ)) srq_asserted = 1; |
1da177e4c Linux-2.6.12-rc2 |
491 |
} |
d95fd5fce m68k: Mac II ADB ... |
492 493 494 495 |
} if (macii_state == reading) { BUG_ON(reply_len > 15); |
1da177e4c Linux-2.6.12-rc2 |
496 |
reply_ptr++; |
d95fd5fce m68k: Mac II ADB ... |
497 |
*reply_ptr = x; |
1da177e4c Linux-2.6.12-rc2 |
498 499 |
reply_len++; } |
1da177e4c Linux-2.6.12-rc2 |
500 |
|
d95fd5fce m68k: Mac II ADB ... |
501 502 |
/* invert state bits, toggle ODD/EVEN */ via[B] ^= ST_MASK; |
1da177e4c Linux-2.6.12-rc2 |
503 504 505 506 |
break; case read_done: x = via[SR]; |
d95fd5fce m68k: Mac II ADB ... |
507 |
|
1da177e4c Linux-2.6.12-rc2 |
508 |
if (reading_reply) { |
d95fd5fce m68k: Mac II ADB ... |
509 |
reading_reply = 0; |
1da177e4c Linux-2.6.12-rc2 |
510 |
req = current_req; |
d95fd5fce m68k: Mac II ADB ... |
511 |
req->reply_len = reply_len; |
1da177e4c Linux-2.6.12-rc2 |
512 513 514 |
req->complete = 1; current_req = req->next; if (req->done) (*req->done)(req); |
d95fd5fce m68k: Mac II ADB ... |
515 516 |
} else if (reply_len && autopoll_devs) adb_input(reply_buf, reply_len, 0); |
1da177e4c Linux-2.6.12-rc2 |
517 |
|
d95fd5fce m68k: Mac II ADB ... |
518 |
macii_state = idle; |
1da177e4c Linux-2.6.12-rc2 |
519 520 |
/* SRQ seen before, initiate poll now */ |
d95fd5fce m68k: Mac II ADB ... |
521 |
if (srq_asserted) |
1da177e4c Linux-2.6.12-rc2 |
522 |
macii_queue_poll(); |
1da177e4c Linux-2.6.12-rc2 |
523 |
|
d95fd5fce m68k: Mac II ADB ... |
524 525 526 527 528 529 530 531 |
if (current_req) macii_start(); else if (need_autopoll()) macii_autopoll(autopoll_devs); if (macii_state == idle) via[B] = (via[B] & ~ST_MASK) | ST_IDLE; |
1da177e4c Linux-2.6.12-rc2 |
532 533 534 535 536 |
break; default: break; } |
d95fd5fce m68k: Mac II ADB ... |
537 538 |
entered--; |
1da177e4c Linux-2.6.12-rc2 |
539 540 |
return IRQ_HANDLED; } |