1 /* $Id: aha1542.c,v 1.1 1992/07/24 06:27:38 root Exp root $ 2 * linux/kernel/aha1542.c 3 * 4 * Copyright (C) 1992 Tommy Thorn 5 * Copyright (C) 1993, 1994, 1995 Eric Youngdale 6 * 7 * Modified by Eric Youngdale 8 * Use request_irq and request_dma to help prevent unexpected conflicts 9 * Set up on-board DMA controller, such that we do not have to 10 * have the bios enabled to use the aha1542. 11 * Modified by David Gentzel 12 * Don't call request_dma if dma mask is 0 (for BusLogic BT-445S VL-Bus 13 * controller). 14 * Modified by Matti Aarnio 15 * Accept parameters from LILO cmd-line. -- 1-Oct-94 16 * Modified by Mike McLagan <mike.mclagan@linux.org> 17 * Recognise extended mode on AHA1542CP, different bit than 1542CF 18 * 1-Jan-97 19 * Modified by Bjorn L. Thordarson and Einar Thor Einarsson 20 * Recognize that DMA0 is valid DMA channel -- 13-Jul-98 21 * Modified by Chris Faulhaber <jedgar@fxp.org> 22 * Added module command-line options 23 * 19-Jul-99 24 * Modified by Adam Fritzler 25 * Added proper detection of the AHA-1640 (MCA version of AHA-1540) 26 */ 27 28 #include <linux/module.h> 29 #include <linux/interrupt.h> 30 #include <linux/kernel.h> 31 #include <linux/types.h> 32 #include <linux/string.h> 33 #include <linux/ioport.h> 34 #include <linux/delay.h> 35 #include <linux/proc_fs.h> 36 #include <linux/init.h> 37 #include <linux/spinlock.h> 38 #include <linux/isapnp.h> 39 #include <linux/blkdev.h> 40 #include <linux/mca.h> 41 #include <linux/mca-legacy.h> 42 #include <linux/slab.h> 43 44 #include <asm/dma.h> 45 #include <asm/system.h> 46 #include <asm/io.h> 47 48 #include "scsi.h" 49 #include <scsi/scsi_host.h> 50 #include "aha1542.h" 51 52 #define SCSI_BUF_PA(address) isa_virt_to_bus(address) 53 #define SCSI_SG_PA(sgent) (isa_page_to_bus(sg_page((sgent))) + (sgent)->offset) 54 55 #include<linux/stat.h> 56 57 #ifdef DEBUG 58 #define DEB(x) x 59 #else 60 #define DEB(x) 61 #endif 62 63 /* 64 static const char RCSid[] = "$Header: /usr/src/linux/kernel/blk_drv/scsi/RCS/aha1542.c,v 1.1 1992/07/24 06:27:38 root Exp root $"; 65 */ 66 67 /* The adaptec can be configured for quite a number of addresses, but 68 I generally do not want the card poking around at random. We allow 69 two addresses - this allows people to use the Adaptec with a Midi 70 card, which also used 0x330 -- can be overridden with LILO! */ 71 72 #define MAXBOARDS 4 /* Increase this and the sizes of the 73 arrays below, if you need more.. */ 74 75 /* Boards 3,4 slots are reserved for ISAPnP/MCA scans */ 76 77 static unsigned int bases[MAXBOARDS] __initdata = {0x330, 0x334, 0, 0}; 78 79 /* set by aha1542_setup according to the command line; they also may 80 be marked __initdata, but require zero initializers then */ 81 82 static int setup_called[MAXBOARDS]; 83 static int setup_buson[MAXBOARDS]; 84 static int setup_busoff[MAXBOARDS]; 85 static int setup_dmaspeed[MAXBOARDS] __initdata = { -1, -1, -1, -1 }; 86 87 /* 88 * LILO/Module params: aha1542=<PORTBASE>[,<BUSON>,<BUSOFF>[,<DMASPEED>]] 89 * 90 * Where: <PORTBASE> is any of the valid AHA addresses: 91 * 0x130, 0x134, 0x230, 0x234, 0x330, 0x334 92 * <BUSON> is the time (in microsecs) that AHA spends on the AT-bus 93 * when transferring data. 1542A power-on default is 11us, 94 * valid values are in range: 2..15 (decimal) 95 * <BUSOFF> is the time that AHA spends OFF THE BUS after while 96 * it is transferring data (not to monopolize the bus). 97 * Power-on default is 4us, valid range: 1..64 microseconds. 98 * <DMASPEED> Default is jumper selected (1542A: on the J1), 99 * but experimenter can alter it with this. 100 * Valid values: 5, 6, 7, 8, 10 (MB/s) 101 * Factory default is 5 MB/s. 102 */ 103 104 #if defined(MODULE) 105 static int isapnp = 0; 106 static int aha1542[] = {0x330, 11, 4, -1}; 107 module_param_array(aha1542, int, NULL, 0); 108 module_param(isapnp, bool, 0); 109 110 static struct isapnp_device_id id_table[] __initdata = { 111 { 112 ISAPNP_ANY_ID, ISAPNP_ANY_ID, 113 ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1542), 114 0 115 }, 116 {0} 117 }; 118 119 MODULE_DEVICE_TABLE(isapnp, id_table); 120 121 #else 122 static int isapnp = 1; 123 #endif 124 125 #define BIOS_TRANSLATION_1632 0 /* Used by some old 1542A boards */ 126 #define BIOS_TRANSLATION_6432 1 /* Default case these days */ 127 #define BIOS_TRANSLATION_25563 2 /* Big disk case */ 128 129 struct aha1542_hostdata { 130 /* This will effectively start both of them at the first mailbox */ 131 int bios_translation; /* Mapping bios uses - for compatibility */ 132 int aha1542_last_mbi_used; 133 int aha1542_last_mbo_used; 134 Scsi_Cmnd *SCint[AHA1542_MAILBOXES]; 135 struct mailbox mb[2 * AHA1542_MAILBOXES]; 136 struct ccb ccb[AHA1542_MAILBOXES]; 137 }; 138 139 #define HOSTDATA(host) ((struct aha1542_hostdata *) &host->hostdata) 140 141 static DEFINE_SPINLOCK(aha1542_lock); 142 143 144 145 #define WAITnexttimeout 3000000 146 147 static void setup_mailboxes(int base_io, struct Scsi_Host *shpnt); 148 static int aha1542_restart(struct Scsi_Host *shost); 149 static void aha1542_intr_handle(struct Scsi_Host *shost); 150 151 #define aha1542_intr_reset(base) outb(IRST, CONTROL(base)) 152 153 #define WAIT(port, mask, allof, noneof) \ 154 { register int WAITbits; \ 155 register int WAITtimeout = WAITnexttimeout; \ 156 while (1) { \ 157 WAITbits = inb(port) & (mask); \ 158 if ((WAITbits & (allof)) == (allof) && ((WAITbits & (noneof)) == 0)) \ 159 break; \ 160 if (--WAITtimeout == 0) goto fail; \ 161 } \ 162 } 163 164 /* Similar to WAIT, except we use the udelay call to regulate the 165 amount of time we wait. */ 166 #define WAITd(port, mask, allof, noneof, timeout) \ 167 { register int WAITbits; \ 168 register int WAITtimeout = timeout; \ 169 while (1) { \ 170 WAITbits = inb(port) & (mask); \ 171 if ((WAITbits & (allof)) == (allof) && ((WAITbits & (noneof)) == 0)) \ 172 break; \ 173 mdelay(1); \ 174 if (--WAITtimeout == 0) goto fail; \ 175 } \ 176 } 177 178 static void aha1542_stat(void) 179 { 180 /* int s = inb(STATUS), i = inb(INTRFLAGS); 181 printk("status=%x intrflags=%x\n", s, i, WAITnexttimeout-WAITtimeout); */ 182 } 183 184 /* This is a bit complicated, but we need to make sure that an interrupt 185 routine does not send something out while we are in the middle of this. 186 Fortunately, it is only at boot time that multi-byte messages 187 are ever sent. */ 188 static int aha1542_out(unsigned int base, unchar * cmdp, int len) 189 { 190 unsigned long flags = 0; 191 int got_lock; 192 193 if (len == 1) { 194 got_lock = 0; 195 while (1 == 1) { 196 WAIT(STATUS(base), CDF, 0, CDF); 197 spin_lock_irqsave(&aha1542_lock, flags); 198 if (inb(STATUS(base)) & CDF) { 199 spin_unlock_irqrestore(&aha1542_lock, flags); 200 continue; 201 } 202 outb(*cmdp, DATA(base)); 203 spin_unlock_irqrestore(&aha1542_lock, flags); 204 return 0; 205 } 206 } else { 207 spin_lock_irqsave(&aha1542_lock, flags); 208 got_lock = 1; 209 while (len--) { 210 WAIT(STATUS(base), CDF, 0, CDF); 211 outb(*cmdp++, DATA(base)); 212 } 213 spin_unlock_irqrestore(&aha1542_lock, flags); 214 } 215 return 0; 216 fail: 217 if (got_lock) 218 spin_unlock_irqrestore(&aha1542_lock, flags); 219 printk(KERN_ERR "aha1542_out failed(%d): ", len + 1); 220 aha1542_stat(); 221 return 1; 222 } 223 224 /* Only used at boot time, so we do not need to worry about latency as much 225 here */ 226 227 static int __init aha1542_in(unsigned int base, unchar * cmdp, int len) 228 { 229 unsigned long flags; 230 231 spin_lock_irqsave(&aha1542_lock, flags); 232 while (len--) { 233 WAIT(STATUS(base), DF, DF, 0); 234 *cmdp++ = inb(DATA(base)); 235 } 236 spin_unlock_irqrestore(&aha1542_lock, flags); 237 return 0; 238 fail: 239 spin_unlock_irqrestore(&aha1542_lock, flags); 240 printk(KERN_ERR "aha1542_in failed(%d): ", len + 1); 241 aha1542_stat(); 242 return 1; 243 } 244 245 /* Similar to aha1542_in, except that we wait a very short period of time. 246 We use this if we know the board is alive and awake, but we are not sure 247 if the board will respond to the command we are about to send or not */ 248 static int __init aha1542_in1(unsigned int base, unchar * cmdp, int len) 249 { 250 unsigned long flags; 251 252 spin_lock_irqsave(&aha1542_lock, flags); 253 while (len--) { 254 WAITd(STATUS(base), DF, DF, 0, 100); 255 *cmdp++ = inb(DATA(base)); 256 } 257 spin_unlock_irqrestore(&aha1542_lock, flags); 258 return 0; 259 fail: 260 spin_unlock_irqrestore(&aha1542_lock, flags); 261 return 1; 262 } 263 264 static int makecode(unsigned hosterr, unsigned scsierr) 265 { 266 switch (hosterr) { 267 case 0x0: 268 case 0xa: /* Linked command complete without error and linked normally */ 269 case 0xb: /* Linked command complete without error, interrupt generated */ 270 hosterr = 0; 271 break; 272 273 case 0x11: /* Selection time out-The initiator selection or target 274 reselection was not complete within the SCSI Time out period */ 275 hosterr = DID_TIME_OUT; 276 break; 277 278 case 0x12: /* Data overrun/underrun-The target attempted to transfer more data 279 than was allocated by the Data Length field or the sum of the 280 Scatter / Gather Data Length fields. */ 281 282 case 0x13: /* Unexpected bus free-The target dropped the SCSI BSY at an unexpected time. */ 283 284 case 0x15: /* MBO command was not 00, 01 or 02-The first byte of the CB was 285 invalid. This usually indicates a software failure. */ 286 287 case 0x16: /* Invalid CCB Operation Code-The first byte of the CCB was invalid. 288 This usually indicates a software failure. */ 289 290 case 0x17: /* Linked CCB does not have the same LUN-A subsequent CCB of a set 291 of linked CCB's does not specify the same logical unit number as 292 the first. */ 293 case 0x18: /* Invalid Target Direction received from Host-The direction of a 294 Target Mode CCB was invalid. */ 295 296 case 0x19: /* Duplicate CCB Received in Target Mode-More than once CCB was 297 received to service data transfer between the same target LUN 298 and initiator SCSI ID in the same direction. */ 299 300 case 0x1a: /* Invalid CCB or Segment List Parameter-A segment list with a zero 301 length segment or invalid segment list boundaries was received. 302 A CCB parameter was invalid. */ 303 DEB(printk("Aha1542: %x %x\n", hosterr, scsierr)); 304 hosterr = DID_ERROR; /* Couldn't find any better */ 305 break; 306 307 case 0x14: /* Target bus phase sequence failure-An invalid bus phase or bus 308 phase sequence was requested by the target. The host adapter 309 will generate a SCSI Reset Condition, notifying the host with 310 a SCRD interrupt */ 311 hosterr = DID_RESET; 312 break; 313 default: 314 printk(KERN_ERR "aha1542: makecode: unknown hoststatus %x\n", hosterr); 315 break; 316 } 317 return scsierr | (hosterr << 16); 318 } 319 320 static int __init aha1542_test_port(int bse, struct Scsi_Host *shpnt) 321 { 322 unchar inquiry_cmd[] = {CMD_INQUIRY}; 323 unchar inquiry_result[4]; 324 unchar *cmdp; 325 int len; 326 volatile int debug = 0; 327 328 /* Quick and dirty test for presence of the card. */ 329 if (inb(STATUS(bse)) == 0xff) 330 return 0; 331 332 /* Reset the adapter. I ought to make a hard reset, but it's not really necessary */ 333 334 /* DEB(printk("aha1542_test_port called \n")); */ 335 336 /* In case some other card was probing here, reset interrupts */ 337 aha1542_intr_reset(bse); /* reset interrupts, so they don't block */ 338 339 outb(SRST | IRST /*|SCRST */ , CONTROL(bse)); 340 341 mdelay(20); /* Wait a little bit for things to settle down. */ 342 343 debug = 1; 344 /* Expect INIT and IDLE, any of the others are bad */ 345 WAIT(STATUS(bse), STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF); 346 347 debug = 2; 348 /* Shouldn't have generated any interrupts during reset */ 349 if (inb(INTRFLAGS(bse)) & INTRMASK) 350 goto fail; 351 352 353 /* Perform a host adapter inquiry instead so we do not need to set 354 up the mailboxes ahead of time */ 355 356 aha1542_out(bse, inquiry_cmd, 1); 357 358 debug = 3; 359 len = 4; 360 cmdp = &inquiry_result[0]; 361 362 while (len--) { 363 WAIT(STATUS(bse), DF, DF, 0); 364 *cmdp++ = inb(DATA(bse)); 365 } 366 367 debug = 8; 368 /* Reading port should reset DF */ 369 if (inb(STATUS(bse)) & DF) 370 goto fail; 371 372 debug = 9; 373 /* When HACC, command is completed, and we're though testing */ 374 WAIT(INTRFLAGS(bse), HACC, HACC, 0); 375 /* now initialize adapter */ 376 377 debug = 10; 378 /* Clear interrupts */ 379 outb(IRST, CONTROL(bse)); 380 381 debug = 11; 382 383 return debug; /* 1 = ok */ 384 fail: 385 return 0; /* 0 = not ok */ 386 } 387 388 /* A quick wrapper for do_aha1542_intr_handle to grab the spin lock */ 389 static irqreturn_t do_aha1542_intr_handle(int dummy, void *dev_id) 390 { 391 unsigned long flags; 392 struct Scsi_Host *shost = dev_id; 393 394 spin_lock_irqsave(shost->host_lock, flags); 395 aha1542_intr_handle(shost); 396 spin_unlock_irqrestore(shost->host_lock, flags); 397 return IRQ_HANDLED; 398 } 399 400 /* A "high" level interrupt handler */ 401 static void aha1542_intr_handle(struct Scsi_Host *shost) 402 { 403 void (*my_done) (Scsi_Cmnd *) = NULL; 404 int errstatus, mbi, mbo, mbistatus; 405 int number_serviced; 406 unsigned long flags; 407 Scsi_Cmnd *SCtmp; 408 int flag; 409 int needs_restart; 410 struct mailbox *mb; 411 struct ccb *ccb; 412 413 mb = HOSTDATA(shost)->mb; 414 ccb = HOSTDATA(shost)->ccb; 415 416 #ifdef DEBUG 417 { 418 flag = inb(INTRFLAGS(shost->io_port)); 419 printk(KERN_DEBUG "aha1542_intr_handle: "); 420 if (!(flag & ANYINTR)) 421 printk("no interrupt?"); 422 if (flag & MBIF) 423 printk("MBIF "); 424 if (flag & MBOA) 425 printk("MBOF "); 426 if (flag & HACC) 427 printk("HACC "); 428 if (flag & SCRD) 429 printk("SCRD "); 430 printk("status %02x\n", inb(STATUS(shost->io_port))); 431 }; 432 #endif 433 number_serviced = 0; 434 needs_restart = 0; 435 436 while (1 == 1) { 437 flag = inb(INTRFLAGS(shost->io_port)); 438 439 /* Check for unusual interrupts. If any of these happen, we should 440 probably do something special, but for now just printing a message 441 is sufficient. A SCSI reset detected is something that we really 442 need to deal with in some way. */ 443 if (flag & ~MBIF) { 444 if (flag & MBOA) 445 printk("MBOF "); 446 if (flag & HACC) 447 printk("HACC "); 448 if (flag & SCRD) { 449 needs_restart = 1; 450 printk("SCRD "); 451 } 452 } 453 aha1542_intr_reset(shost->io_port); 454 455 spin_lock_irqsave(&aha1542_lock, flags); 456 mbi = HOSTDATA(shost)->aha1542_last_mbi_used + 1; 457 if (mbi >= 2 * AHA1542_MAILBOXES) 458 mbi = AHA1542_MAILBOXES; 459 460 do { 461 if (mb[mbi].status != 0) 462 break; 463 mbi++; 464 if (mbi >= 2 * AHA1542_MAILBOXES) 465 mbi = AHA1542_MAILBOXES; 466 } while (mbi != HOSTDATA(shost)->aha1542_last_mbi_used); 467 468 if (mb[mbi].status == 0) { 469 spin_unlock_irqrestore(&aha1542_lock, flags); 470 /* Hmm, no mail. Must have read it the last time around */ 471 if (!number_serviced && !needs_restart) 472 printk(KERN_WARNING "aha1542.c: interrupt received, but no mail.\n"); 473 /* We detected a reset. Restart all pending commands for 474 devices that use the hard reset option */ 475 if (needs_restart) 476 aha1542_restart(shost); 477 return; 478 }; 479 480 mbo = (scsi2int(mb[mbi].ccbptr) - (SCSI_BUF_PA(&ccb[0]))) / sizeof(struct ccb); 481 mbistatus = mb[mbi].status; 482 mb[mbi].status = 0; 483 HOSTDATA(shost)->aha1542_last_mbi_used = mbi; 484 spin_unlock_irqrestore(&aha1542_lock, flags); 485 486 #ifdef DEBUG 487 { 488 if (ccb[mbo].tarstat | ccb[mbo].hastat) 489 printk(KERN_DEBUG "aha1542_command: returning %x (status %d)\n", 490 ccb[mbo].tarstat + ((int) ccb[mbo].hastat << 16), mb[mbi].status); 491 }; 492 #endif 493 494 if (mbistatus == 3) 495 continue; /* Aborted command not found */ 496 497 #ifdef DEBUG 498 printk(KERN_DEBUG "...done %d %d\n", mbo, mbi); 499 #endif 500 501 SCtmp = HOSTDATA(shost)->SCint[mbo]; 502 503 if (!SCtmp || !SCtmp->scsi_done) { 504 printk(KERN_WARNING "aha1542_intr_handle: Unexpected interrupt\n"); 505 printk(KERN_WARNING "tarstat=%x, hastat=%x idlun=%x ccb#=%d \n", ccb[mbo].tarstat, 506 ccb[mbo].hastat, ccb[mbo].idlun, mbo); 507 return; 508 } 509 my_done = SCtmp->scsi_done; 510 kfree(SCtmp->host_scribble); 511 SCtmp->host_scribble = NULL; 512 /* Fetch the sense data, and tuck it away, in the required slot. The 513 Adaptec automatically fetches it, and there is no guarantee that 514 we will still have it in the cdb when we come back */ 515 if (ccb[mbo].tarstat == 2) 516 memcpy(SCtmp->sense_buffer, &ccb[mbo].cdb[ccb[mbo].cdblen], 517 SCSI_SENSE_BUFFERSIZE); 518 519 520 /* is there mail :-) */ 521 522 /* more error checking left out here */ 523 if (mbistatus != 1) 524 /* This is surely wrong, but I don't know what's right */ 525 errstatus = makecode(ccb[mbo].hastat, ccb[mbo].tarstat); 526 else 527 errstatus = 0; 528 529 #ifdef DEBUG 530 if (errstatus) 531 printk(KERN_DEBUG "(aha1542 error:%x %x %x) ", errstatus, 532 ccb[mbo].hastat, ccb[mbo].tarstat); 533 #endif 534 535 if (ccb[mbo].tarstat == 2) { 536 #ifdef DEBUG 537 int i; 538 #endif 539 DEB(printk("aha1542_intr_handle: sense:")); 540 #ifdef DEBUG 541 for (i = 0; i < 12; i++) 542 printk("%02x ", ccb[mbo].cdb[ccb[mbo].cdblen + i]); 543 printk("\n"); 544 #endif 545 /* 546 DEB(printk("aha1542_intr_handle: buf:")); 547 for (i = 0; i < bufflen; i++) 548 printk("%02x ", ((unchar *)buff)[i]); 549 printk("\n"); 550 */ 551 } 552 DEB(if (errstatus) printk("aha1542_intr_handle: returning %6x\n", errstatus)); 553 SCtmp->result = errstatus; 554 HOSTDATA(shost)->SCint[mbo] = NULL; /* This effectively frees up the mailbox slot, as 555 far as queuecommand is concerned */ 556 my_done(SCtmp); 557 number_serviced++; 558 }; 559 } 560 561 static int aha1542_queuecommand(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *)) 562 { 563 unchar ahacmd = CMD_START_SCSI; 564 unchar direction; 565 unchar *cmd = (unchar *) SCpnt->cmnd; 566 unchar target = SCpnt->device->id; 567 unchar lun = SCpnt->device->lun; 568 unsigned long flags; 569 int bufflen = scsi_bufflen(SCpnt); 570 int mbo; 571 struct mailbox *mb; 572 struct ccb *ccb; 573 574 DEB(int i); 575 576 mb = HOSTDATA(SCpnt->device->host)->mb; 577 ccb = HOSTDATA(SCpnt->device->host)->ccb; 578 579 DEB(if (target > 1) { 580 SCpnt->result = DID_TIME_OUT << 16; 581 done(SCpnt); return 0; 582 } 583 ); 584 585 if (*cmd == REQUEST_SENSE) { 586 /* Don't do the command - we have the sense data already */ 587 #if 0 588 /* scsi_request_sense() provides a buffer of size 256, 589 so there is no reason to expect equality */ 590 if (bufflen != SCSI_SENSE_BUFFERSIZE) 591 printk(KERN_CRIT "aha1542: Wrong buffer length supplied " 592 "for request sense (%d)\n", bufflen); 593 #endif 594 SCpnt->result = 0; 595 done(SCpnt); 596 return 0; 597 } 598 #ifdef DEBUG 599 if (*cmd == READ_10 || *cmd == WRITE_10) 600 i = xscsi2int(cmd + 2); 601 else if (*cmd == READ_6 || *cmd == WRITE_6) 602 i = scsi2int(cmd + 2); 603 else 604 i = -1; 605 if (done) 606 printk(KERN_DEBUG "aha1542_queuecommand: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen); 607 else 608 printk(KERN_DEBUG "aha1542_command: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen); 609 aha1542_stat(); 610 printk(KERN_DEBUG "aha1542_queuecommand: dumping scsi cmd:"); 611 for (i = 0; i < SCpnt->cmd_len; i++) 612 printk("%02x ", cmd[i]); 613 printk("\n"); 614 if (*cmd == WRITE_10 || *cmd == WRITE_6) 615 return 0; /* we are still testing, so *don't* write */ 616 #endif 617 /* Use the outgoing mailboxes in a round-robin fashion, because this 618 is how the host adapter will scan for them */ 619 620 spin_lock_irqsave(&aha1542_lock, flags); 621 mbo = HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used + 1; 622 if (mbo >= AHA1542_MAILBOXES) 623 mbo = 0; 624 625 do { 626 if (mb[mbo].status == 0 && HOSTDATA(SCpnt->device->host)->SCint[mbo] == NULL) 627 break; 628 mbo++; 629 if (mbo >= AHA1542_MAILBOXES) 630 mbo = 0; 631 } while (mbo != HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used); 632 633 if (mb[mbo].status || HOSTDATA(SCpnt->device->host)->SCint[mbo]) 634 panic("Unable to find empty mailbox for aha1542.\n"); 635 636 HOSTDATA(SCpnt->device->host)->SCint[mbo] = SCpnt; /* This will effectively prevent someone else from 637 screwing with this cdb. */ 638 639 HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used = mbo; 640 spin_unlock_irqrestore(&aha1542_lock, flags); 641 642 #ifdef DEBUG 643 printk(KERN_DEBUG "Sending command (%d %x)...", mbo, done); 644 #endif 645 646 any2scsi(mb[mbo].ccbptr, SCSI_BUF_PA(&ccb[mbo])); /* This gets trashed for some reason */ 647 648 memset(&ccb[mbo], 0, sizeof(struct ccb)); 649 650 ccb[mbo].cdblen = SCpnt->cmd_len; 651 652 direction = 0; 653 if (*cmd == READ_10 || *cmd == READ_6) 654 direction = 8; 655 else if (*cmd == WRITE_10 || *cmd == WRITE_6) 656 direction = 16; 657 658 memcpy(ccb[mbo].cdb, cmd, ccb[mbo].cdblen); 659 660 if (bufflen) { 661 struct scatterlist *sg; 662 struct chain *cptr; 663 #ifdef DEBUG 664 unsigned char *ptr; 665 #endif 666 int i, sg_count = scsi_sg_count(SCpnt); 667 ccb[mbo].op = 2; /* SCSI Initiator Command w/scatter-gather */ 668 SCpnt->host_scribble = kmalloc(sizeof(*cptr)*sg_count, 669 GFP_KERNEL | GFP_DMA); 670 cptr = (struct chain *) SCpnt->host_scribble; 671 if (cptr == NULL) { 672 /* free the claimed mailbox slot */ 673 HOSTDATA(SCpnt->device->host)->SCint[mbo] = NULL; 674 return SCSI_MLQUEUE_HOST_BUSY; 675 } 676 scsi_for_each_sg(SCpnt, sg, sg_count, i) { 677 any2scsi(cptr[i].dataptr, SCSI_SG_PA(sg)); 678 any2scsi(cptr[i].datalen, sg->length); 679 }; 680 any2scsi(ccb[mbo].datalen, sg_count * sizeof(struct chain)); 681 any2scsi(ccb[mbo].dataptr, SCSI_BUF_PA(cptr)); 682 #ifdef DEBUG 683 printk("cptr %x: ", cptr); 684 ptr = (unsigned char *) cptr; 685 for (i = 0; i < 18; i++) 686 printk("%02x ", ptr[i]); 687 #endif 688 } else { 689 ccb[mbo].op = 0; /* SCSI Initiator Command */ 690 SCpnt->host_scribble = NULL; 691 any2scsi(ccb[mbo].datalen, 0); 692 any2scsi(ccb[mbo].dataptr, 0); 693 }; 694 ccb[mbo].idlun = (target & 7) << 5 | direction | (lun & 7); /*SCSI Target Id */ 695 ccb[mbo].rsalen = 16; 696 ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0; 697 ccb[mbo].commlinkid = 0; 698 699 #ifdef DEBUG 700 { 701 int i; 702 printk(KERN_DEBUG "aha1542_command: sending.. "); 703 for (i = 0; i < sizeof(ccb[mbo]) - 10; i++) 704 printk("%02x ", ((unchar *) & ccb[mbo])[i]); 705 }; 706 #endif 707 708 if (done) { 709 DEB(printk("aha1542_queuecommand: now waiting for interrupt "); 710 aha1542_stat()); 711 SCpnt->scsi_done = done; 712 mb[mbo].status = 1; 713 aha1542_out(SCpnt->device->host->io_port, &ahacmd, 1); /* start scsi command */ 714 DEB(aha1542_stat()); 715 } else 716 printk("aha1542_queuecommand: done can't be NULL\n"); 717 718 return 0; 719 } 720 721 /* Initialize mailboxes */ 722 static void setup_mailboxes(int bse, struct Scsi_Host *shpnt) 723 { 724 int i; 725 struct mailbox *mb; 726 struct ccb *ccb; 727 728 unchar cmd[5] = { CMD_MBINIT, AHA1542_MAILBOXES, 0, 0, 0}; 729 730 mb = HOSTDATA(shpnt)->mb; 731 ccb = HOSTDATA(shpnt)->ccb; 732 733 for (i = 0; i < AHA1542_MAILBOXES; i++) { 734 mb[i].status = mb[AHA1542_MAILBOXES + i].status = 0; 735 any2scsi(mb[i].ccbptr, SCSI_BUF_PA(&ccb[i])); 736 }; 737 aha1542_intr_reset(bse); /* reset interrupts, so they don't block */ 738 any2scsi((cmd + 2), SCSI_BUF_PA(mb)); 739 aha1542_out(bse, cmd, 5); 740 WAIT(INTRFLAGS(bse), INTRMASK, HACC, 0); 741 while (0) { 742 fail: 743 printk(KERN_ERR "aha1542_detect: failed setting up mailboxes\n"); 744 } 745 aha1542_intr_reset(bse); 746 } 747 748 static int __init aha1542_getconfig(int base_io, unsigned char *irq_level, unsigned char *dma_chan, unsigned char *scsi_id) 749 { 750 unchar inquiry_cmd[] = {CMD_RETCONF}; 751 unchar inquiry_result[3]; 752 int i; 753 i = inb(STATUS(base_io)); 754 if (i & DF) { 755 i = inb(DATA(base_io)); 756 }; 757 aha1542_out(base_io, inquiry_cmd, 1); 758 aha1542_in(base_io, inquiry_result, 3); 759 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0); 760 while (0) { 761 fail: 762 printk(KERN_ERR "aha1542_detect: query board settings\n"); 763 } 764 aha1542_intr_reset(base_io); 765 switch (inquiry_result[0]) { 766 case 0x80: 767 *dma_chan = 7; 768 break; 769 case 0x40: 770 *dma_chan = 6; 771 break; 772 case 0x20: 773 *dma_chan = 5; 774 break; 775 case 0x01: 776 *dma_chan = 0; 777 break; 778 case 0: 779 /* This means that the adapter, although Adaptec 1542 compatible, doesn't use a DMA channel. 780 Currently only aware of the BusLogic BT-445S VL-Bus adapter which needs this. */ 781 *dma_chan = 0xFF; 782 break; 783 default: 784 printk(KERN_ERR "Unable to determine Adaptec DMA priority. Disabling board\n"); 785 return -1; 786 }; 787 switch (inquiry_result[1]) { 788 case 0x40: 789 *irq_level = 15; 790 break; 791 case 0x20: 792 *irq_level = 14; 793 break; 794 case 0x8: 795 *irq_level = 12; 796 break; 797 case 0x4: 798 *irq_level = 11; 799 break; 800 case 0x2: 801 *irq_level = 10; 802 break; 803 case 0x1: 804 *irq_level = 9; 805 break; 806 default: 807 printk(KERN_ERR "Unable to determine Adaptec IRQ level. Disabling board\n"); 808 return -1; 809 }; 810 *scsi_id = inquiry_result[2] & 7; 811 return 0; 812 } 813 814 /* This function should only be called for 1542C boards - we can detect 815 the special firmware settings and unlock the board */ 816 817 static int __init aha1542_mbenable(int base) 818 { 819 static unchar mbenable_cmd[3]; 820 static unchar mbenable_result[2]; 821 int retval; 822 823 retval = BIOS_TRANSLATION_6432; 824 825 mbenable_cmd[0] = CMD_EXTBIOS; 826 aha1542_out(base, mbenable_cmd, 1); 827 if (aha1542_in1(base, mbenable_result, 2)) 828 return retval; 829 WAITd(INTRFLAGS(base), INTRMASK, HACC, 0, 100); 830 aha1542_intr_reset(base); 831 832 if ((mbenable_result[0] & 0x08) || mbenable_result[1]) { 833 mbenable_cmd[0] = CMD_MBENABLE; 834 mbenable_cmd[1] = 0; 835 mbenable_cmd[2] = mbenable_result[1]; 836 837 if ((mbenable_result[0] & 0x08) && (mbenable_result[1] & 0x03)) 838 retval = BIOS_TRANSLATION_25563; 839 840 aha1542_out(base, mbenable_cmd, 3); 841 WAIT(INTRFLAGS(base), INTRMASK, HACC, 0); 842 }; 843 while (0) { 844 fail: 845 printk(KERN_ERR "aha1542_mbenable: Mailbox init failed\n"); 846 } 847 aha1542_intr_reset(base); 848 return retval; 849 } 850 851 /* Query the board to find out if it is a 1542 or a 1740, or whatever. */ 852 static int __init aha1542_query(int base_io, int *transl) 853 { 854 unchar inquiry_cmd[] = {CMD_INQUIRY}; 855 unchar inquiry_result[4]; 856 int i; 857 i = inb(STATUS(base_io)); 858 if (i & DF) { 859 i = inb(DATA(base_io)); 860 }; 861 aha1542_out(base_io, inquiry_cmd, 1); 862 aha1542_in(base_io, inquiry_result, 4); 863 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0); 864 while (0) { 865 fail: 866 printk(KERN_ERR "aha1542_detect: query card type\n"); 867 } 868 aha1542_intr_reset(base_io); 869 870 *transl = BIOS_TRANSLATION_6432; /* Default case */ 871 872 /* For an AHA1740 series board, we ignore the board since there is a 873 hardware bug which can lead to wrong blocks being returned if the board 874 is operating in the 1542 emulation mode. Since there is an extended mode 875 driver, we simply ignore the board and let the 1740 driver pick it up. 876 */ 877 878 if (inquiry_result[0] == 0x43) { 879 printk(KERN_INFO "aha1542.c: Emulation mode not supported for AHA 174N hardware.\n"); 880 return 1; 881 }; 882 883 /* Always call this - boards that do not support extended bios translation 884 will ignore the command, and we will set the proper default */ 885 886 *transl = aha1542_mbenable(base_io); 887 888 return 0; 889 } 890 891 #ifndef MODULE 892 static char *setup_str[MAXBOARDS] __initdata; 893 static int setup_idx = 0; 894 895 static void __init aha1542_setup(char *str, int *ints) 896 { 897 const char *ahausage = "aha1542: usage: aha1542=<PORTBASE>[,<BUSON>,<BUSOFF>[,<DMASPEED>]]\n"; 898 int setup_portbase; 899 900 if (setup_idx >= MAXBOARDS) { 901 printk(KERN_ERR "aha1542: aha1542_setup called too many times! Bad LILO params ?\n"); 902 printk(KERN_ERR " Entryline 1: %s\n", setup_str[0]); 903 printk(KERN_ERR " Entryline 2: %s\n", setup_str[1]); 904 printk(KERN_ERR " This line: %s\n", str); 905 return; 906 } 907 if (ints[0] < 1 || ints[0] > 4) { 908 printk(KERN_ERR "aha1542: %s\n", str); 909 printk(ahausage); 910 printk(KERN_ERR "aha1542: Wrong parameters may cause system malfunction.. We try anyway..\n"); 911 } 912 setup_called[setup_idx] = ints[0]; 913 setup_str[setup_idx] = str; 914 915 setup_portbase = ints[0] >= 1 ? ints[1] : 0; /* Preserve the default value.. */ 916 setup_buson[setup_idx] = ints[0] >= 2 ? ints[2] : 7; 917 setup_busoff[setup_idx] = ints[0] >= 3 ? ints[3] : 5; 918 if (ints[0] >= 4) 919 { 920 int atbt = -1; 921 switch (ints[4]) { 922 case 5: 923 atbt = 0x00; 924 break; 925 case 6: 926 atbt = 0x04; 927 break; 928 case 7: 929 atbt = 0x01; 930 break; 931 case 8: 932 atbt = 0x02; 933 break; 934 case 10: 935 atbt = 0x03; 936 break; 937 default: 938 printk(KERN_ERR "aha1542: %s\n", str); 939 printk(ahausage); 940 printk(KERN_ERR "aha1542: Valid values for DMASPEED are 5-8, 10 MB/s. Using jumper defaults.\n"); 941 break; 942 } 943 setup_dmaspeed[setup_idx] = atbt; 944 } 945 if (setup_portbase != 0) 946 bases[setup_idx] = setup_portbase; 947 948 ++setup_idx; 949 } 950 951 static int __init do_setup(char *str) 952 { 953 int ints[5]; 954 955 int count=setup_idx; 956 957 get_options(str, ARRAY_SIZE(ints), ints); 958 aha1542_setup(str,ints); 959 960 return count<setup_idx; 961 } 962 963 __setup("aha1542=",do_setup); 964 #endif 965 966 /* return non-zero on detection */ 967 static int __init aha1542_detect(struct scsi_host_template * tpnt) 968 { 969 unsigned char dma_chan; 970 unsigned char irq_level; 971 unsigned char scsi_id; 972 unsigned long flags; 973 unsigned int base_io; 974 int trans; 975 struct Scsi_Host *shpnt = NULL; 976 int count = 0; 977 int indx; 978 979 DEB(printk("aha1542_detect: \n")); 980 981 tpnt->proc_name = "aha1542"; 982 983 #ifdef MODULE 984 bases[0] = aha1542[0]; 985 setup_buson[0] = aha1542[1]; 986 setup_busoff[0] = aha1542[2]; 987 { 988 int atbt = -1; 989 switch (aha1542[3]) { 990 case 5: 991 atbt = 0x00; 992 break; 993 case 6: 994 atbt = 0x04; 995 break; 996 case 7: 997 atbt = 0x01; 998 break; 999 case 8: 1000 atbt = 0x02; 1001 break; 1002 case 10: 1003 atbt = 0x03; 1004 break; 1005 }; 1006 setup_dmaspeed[0] = atbt; 1007 } 1008 #endif 1009 1010 /* 1011 * Find MicroChannel cards (AHA1640) 1012 */ 1013 #ifdef CONFIG_MCA_LEGACY 1014 if(MCA_bus) { 1015 int slot = 0; 1016 int pos = 0; 1017 1018 for (indx = 0; (slot != MCA_NOTFOUND) && (indx < ARRAY_SIZE(bases)); indx++) { 1019 1020 if (bases[indx]) 1021 continue; 1022 1023 /* Detect only AHA-1640 cards -- MCA ID 0F1F */ 1024 slot = mca_find_unused_adapter(0x0f1f, slot); 1025 if (slot == MCA_NOTFOUND) 1026 break; 1027 1028 /* Found one */ 1029 pos = mca_read_stored_pos(slot, 3); 1030 1031 /* Decode address */ 1032 if (pos & 0x80) { 1033 if (pos & 0x02) { 1034 if (pos & 0x01) 1035 bases[indx] = 0x334; 1036 else 1037 bases[indx] = 0x234; 1038 } else { 1039 if (pos & 0x01) 1040 bases[indx] = 0x134; 1041 } 1042 } else { 1043 if (pos & 0x02) { 1044 if (pos & 0x01) 1045 bases[indx] = 0x330; 1046 else 1047 bases[indx] = 0x230; 1048 } else { 1049 if (pos & 0x01) 1050 bases[indx] = 0x130; 1051 } 1052 } 1053 1054 /* No need to decode IRQ and Arb level -- those are 1055 * read off the card later. 1056 */ 1057 printk(KERN_INFO "Found an AHA-1640 in MCA slot %d, I/O 0x%04x\n", slot, bases[indx]); 1058 1059 mca_set_adapter_name(slot, "Adapter AHA-1640"); 1060 mca_set_adapter_procfn(slot, NULL, NULL); 1061 mca_mark_as_used(slot); 1062 1063 /* Go on */ 1064 slot++; 1065 } 1066 1067 } 1068 #endif 1069 1070 /* 1071 * Hunt for ISA Plug'n'Pray Adaptecs (AHA1535) 1072 */ 1073 1074 if(isapnp) 1075 { 1076 struct pnp_dev *pdev = NULL; 1077 for(indx = 0; indx < ARRAY_SIZE(bases); indx++) { 1078 if(bases[indx]) 1079 continue; 1080 pdev = pnp_find_dev(NULL, ISAPNP_VENDOR('A', 'D', 'P'), 1081 ISAPNP_FUNCTION(0x1542), pdev); 1082 if(pdev==NULL) 1083 break; 1084 /* 1085 * Activate the PnP card 1086 */ 1087 1088 if(pnp_device_attach(pdev)<0) 1089 continue; 1090 1091 if(pnp_activate_dev(pdev)<0) { 1092 pnp_device_detach(pdev); 1093 continue; 1094 } 1095 1096 if(!pnp_port_valid(pdev, 0)) { 1097 pnp_device_detach(pdev); 1098 continue; 1099 } 1100 1101 bases[indx] = pnp_port_start(pdev, 0); 1102 1103 /* The card can be queried for its DMA, we have 1104 the DMA set up that is enough */ 1105 1106 printk(KERN_INFO "ISAPnP found an AHA1535 at I/O 0x%03X\n", bases[indx]); 1107 } 1108 } 1109 for (indx = 0; indx < ARRAY_SIZE(bases); indx++) 1110 if (bases[indx] != 0 && request_region(bases[indx], 4, "aha1542")) { 1111 shpnt = scsi_register(tpnt, 1112 sizeof(struct aha1542_hostdata)); 1113 1114 if(shpnt==NULL) { 1115 release_region(bases[indx], 4); 1116 continue; 1117 } 1118 if (!aha1542_test_port(bases[indx], shpnt)) 1119 goto unregister; 1120 1121 base_io = bases[indx]; 1122 1123 /* Set the Bus on/off-times as not to ruin floppy performance */ 1124 { 1125 unchar oncmd[] = {CMD_BUSON_TIME, 7}; 1126 unchar offcmd[] = {CMD_BUSOFF_TIME, 5}; 1127 1128 if (setup_called[indx]) { 1129 oncmd[1] = setup_buson[indx]; 1130 offcmd[1] = setup_busoff[indx]; 1131 } 1132 aha1542_intr_reset(base_io); 1133 aha1542_out(base_io, oncmd, 2); 1134 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0); 1135 aha1542_intr_reset(base_io); 1136 aha1542_out(base_io, offcmd, 2); 1137 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0); 1138 if (setup_dmaspeed[indx] >= 0) { 1139 unchar dmacmd[] = {CMD_DMASPEED, 0}; 1140 dmacmd[1] = setup_dmaspeed[indx]; 1141 aha1542_intr_reset(base_io); 1142 aha1542_out(base_io, dmacmd, 2); 1143 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0); 1144 } 1145 while (0) { 1146 fail: 1147 printk(KERN_ERR "aha1542_detect: setting bus on/off-time failed\n"); 1148 } 1149 aha1542_intr_reset(base_io); 1150 } 1151 if (aha1542_query(base_io, &trans)) 1152 goto unregister; 1153 1154 if (aha1542_getconfig(base_io, &irq_level, &dma_chan, &scsi_id) == -1) 1155 goto unregister; 1156 1157 printk(KERN_INFO "Configuring Adaptec (SCSI-ID %d) at IO:%x, IRQ %d", scsi_id, base_io, irq_level); 1158 if (dma_chan != 0xFF) 1159 printk(", DMA priority %d", dma_chan); 1160 printk("\n"); 1161 1162 DEB(aha1542_stat()); 1163 setup_mailboxes(base_io, shpnt); 1164 1165 DEB(aha1542_stat()); 1166 1167 DEB(printk("aha1542_detect: enable interrupt channel %d\n", irq_level)); 1168 spin_lock_irqsave(&aha1542_lock, flags); 1169 if (request_irq(irq_level, do_aha1542_intr_handle, 0, 1170 "aha1542", shpnt)) { 1171 printk(KERN_ERR "Unable to allocate IRQ for adaptec controller.\n"); 1172 spin_unlock_irqrestore(&aha1542_lock, flags); 1173 goto unregister; 1174 } 1175 if (dma_chan != 0xFF) { 1176 if (request_dma(dma_chan, "aha1542")) { 1177 printk(KERN_ERR "Unable to allocate DMA channel for Adaptec.\n"); 1178 free_irq(irq_level, shpnt); 1179 spin_unlock_irqrestore(&aha1542_lock, flags); 1180 goto unregister; 1181 } 1182 if (dma_chan == 0 || dma_chan >= 5) { 1183 set_dma_mode(dma_chan, DMA_MODE_CASCADE); 1184 enable_dma(dma_chan); 1185 } 1186 } 1187 1188 shpnt->this_id = scsi_id; 1189 shpnt->unique_id = base_io; 1190 shpnt->io_port = base_io; 1191 shpnt->n_io_port = 4; /* Number of bytes of I/O space used */ 1192 shpnt->dma_channel = dma_chan; 1193 shpnt->irq = irq_level; 1194 HOSTDATA(shpnt)->bios_translation = trans; 1195 if (trans == BIOS_TRANSLATION_25563) 1196 printk(KERN_INFO "aha1542.c: Using extended bios translation\n"); 1197 HOSTDATA(shpnt)->aha1542_last_mbi_used = (2 * AHA1542_MAILBOXES - 1); 1198 HOSTDATA(shpnt)->aha1542_last_mbo_used = (AHA1542_MAILBOXES - 1); 1199 memset(HOSTDATA(shpnt)->SCint, 0, sizeof(HOSTDATA(shpnt)->SCint)); 1200 spin_unlock_irqrestore(&aha1542_lock, flags); 1201 #if 0 1202 DEB(printk(" *** READ CAPACITY ***\n")); 1203 1204 { 1205 unchar buf[8]; 1206 static unchar cmd[] = { READ_CAPACITY, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; 1207 int i; 1208 1209 for (i = 0; i < sizeof(buf); ++i) 1210 buf[i] = 0x87; 1211 for (i = 0; i < 2; ++i) 1212 if (!aha1542_command(i, cmd, buf, sizeof(buf))) { 1213 printk(KERN_DEBUG "aha_detect: LU %d sector_size %d device_size %d\n", 1214 i, xscsi2int(buf + 4), xscsi2int(buf)); 1215 } 1216 } 1217 1218 DEB(printk(" *** NOW RUNNING MY OWN TEST *** \n")); 1219 1220 for (i = 0; i < 4; ++i) { 1221 unsigned char cmd[10]; 1222 static buffer[512]; 1223 1224 cmd[0] = READ_10; 1225 cmd[1] = 0; 1226 xany2scsi(cmd + 2, i); 1227 cmd[6] = 0; 1228 cmd[7] = 0; 1229 cmd[8] = 1; 1230 cmd[9] = 0; 1231 aha1542_command(0, cmd, buffer, 512); 1232 } 1233 #endif 1234 count++; 1235 continue; 1236 unregister: 1237 release_region(bases[indx], 4); 1238 scsi_unregister(shpnt); 1239 continue; 1240 1241 }; 1242 1243 return count; 1244 } 1245 1246 static int aha1542_release(struct Scsi_Host *shost) 1247 { 1248 if (shost->irq) 1249 free_irq(shost->irq, shost); 1250 if (shost->dma_channel != 0xff) 1251 free_dma(shost->dma_channel); 1252 if (shost->io_port && shost->n_io_port) 1253 release_region(shost->io_port, shost->n_io_port); 1254 scsi_unregister(shost); 1255 return 0; 1256 } 1257 1258 static int aha1542_restart(struct Scsi_Host *shost) 1259 { 1260 int i; 1261 int count = 0; 1262 #if 0 1263 unchar ahacmd = CMD_START_SCSI; 1264 #endif 1265 1266 for (i = 0; i < AHA1542_MAILBOXES; i++) 1267 if (HOSTDATA(shost)->SCint[i] && 1268 !(HOSTDATA(shost)->SCint[i]->device->soft_reset)) { 1269 #if 0 1270 HOSTDATA(shost)->mb[i].status = 1; /* Indicate ready to restart... */ 1271 #endif 1272 count++; 1273 } 1274 printk(KERN_DEBUG "Potential to restart %d stalled commands...\n", count); 1275 #if 0 1276 /* start scsi command */ 1277 if (count) 1278 aha1542_out(shost->io_port, &ahacmd, 1); 1279 #endif 1280 return 0; 1281 } 1282 1283 /* 1284 * This is a device reset. This is handled by sending a special command 1285 * to the device. 1286 */ 1287 static int aha1542_dev_reset(Scsi_Cmnd * SCpnt) 1288 { 1289 unsigned long flags; 1290 struct mailbox *mb; 1291 unchar target = SCpnt->device->id; 1292 unchar lun = SCpnt->device->lun; 1293 int mbo; 1294 struct ccb *ccb; 1295 unchar ahacmd = CMD_START_SCSI; 1296 1297 ccb = HOSTDATA(SCpnt->device->host)->ccb; 1298 mb = HOSTDATA(SCpnt->device->host)->mb; 1299 1300 spin_lock_irqsave(&aha1542_lock, flags); 1301 mbo = HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used + 1; 1302 if (mbo >= AHA1542_MAILBOXES) 1303 mbo = 0; 1304 1305 do { 1306 if (mb[mbo].status == 0 && HOSTDATA(SCpnt->device->host)->SCint[mbo] == NULL) 1307 break; 1308 mbo++; 1309 if (mbo >= AHA1542_MAILBOXES) 1310 mbo = 0; 1311 } while (mbo != HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used); 1312 1313 if (mb[mbo].status || HOSTDATA(SCpnt->device->host)->SCint[mbo]) 1314 panic("Unable to find empty mailbox for aha1542.\n"); 1315 1316 HOSTDATA(SCpnt->device->host)->SCint[mbo] = SCpnt; /* This will effectively 1317 prevent someone else from 1318 screwing with this cdb. */ 1319 1320 HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used = mbo; 1321 spin_unlock_irqrestore(&aha1542_lock, flags); 1322 1323 any2scsi(mb[mbo].ccbptr, SCSI_BUF_PA(&ccb[mbo])); /* This gets trashed for some reason */ 1324 1325 memset(&ccb[mbo], 0, sizeof(struct ccb)); 1326 1327 ccb[mbo].op = 0x81; /* BUS DEVICE RESET */ 1328 1329 ccb[mbo].idlun = (target & 7) << 5 | (lun & 7); /*SCSI Target Id */ 1330 1331 ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0; 1332 ccb[mbo].commlinkid = 0; 1333 1334 /* 1335 * Now tell the 1542 to flush all pending commands for this 1336 * target 1337 */ 1338 aha1542_out(SCpnt->device->host->io_port, &ahacmd, 1); 1339 1340 scmd_printk(KERN_WARNING, SCpnt, 1341 "Trying device reset for target\n"); 1342 1343 return SUCCESS; 1344 1345 1346 #ifdef ERIC_neverdef 1347 /* 1348 * With the 1542 we apparently never get an interrupt to 1349 * acknowledge a device reset being sent. Then again, Leonard 1350 * says we are doing this wrong in the first place... 1351 * 1352 * Take a wait and see attitude. If we get spurious interrupts, 1353 * then the device reset is doing something sane and useful, and 1354 * we will wait for the interrupt to post completion. 1355 */ 1356 printk(KERN_WARNING "Sent BUS DEVICE RESET to target %d\n", SCpnt->target); 1357 1358 /* 1359 * Free the command block for all commands running on this 1360 * target... 1361 */ 1362 for (i = 0; i < AHA1542_MAILBOXES; i++) { 1363 if (HOSTDATA(SCpnt->host)->SCint[i] && 1364 HOSTDATA(SCpnt->host)->SCint[i]->target == SCpnt->target) { 1365 Scsi_Cmnd *SCtmp; 1366 SCtmp = HOSTDATA(SCpnt->host)->SCint[i]; 1367 kfree(SCtmp->host_scribble); 1368 SCtmp->host_scribble = NULL; 1369 HOSTDATA(SCpnt->host)->SCint[i] = NULL; 1370 HOSTDATA(SCpnt->host)->mb[i].status = 0; 1371 } 1372 } 1373 return SUCCESS; 1374 1375 return FAILED; 1376 #endif /* ERIC_neverdef */ 1377 } 1378 1379 static int aha1542_bus_reset(Scsi_Cmnd * SCpnt) 1380 { 1381 int i; 1382 1383 /* 1384 * This does a scsi reset for all devices on the bus. 1385 * In principle, we could also reset the 1542 - should 1386 * we do this? Try this first, and we can add that later 1387 * if it turns out to be useful. 1388 */ 1389 outb(SCRST, CONTROL(SCpnt->device->host->io_port)); 1390 1391 /* 1392 * Wait for the thing to settle down a bit. Unfortunately 1393 * this is going to basically lock up the machine while we 1394 * wait for this to complete. To be 100% correct, we need to 1395 * check for timeout, and if we are doing something like this 1396 * we are pretty desperate anyways. 1397 */ 1398 ssleep(4); 1399 1400 spin_lock_irq(SCpnt->device->host->host_lock); 1401 1402 WAIT(STATUS(SCpnt->device->host->io_port), 1403 STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF); 1404 1405 /* 1406 * Now try to pick up the pieces. For all pending commands, 1407 * free any internal data structures, and basically clear things 1408 * out. We do not try and restart any commands or anything - 1409 * the strategy handler takes care of that crap. 1410 */ 1411 printk(KERN_WARNING "Sent BUS RESET to scsi host %d\n", SCpnt->device->host->host_no); 1412 1413 for (i = 0; i < AHA1542_MAILBOXES; i++) { 1414 if (HOSTDATA(SCpnt->device->host)->SCint[i] != NULL) { 1415 Scsi_Cmnd *SCtmp; 1416 SCtmp = HOSTDATA(SCpnt->device->host)->SCint[i]; 1417 1418 1419 if (SCtmp->device->soft_reset) { 1420 /* 1421 * If this device implements the soft reset option, 1422 * then it is still holding onto the command, and 1423 * may yet complete it. In this case, we don't 1424 * flush the data. 1425 */ 1426 continue; 1427 } 1428 kfree(SCtmp->host_scribble); 1429 SCtmp->host_scribble = NULL; 1430 HOSTDATA(SCpnt->device->host)->SCint[i] = NULL; 1431 HOSTDATA(SCpnt->device->host)->mb[i].status = 0; 1432 } 1433 } 1434 1435 spin_unlock_irq(SCpnt->device->host->host_lock); 1436 return SUCCESS; 1437 1438 fail: 1439 spin_unlock_irq(SCpnt->device->host->host_lock); 1440 return FAILED; 1441 } 1442 1443 static int aha1542_host_reset(Scsi_Cmnd * SCpnt) 1444 { 1445 int i; 1446 1447 /* 1448 * This does a scsi reset for all devices on the bus. 1449 * In principle, we could also reset the 1542 - should 1450 * we do this? Try this first, and we can add that later 1451 * if it turns out to be useful. 1452 */ 1453 outb(HRST | SCRST, CONTROL(SCpnt->device->host->io_port)); 1454 1455 /* 1456 * Wait for the thing to settle down a bit. Unfortunately 1457 * this is going to basically lock up the machine while we 1458 * wait for this to complete. To be 100% correct, we need to 1459 * check for timeout, and if we are doing something like this 1460 * we are pretty desperate anyways. 1461 */ 1462 ssleep(4); 1463 spin_lock_irq(SCpnt->device->host->host_lock); 1464 1465 WAIT(STATUS(SCpnt->device->host->io_port), 1466 STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF); 1467 1468 /* 1469 * We need to do this too before the 1542 can interact with 1470 * us again. 1471 */ 1472 setup_mailboxes(SCpnt->device->host->io_port, SCpnt->device->host); 1473 1474 /* 1475 * Now try to pick up the pieces. For all pending commands, 1476 * free any internal data structures, and basically clear things 1477 * out. We do not try and restart any commands or anything - 1478 * the strategy handler takes care of that crap. 1479 */ 1480 printk(KERN_WARNING "Sent BUS RESET to scsi host %d\n", SCpnt->device->host->host_no); 1481 1482 for (i = 0; i < AHA1542_MAILBOXES; i++) { 1483 if (HOSTDATA(SCpnt->device->host)->SCint[i] != NULL) { 1484 Scsi_Cmnd *SCtmp; 1485 SCtmp = HOSTDATA(SCpnt->device->host)->SCint[i]; 1486 1487 if (SCtmp->device->soft_reset) { 1488 /* 1489 * If this device implements the soft reset option, 1490 * then it is still holding onto the command, and 1491 * may yet complete it. In this case, we don't 1492 * flush the data. 1493 */ 1494 continue; 1495 } 1496 kfree(SCtmp->host_scribble); 1497 SCtmp->host_scribble = NULL; 1498 HOSTDATA(SCpnt->device->host)->SCint[i] = NULL; 1499 HOSTDATA(SCpnt->device->host)->mb[i].status = 0; 1500 } 1501 } 1502 1503 spin_unlock_irq(SCpnt->device->host->host_lock); 1504 return SUCCESS; 1505 1506 fail: 1507 spin_unlock_irq(SCpnt->device->host->host_lock); 1508 return FAILED; 1509 } 1510 1511 #if 0 1512 /* 1513 * These are the old error handling routines. They are only temporarily 1514 * here while we play with the new error handling code. 1515 */ 1516 static int aha1542_old_abort(Scsi_Cmnd * SCpnt) 1517 { 1518 #if 0 1519 unchar ahacmd = CMD_START_SCSI; 1520 unsigned long flags; 1521 struct mailbox *mb; 1522 int mbi, mbo, i; 1523 1524 printk(KERN_DEBUG "In aha1542_abort: %x %x\n", 1525 inb(STATUS(SCpnt->host->io_port)), 1526 inb(INTRFLAGS(SCpnt->host->io_port))); 1527 1528 spin_lock_irqsave(&aha1542_lock, flags); 1529 mb = HOSTDATA(SCpnt->host)->mb; 1530 mbi = HOSTDATA(SCpnt->host)->aha1542_last_mbi_used + 1; 1531 if (mbi >= 2 * AHA1542_MAILBOXES) 1532 mbi = AHA1542_MAILBOXES; 1533 1534 do { 1535 if (mb[mbi].status != 0) 1536 break; 1537 mbi++; 1538 if (mbi >= 2 * AHA1542_MAILBOXES) 1539 mbi = AHA1542_MAILBOXES; 1540 } while (mbi != HOSTDATA(SCpnt->host)->aha1542_last_mbi_used); 1541 spin_unlock_irqrestore(&aha1542_lock, flags); 1542 1543 if (mb[mbi].status) { 1544 printk(KERN_ERR "Lost interrupt discovered on irq %d - attempting to recover\n", 1545 SCpnt->host->irq); 1546 aha1542_intr_handle(SCpnt->host, NULL); 1547 return 0; 1548 } 1549 /* OK, no lost interrupt. Try looking to see how many pending commands 1550 we think we have. */ 1551 1552 for (i = 0; i < AHA1542_MAILBOXES; i++) 1553 if (HOSTDATA(SCpnt->host)->SCint[i]) { 1554 if (HOSTDATA(SCpnt->host)->SCint[i] == SCpnt) { 1555 printk(KERN_ERR "Timed out command pending for %s\n", 1556 SCpnt->request->rq_disk ? 1557 SCpnt->request->rq_disk->disk_name : "?" 1558 ); 1559 if (HOSTDATA(SCpnt->host)->mb[i].status) { 1560 printk(KERN_ERR "OGMB still full - restarting\n"); 1561 aha1542_out(SCpnt->host->io_port, &ahacmd, 1); 1562 }; 1563 } else 1564 printk(KERN_ERR "Other pending command %s\n", 1565 SCpnt->request->rq_disk ? 1566 SCpnt->request->rq_disk->disk_name : "?" 1567 ); 1568 } 1569 #endif 1570 1571 DEB(printk("aha1542_abort\n")); 1572 #if 0 1573 spin_lock_irqsave(&aha1542_lock, flags); 1574 for (mbo = 0; mbo < AHA1542_MAILBOXES; mbo++) { 1575 if (SCpnt == HOSTDATA(SCpnt->host)->SCint[mbo]) { 1576 mb[mbo].status = 2; /* Abort command */ 1577 aha1542_out(SCpnt->host->io_port, &ahacmd, 1); /* start scsi command */ 1578 spin_unlock_irqrestore(&aha1542_lock, flags); 1579 break; 1580 } 1581 } 1582 if (AHA1542_MAILBOXES == mbo) 1583 spin_unlock_irqrestore(&aha1542_lock, flags); 1584 #endif 1585 return SCSI_ABORT_SNOOZE; 1586 } 1587 1588 /* We do not implement a reset function here, but the upper level code 1589 assumes that it will get some kind of response for the command in 1590 SCpnt. We must oblige, or the command will hang the scsi system. 1591 For a first go, we assume that the 1542 notifies us with all of the 1592 pending commands (it does implement soft reset, after all). */ 1593 1594 static int aha1542_old_reset(Scsi_Cmnd * SCpnt, unsigned int reset_flags) 1595 { 1596 unchar ahacmd = CMD_START_SCSI; 1597 int i; 1598 1599 /* 1600 * See if a bus reset was suggested. 1601 */ 1602 if (reset_flags & SCSI_RESET_SUGGEST_BUS_RESET) { 1603 /* 1604 * This does a scsi reset for all devices on the bus. 1605 * In principle, we could also reset the 1542 - should 1606 * we do this? Try this first, and we can add that later 1607 * if it turns out to be useful. 1608 */ 1609 outb(HRST | SCRST, CONTROL(SCpnt->host->io_port)); 1610 1611 /* 1612 * Wait for the thing to settle down a bit. Unfortunately 1613 * this is going to basically lock up the machine while we 1614 * wait for this to complete. To be 100% correct, we need to 1615 * check for timeout, and if we are doing something like this 1616 * we are pretty desperate anyways. 1617 */ 1618 WAIT(STATUS(SCpnt->host->io_port), 1619 STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF); 1620 1621 /* 1622 * We need to do this too before the 1542 can interact with 1623 * us again. 1624 */ 1625 setup_mailboxes(SCpnt->host->io_port, SCpnt->host); 1626 1627 /* 1628 * Now try to pick up the pieces. Restart all commands 1629 * that are currently active on the bus, and reset all of 1630 * the datastructures. We have some time to kill while 1631 * things settle down, so print a nice message. 1632 */ 1633 printk(KERN_WARNING "Sent BUS RESET to scsi host %d\n", SCpnt->host->host_no); 1634 1635 for (i = 0; i < AHA1542_MAILBOXES; i++) 1636 if (HOSTDATA(SCpnt->host)->SCint[i] != NULL) { 1637 Scsi_Cmnd *SCtmp; 1638 SCtmp = HOSTDATA(SCpnt->host)->SCint[i]; 1639 SCtmp->result = DID_RESET << 16; 1640 kfree(SCtmp->host_scribble); 1641 SCtmp->host_scribble = NULL; 1642 printk(KERN_WARNING "Sending DID_RESET for target %d\n", SCpnt->target); 1643 SCtmp->scsi_done(SCpnt); 1644 1645 HOSTDATA(SCpnt->host)->SCint[i] = NULL; 1646 HOSTDATA(SCpnt->host)->mb[i].status = 0; 1647 } 1648 /* 1649 * Now tell the mid-level code what we did here. Since 1650 * we have restarted all of the outstanding commands, 1651 * then report SUCCESS. 1652 */ 1653 return (SCSI_RESET_SUCCESS | SCSI_RESET_BUS_RESET); 1654 fail: 1655 printk(KERN_CRIT "aha1542.c: Unable to perform hard reset.\n"); 1656 printk(KERN_CRIT "Power cycle machine to reset\n"); 1657 return (SCSI_RESET_ERROR | SCSI_RESET_BUS_RESET); 1658 1659 1660 } else { 1661 /* This does a selective reset of just the one device */ 1662 /* First locate the ccb for this command */ 1663 for (i = 0; i < AHA1542_MAILBOXES; i++) 1664 if (HOSTDATA(SCpnt->host)->SCint[i] == SCpnt) { 1665 HOSTDATA(SCpnt->host)->ccb[i].op = 0x81; /* BUS DEVICE RESET */ 1666 /* Now tell the 1542 to flush all pending commands for this target */ 1667 aha1542_out(SCpnt->host->io_port, &ahacmd, 1); 1668 1669 /* Here is the tricky part. What to do next. Do we get an interrupt 1670 for the commands that we aborted with the specified target, or 1671 do we generate this on our own? Try it without first and see 1672 what happens */ 1673 printk(KERN_WARNING "Sent BUS DEVICE RESET to target %d\n", SCpnt->target); 1674 1675 /* If the first does not work, then try the second. I think the 1676 first option is more likely to be correct. Free the command 1677 block for all commands running on this target... */ 1678 for (i = 0; i < AHA1542_MAILBOXES; i++) 1679 if (HOSTDATA(SCpnt->host)->SCint[i] && 1680 HOSTDATA(SCpnt->host)->SCint[i]->target == SCpnt->target) { 1681 Scsi_Cmnd *SCtmp; 1682 SCtmp = HOSTDATA(SCpnt->host)->SCint[i]; 1683 SCtmp->result = DID_RESET << 16; 1684 kfree(SCtmp->host_scribble); 1685 SCtmp->host_scribble = NULL; 1686 printk(KERN_WARNING "Sending DID_RESET for target %d\n", SCpnt->target); 1687 SCtmp->scsi_done(SCpnt); 1688 1689 HOSTDATA(SCpnt->host)->SCint[i] = NULL; 1690 HOSTDATA(SCpnt->host)->mb[i].status = 0; 1691 } 1692 return SCSI_RESET_SUCCESS; 1693 } 1694 } 1695 /* No active command at this time, so this means that each time we got 1696 some kind of response the last time through. Tell the mid-level code 1697 to request sense information in order to decide what to do next. */ 1698 return SCSI_RESET_PUNT; 1699 } 1700 #endif /* end of big comment block around old_abort + old_reset */ 1701 1702 static int aha1542_biosparam(struct scsi_device *sdev, 1703 struct block_device *bdev, sector_t capacity, int *ip) 1704 { 1705 int translation_algorithm; 1706 int size = capacity; 1707 1708 translation_algorithm = HOSTDATA(sdev->host)->bios_translation; 1709 1710 if ((size >> 11) > 1024 && translation_algorithm == BIOS_TRANSLATION_25563) { 1711 /* Please verify that this is the same as what DOS returns */ 1712 ip[0] = 255; 1713 ip[1] = 63; 1714 ip[2] = size / 255 / 63; 1715 } else { 1716 ip[0] = 64; 1717 ip[1] = 32; 1718 ip[2] = size >> 11; 1719 } 1720 1721 return 0; 1722 } 1723 MODULE_LICENSE("GPL"); 1724 1725 1726 static struct scsi_host_template driver_template = { 1727 .proc_name = "aha1542", 1728 .name = "Adaptec 1542", 1729 .detect = aha1542_detect, 1730 .release = aha1542_release, 1731 .queuecommand = aha1542_queuecommand, 1732 .eh_device_reset_handler= aha1542_dev_reset, 1733 .eh_bus_reset_handler = aha1542_bus_reset, 1734 .eh_host_reset_handler = aha1542_host_reset, 1735 .bios_param = aha1542_biosparam, 1736 .can_queue = AHA1542_MAILBOXES, 1737 .this_id = 7, 1738 .sg_tablesize = AHA1542_SCATTER, 1739 .cmd_per_lun = AHA1542_CMDLUN, 1740 .unchecked_isa_dma = 1, 1741 .use_clustering = ENABLE_CLUSTERING, 1742 }; 1743 #include "scsi_module.c" 1744