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