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