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