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