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