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