1 /* 2 * Driver for Adaptec AHA-1542 SCSI host adapters 3 * 4 * Copyright (C) 1992 Tommy Thorn 5 * Copyright (C) 1993, 1994, 1995 Eric Youngdale 6 * Copyright (C) 2015 Ondrej Zary 7 */ 8 9 #include <linux/module.h> 10 #include <linux/interrupt.h> 11 #include <linux/kernel.h> 12 #include <linux/types.h> 13 #include <linux/string.h> 14 #include <linux/delay.h> 15 #include <linux/init.h> 16 #include <linux/spinlock.h> 17 #include <linux/isa.h> 18 #include <linux/pnp.h> 19 #include <linux/slab.h> 20 #include <linux/io.h> 21 #include <asm/dma.h> 22 #include <scsi/scsi_cmnd.h> 23 #include <scsi/scsi_device.h> 24 #include <scsi/scsi_host.h> 25 #include "aha1542.h" 26 27 #define MAXBOARDS 4 28 29 static bool isapnp = 1; 30 module_param(isapnp, bool, 0); 31 MODULE_PARM_DESC(isapnp, "enable PnP support (default=1)"); 32 33 static int io[MAXBOARDS] = { 0x330, 0x334, 0, 0 }; 34 module_param_array(io, int, NULL, 0); 35 MODULE_PARM_DESC(io, "base IO address of controller (0x130,0x134,0x230,0x234,0x330,0x334, default=0x330,0x334)"); 36 37 /* time AHA spends on the AT-bus during data transfer */ 38 static int bus_on[MAXBOARDS] = { -1, -1, -1, -1 }; /* power-on default: 11us */ 39 module_param_array(bus_on, int, NULL, 0); 40 MODULE_PARM_DESC(bus_on, "bus on time [us] (2-15, default=-1 [HW default: 11])"); 41 42 /* time AHA spends off the bus (not to monopolize it) during data transfer */ 43 static int bus_off[MAXBOARDS] = { -1, -1, -1, -1 }; /* power-on default: 4us */ 44 module_param_array(bus_off, int, NULL, 0); 45 MODULE_PARM_DESC(bus_off, "bus off time [us] (1-64, default=-1 [HW default: 4])"); 46 47 /* default is jumper selected (J1 on 1542A), factory default = 5 MB/s */ 48 static int dma_speed[MAXBOARDS] = { -1, -1, -1, -1 }; 49 module_param_array(dma_speed, int, NULL, 0); 50 MODULE_PARM_DESC(dma_speed, "DMA speed [MB/s] (5,6,7,8,10, default=-1 [by jumper])"); 51 52 #define BIOS_TRANSLATION_6432 1 /* Default case these days */ 53 #define BIOS_TRANSLATION_25563 2 /* Big disk case */ 54 55 struct aha1542_hostdata { 56 /* This will effectively start both of them at the first mailbox */ 57 int bios_translation; /* Mapping bios uses - for compatibility */ 58 int aha1542_last_mbi_used; 59 int aha1542_last_mbo_used; 60 struct scsi_cmnd *int_cmds[AHA1542_MAILBOXES]; 61 struct mailbox mb[2 * AHA1542_MAILBOXES]; 62 struct ccb ccb[AHA1542_MAILBOXES]; 63 }; 64 65 static inline void aha1542_intr_reset(u16 base) 66 { 67 outb(IRST, CONTROL(base)); 68 } 69 70 static inline bool wait_mask(u16 port, u8 mask, u8 allof, u8 noneof, int timeout) 71 { 72 bool delayed = true; 73 74 if (timeout == 0) { 75 timeout = 3000000; 76 delayed = false; 77 } 78 79 while (1) { 80 u8 bits = inb(port) & mask; 81 if ((bits & allof) == allof && ((bits & noneof) == 0)) 82 break; 83 if (delayed) 84 mdelay(1); 85 if (--timeout == 0) 86 return false; 87 } 88 89 return true; 90 } 91 92 static int aha1542_outb(unsigned int base, u8 val) 93 { 94 if (!wait_mask(STATUS(base), CDF, 0, CDF, 0)) 95 return 1; 96 outb(val, DATA(base)); 97 98 return 0; 99 } 100 101 static int aha1542_out(unsigned int base, u8 *buf, int len) 102 { 103 while (len--) { 104 if (!wait_mask(STATUS(base), CDF, 0, CDF, 0)) 105 return 1; 106 outb(*buf++, DATA(base)); 107 } 108 if (!wait_mask(INTRFLAGS(base), INTRMASK, HACC, 0, 0)) 109 return 1; 110 111 return 0; 112 } 113 114 /* Only used at boot time, so we do not need to worry about latency as much 115 here */ 116 117 static int aha1542_in(unsigned int base, u8 *buf, int len, int timeout) 118 { 119 while (len--) { 120 if (!wait_mask(STATUS(base), DF, DF, 0, timeout)) 121 return 1; 122 *buf++ = inb(DATA(base)); 123 } 124 return 0; 125 } 126 127 static int makecode(unsigned hosterr, unsigned scsierr) 128 { 129 switch (hosterr) { 130 case 0x0: 131 case 0xa: /* Linked command complete without error and linked normally */ 132 case 0xb: /* Linked command complete without error, interrupt generated */ 133 hosterr = 0; 134 break; 135 136 case 0x11: /* Selection time out-The initiator selection or target 137 reselection was not complete within the SCSI Time out period */ 138 hosterr = DID_TIME_OUT; 139 break; 140 141 case 0x12: /* Data overrun/underrun-The target attempted to transfer more data 142 than was allocated by the Data Length field or the sum of the 143 Scatter / Gather Data Length fields. */ 144 145 case 0x13: /* Unexpected bus free-The target dropped the SCSI BSY at an unexpected time. */ 146 147 case 0x15: /* MBO command was not 00, 01 or 02-The first byte of the CB was 148 invalid. This usually indicates a software failure. */ 149 150 case 0x16: /* Invalid CCB Operation Code-The first byte of the CCB was invalid. 151 This usually indicates a software failure. */ 152 153 case 0x17: /* Linked CCB does not have the same LUN-A subsequent CCB of a set 154 of linked CCB's does not specify the same logical unit number as 155 the first. */ 156 case 0x18: /* Invalid Target Direction received from Host-The direction of a 157 Target Mode CCB was invalid. */ 158 159 case 0x19: /* Duplicate CCB Received in Target Mode-More than once CCB was 160 received to service data transfer between the same target LUN 161 and initiator SCSI ID in the same direction. */ 162 163 case 0x1a: /* Invalid CCB or Segment List Parameter-A segment list with a zero 164 length segment or invalid segment list boundaries was received. 165 A CCB parameter was invalid. */ 166 #ifdef DEBUG 167 printk("Aha1542: %x %x\n", hosterr, scsierr); 168 #endif 169 hosterr = DID_ERROR; /* Couldn't find any better */ 170 break; 171 172 case 0x14: /* Target bus phase sequence failure-An invalid bus phase or bus 173 phase sequence was requested by the target. The host adapter 174 will generate a SCSI Reset Condition, notifying the host with 175 a SCRD interrupt */ 176 hosterr = DID_RESET; 177 break; 178 default: 179 printk(KERN_ERR "aha1542: makecode: unknown hoststatus %x\n", hosterr); 180 break; 181 } 182 return scsierr | (hosterr << 16); 183 } 184 185 static int aha1542_test_port(struct Scsi_Host *sh) 186 { 187 u8 inquiry_result[4]; 188 int i; 189 190 /* Quick and dirty test for presence of the card. */ 191 if (inb(STATUS(sh->io_port)) == 0xff) 192 return 0; 193 194 /* Reset the adapter. I ought to make a hard reset, but it's not really necessary */ 195 196 /* In case some other card was probing here, reset interrupts */ 197 aha1542_intr_reset(sh->io_port); /* reset interrupts, so they don't block */ 198 199 outb(SRST | IRST /*|SCRST */ , CONTROL(sh->io_port)); 200 201 mdelay(20); /* Wait a little bit for things to settle down. */ 202 203 /* Expect INIT and IDLE, any of the others are bad */ 204 if (!wait_mask(STATUS(sh->io_port), STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF, 0)) 205 return 0; 206 207 /* Shouldn't have generated any interrupts during reset */ 208 if (inb(INTRFLAGS(sh->io_port)) & INTRMASK) 209 return 0; 210 211 /* Perform a host adapter inquiry instead so we do not need to set 212 up the mailboxes ahead of time */ 213 214 aha1542_outb(sh->io_port, CMD_INQUIRY); 215 216 for (i = 0; i < 4; i++) { 217 if (!wait_mask(STATUS(sh->io_port), DF, DF, 0, 0)) 218 return 0; 219 inquiry_result[i] = inb(DATA(sh->io_port)); 220 } 221 222 /* Reading port should reset DF */ 223 if (inb(STATUS(sh->io_port)) & DF) 224 return 0; 225 226 /* When HACC, command is completed, and we're though testing */ 227 if (!wait_mask(INTRFLAGS(sh->io_port), HACC, HACC, 0, 0)) 228 return 0; 229 230 /* Clear interrupts */ 231 outb(IRST, CONTROL(sh->io_port)); 232 233 return 1; 234 } 235 236 static irqreturn_t aha1542_interrupt(int irq, void *dev_id) 237 { 238 struct Scsi_Host *sh = dev_id; 239 struct aha1542_hostdata *aha1542 = shost_priv(sh); 240 void (*my_done)(struct scsi_cmnd *) = NULL; 241 int errstatus, mbi, mbo, mbistatus; 242 int number_serviced; 243 unsigned long flags; 244 struct scsi_cmnd *tmp_cmd; 245 int flag; 246 struct mailbox *mb = aha1542->mb; 247 struct ccb *ccb = aha1542->ccb; 248 249 #ifdef DEBUG 250 { 251 flag = inb(INTRFLAGS(sh->io_port)); 252 shost_printk(KERN_DEBUG, sh, "aha1542_intr_handle: "); 253 if (!(flag & ANYINTR)) 254 printk("no interrupt?"); 255 if (flag & MBIF) 256 printk("MBIF "); 257 if (flag & MBOA) 258 printk("MBOF "); 259 if (flag & HACC) 260 printk("HACC "); 261 if (flag & SCRD) 262 printk("SCRD "); 263 printk("status %02x\n", inb(STATUS(sh->io_port))); 264 }; 265 #endif 266 number_serviced = 0; 267 268 spin_lock_irqsave(sh->host_lock, flags); 269 while (1) { 270 flag = inb(INTRFLAGS(sh->io_port)); 271 272 /* Check for unusual interrupts. If any of these happen, we should 273 probably do something special, but for now just printing a message 274 is sufficient. A SCSI reset detected is something that we really 275 need to deal with in some way. */ 276 if (flag & ~MBIF) { 277 if (flag & MBOA) 278 printk("MBOF "); 279 if (flag & HACC) 280 printk("HACC "); 281 if (flag & SCRD) 282 printk("SCRD "); 283 } 284 aha1542_intr_reset(sh->io_port); 285 286 mbi = aha1542->aha1542_last_mbi_used + 1; 287 if (mbi >= 2 * AHA1542_MAILBOXES) 288 mbi = AHA1542_MAILBOXES; 289 290 do { 291 if (mb[mbi].status != 0) 292 break; 293 mbi++; 294 if (mbi >= 2 * AHA1542_MAILBOXES) 295 mbi = AHA1542_MAILBOXES; 296 } while (mbi != aha1542->aha1542_last_mbi_used); 297 298 if (mb[mbi].status == 0) { 299 spin_unlock_irqrestore(sh->host_lock, flags); 300 /* Hmm, no mail. Must have read it the last time around */ 301 if (!number_serviced) 302 shost_printk(KERN_WARNING, sh, "interrupt received, but no mail.\n"); 303 return IRQ_HANDLED; 304 }; 305 306 mbo = (scsi2int(mb[mbi].ccbptr) - (isa_virt_to_bus(&ccb[0]))) / sizeof(struct ccb); 307 mbistatus = mb[mbi].status; 308 mb[mbi].status = 0; 309 aha1542->aha1542_last_mbi_used = mbi; 310 311 #ifdef DEBUG 312 if (ccb[mbo].tarstat | ccb[mbo].hastat) 313 shost_printk(KERN_DEBUG, sh, "aha1542_command: returning %x (status %d)\n", 314 ccb[mbo].tarstat + ((int) ccb[mbo].hastat << 16), mb[mbi].status); 315 #endif 316 317 if (mbistatus == 3) 318 continue; /* Aborted command not found */ 319 320 #ifdef DEBUG 321 shost_printk(KERN_DEBUG, sh, "...done %d %d\n", mbo, mbi); 322 #endif 323 324 tmp_cmd = aha1542->int_cmds[mbo]; 325 326 if (!tmp_cmd || !tmp_cmd->scsi_done) { 327 spin_unlock_irqrestore(sh->host_lock, flags); 328 shost_printk(KERN_WARNING, sh, "Unexpected interrupt\n"); 329 shost_printk(KERN_WARNING, sh, "tarstat=%x, hastat=%x idlun=%x ccb#=%d\n", ccb[mbo].tarstat, 330 ccb[mbo].hastat, ccb[mbo].idlun, mbo); 331 return IRQ_HANDLED; 332 } 333 my_done = tmp_cmd->scsi_done; 334 kfree(tmp_cmd->host_scribble); 335 tmp_cmd->host_scribble = NULL; 336 /* Fetch the sense data, and tuck it away, in the required slot. The 337 Adaptec automatically fetches it, and there is no guarantee that 338 we will still have it in the cdb when we come back */ 339 if (ccb[mbo].tarstat == 2) 340 memcpy(tmp_cmd->sense_buffer, &ccb[mbo].cdb[ccb[mbo].cdblen], 341 SCSI_SENSE_BUFFERSIZE); 342 343 344 /* is there mail :-) */ 345 346 /* more error checking left out here */ 347 if (mbistatus != 1) 348 /* This is surely wrong, but I don't know what's right */ 349 errstatus = makecode(ccb[mbo].hastat, ccb[mbo].tarstat); 350 else 351 errstatus = 0; 352 353 #ifdef DEBUG 354 if (errstatus) 355 shost_printk(KERN_DEBUG, sh, "(aha1542 error:%x %x %x) ", errstatus, 356 ccb[mbo].hastat, ccb[mbo].tarstat); 357 if (ccb[mbo].tarstat == 2) 358 print_hex_dump_bytes("sense: ", DUMP_PREFIX_NONE, &ccb[mbo].cdb[ccb[mbo].cdblen], 12); 359 if (errstatus) 360 printk("aha1542_intr_handle: returning %6x\n", errstatus); 361 #endif 362 tmp_cmd->result = errstatus; 363 aha1542->int_cmds[mbo] = NULL; /* This effectively frees up the mailbox slot, as 364 far as queuecommand is concerned */ 365 my_done(tmp_cmd); 366 number_serviced++; 367 }; 368 } 369 370 static int aha1542_queuecommand(struct Scsi_Host *sh, struct scsi_cmnd *cmd) 371 { 372 struct aha1542_hostdata *aha1542 = shost_priv(sh); 373 u8 direction; 374 u8 target = cmd->device->id; 375 u8 lun = cmd->device->lun; 376 unsigned long flags; 377 int bufflen = scsi_bufflen(cmd); 378 int mbo, sg_count; 379 struct mailbox *mb = aha1542->mb; 380 struct ccb *ccb = aha1542->ccb; 381 struct chain *cptr; 382 383 if (*cmd->cmnd == REQUEST_SENSE) { 384 /* Don't do the command - we have the sense data already */ 385 cmd->result = 0; 386 cmd->scsi_done(cmd); 387 return 0; 388 } 389 #ifdef DEBUG 390 { 391 int i = -1; 392 if (*cmd->cmnd == READ_10 || *cmd->cmnd == WRITE_10) 393 i = xscsi2int(cmd->cmnd + 2); 394 else if (*cmd->cmnd == READ_6 || *cmd->cmnd == WRITE_6) 395 i = scsi2int(cmd->cmnd + 2); 396 shost_printk(KERN_DEBUG, sh, "aha1542_queuecommand: dev %d cmd %02x pos %d len %d", 397 target, *cmd->cmnd, i, bufflen); 398 print_hex_dump_bytes("command: ", DUMP_PREFIX_NONE, cmd->cmnd, cmd->cmd_len); 399 } 400 #endif 401 if (bufflen) { /* allocate memory before taking host_lock */ 402 sg_count = scsi_sg_count(cmd); 403 cptr = kmalloc(sizeof(*cptr) * sg_count, GFP_KERNEL | GFP_DMA); 404 if (!cptr) 405 return SCSI_MLQUEUE_HOST_BUSY; 406 } 407 408 /* Use the outgoing mailboxes in a round-robin fashion, because this 409 is how the host adapter will scan for them */ 410 411 spin_lock_irqsave(sh->host_lock, flags); 412 mbo = aha1542->aha1542_last_mbo_used + 1; 413 if (mbo >= AHA1542_MAILBOXES) 414 mbo = 0; 415 416 do { 417 if (mb[mbo].status == 0 && aha1542->int_cmds[mbo] == NULL) 418 break; 419 mbo++; 420 if (mbo >= AHA1542_MAILBOXES) 421 mbo = 0; 422 } while (mbo != aha1542->aha1542_last_mbo_used); 423 424 if (mb[mbo].status || aha1542->int_cmds[mbo]) 425 panic("Unable to find empty mailbox for aha1542.\n"); 426 427 aha1542->int_cmds[mbo] = cmd; /* This will effectively prevent someone else from 428 screwing with this cdb. */ 429 430 aha1542->aha1542_last_mbo_used = mbo; 431 432 #ifdef DEBUG 433 shost_printk(KERN_DEBUG, sh, "Sending command (%d %p)...", mbo, cmd->scsi_done); 434 #endif 435 436 any2scsi(mb[mbo].ccbptr, isa_virt_to_bus(&ccb[mbo])); /* This gets trashed for some reason */ 437 438 memset(&ccb[mbo], 0, sizeof(struct ccb)); 439 440 ccb[mbo].cdblen = cmd->cmd_len; 441 442 direction = 0; 443 if (*cmd->cmnd == READ_10 || *cmd->cmnd == READ_6) 444 direction = 8; 445 else if (*cmd->cmnd == WRITE_10 || *cmd->cmnd == WRITE_6) 446 direction = 16; 447 448 memcpy(ccb[mbo].cdb, cmd->cmnd, ccb[mbo].cdblen); 449 450 if (bufflen) { 451 struct scatterlist *sg; 452 int i; 453 454 ccb[mbo].op = 2; /* SCSI Initiator Command w/scatter-gather */ 455 cmd->host_scribble = (void *)cptr; 456 scsi_for_each_sg(cmd, sg, sg_count, i) { 457 any2scsi(cptr[i].dataptr, isa_page_to_bus(sg_page(sg)) 458 + sg->offset); 459 any2scsi(cptr[i].datalen, sg->length); 460 }; 461 any2scsi(ccb[mbo].datalen, sg_count * sizeof(struct chain)); 462 any2scsi(ccb[mbo].dataptr, isa_virt_to_bus(cptr)); 463 #ifdef DEBUG 464 shost_printk(KERN_DEBUG, sh, "cptr %p: ", cptr); 465 print_hex_dump_bytes("cptr: ", DUMP_PREFIX_NONE, cptr, 18); 466 #endif 467 } else { 468 ccb[mbo].op = 0; /* SCSI Initiator Command */ 469 cmd->host_scribble = NULL; 470 any2scsi(ccb[mbo].datalen, 0); 471 any2scsi(ccb[mbo].dataptr, 0); 472 }; 473 ccb[mbo].idlun = (target & 7) << 5 | direction | (lun & 7); /*SCSI Target Id */ 474 ccb[mbo].rsalen = 16; 475 ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0; 476 ccb[mbo].commlinkid = 0; 477 478 #ifdef DEBUG 479 print_hex_dump_bytes("sending: ", DUMP_PREFIX_NONE, &ccb[mbo], sizeof(ccb[mbo]) - 10); 480 printk("aha1542_queuecommand: now waiting for interrupt "); 481 #endif 482 mb[mbo].status = 1; 483 aha1542_outb(cmd->device->host->io_port, CMD_START_SCSI); 484 spin_unlock_irqrestore(sh->host_lock, flags); 485 486 return 0; 487 } 488 489 /* Initialize mailboxes */ 490 static void setup_mailboxes(struct Scsi_Host *sh) 491 { 492 struct aha1542_hostdata *aha1542 = shost_priv(sh); 493 int i; 494 struct mailbox *mb = aha1542->mb; 495 struct ccb *ccb = aha1542->ccb; 496 497 u8 mb_cmd[5] = { CMD_MBINIT, AHA1542_MAILBOXES, 0, 0, 0}; 498 499 for (i = 0; i < AHA1542_MAILBOXES; i++) { 500 mb[i].status = mb[AHA1542_MAILBOXES + i].status = 0; 501 any2scsi(mb[i].ccbptr, isa_virt_to_bus(&ccb[i])); 502 }; 503 aha1542_intr_reset(sh->io_port); /* reset interrupts, so they don't block */ 504 any2scsi((mb_cmd + 2), isa_virt_to_bus(mb)); 505 if (aha1542_out(sh->io_port, mb_cmd, 5)) 506 shost_printk(KERN_ERR, sh, "failed setting up mailboxes\n"); 507 aha1542_intr_reset(sh->io_port); 508 } 509 510 static int aha1542_getconfig(struct Scsi_Host *sh) 511 { 512 u8 inquiry_result[3]; 513 int i; 514 i = inb(STATUS(sh->io_port)); 515 if (i & DF) { 516 i = inb(DATA(sh->io_port)); 517 }; 518 aha1542_outb(sh->io_port, CMD_RETCONF); 519 aha1542_in(sh->io_port, inquiry_result, 3, 0); 520 if (!wait_mask(INTRFLAGS(sh->io_port), INTRMASK, HACC, 0, 0)) 521 shost_printk(KERN_ERR, sh, "error querying board settings\n"); 522 aha1542_intr_reset(sh->io_port); 523 switch (inquiry_result[0]) { 524 case 0x80: 525 sh->dma_channel = 7; 526 break; 527 case 0x40: 528 sh->dma_channel = 6; 529 break; 530 case 0x20: 531 sh->dma_channel = 5; 532 break; 533 case 0x01: 534 sh->dma_channel = 0; 535 break; 536 case 0: 537 /* This means that the adapter, although Adaptec 1542 compatible, doesn't use a DMA channel. 538 Currently only aware of the BusLogic BT-445S VL-Bus adapter which needs this. */ 539 sh->dma_channel = 0xFF; 540 break; 541 default: 542 shost_printk(KERN_ERR, sh, "Unable to determine DMA channel.\n"); 543 return -1; 544 }; 545 switch (inquiry_result[1]) { 546 case 0x40: 547 sh->irq = 15; 548 break; 549 case 0x20: 550 sh->irq = 14; 551 break; 552 case 0x8: 553 sh->irq = 12; 554 break; 555 case 0x4: 556 sh->irq = 11; 557 break; 558 case 0x2: 559 sh->irq = 10; 560 break; 561 case 0x1: 562 sh->irq = 9; 563 break; 564 default: 565 shost_printk(KERN_ERR, sh, "Unable to determine IRQ level.\n"); 566 return -1; 567 }; 568 sh->this_id = inquiry_result[2] & 7; 569 return 0; 570 } 571 572 /* This function should only be called for 1542C boards - we can detect 573 the special firmware settings and unlock the board */ 574 575 static int aha1542_mbenable(struct Scsi_Host *sh) 576 { 577 static u8 mbenable_cmd[3]; 578 static u8 mbenable_result[2]; 579 int retval; 580 581 retval = BIOS_TRANSLATION_6432; 582 583 aha1542_outb(sh->io_port, CMD_EXTBIOS); 584 if (aha1542_in(sh->io_port, mbenable_result, 2, 100)) 585 return retval; 586 if (!wait_mask(INTRFLAGS(sh->io_port), INTRMASK, HACC, 0, 100)) 587 goto fail; 588 aha1542_intr_reset(sh->io_port); 589 590 if ((mbenable_result[0] & 0x08) || mbenable_result[1]) { 591 mbenable_cmd[0] = CMD_MBENABLE; 592 mbenable_cmd[1] = 0; 593 mbenable_cmd[2] = mbenable_result[1]; 594 595 if ((mbenable_result[0] & 0x08) && (mbenable_result[1] & 0x03)) 596 retval = BIOS_TRANSLATION_25563; 597 598 if (aha1542_out(sh->io_port, mbenable_cmd, 3)) 599 goto fail; 600 }; 601 while (0) { 602 fail: 603 shost_printk(KERN_ERR, sh, "Mailbox init failed\n"); 604 } 605 aha1542_intr_reset(sh->io_port); 606 return retval; 607 } 608 609 /* Query the board to find out if it is a 1542 or a 1740, or whatever. */ 610 static int aha1542_query(struct Scsi_Host *sh) 611 { 612 struct aha1542_hostdata *aha1542 = shost_priv(sh); 613 u8 inquiry_result[4]; 614 int i; 615 i = inb(STATUS(sh->io_port)); 616 if (i & DF) { 617 i = inb(DATA(sh->io_port)); 618 }; 619 aha1542_outb(sh->io_port, CMD_INQUIRY); 620 aha1542_in(sh->io_port, inquiry_result, 4, 0); 621 if (!wait_mask(INTRFLAGS(sh->io_port), INTRMASK, HACC, 0, 0)) 622 shost_printk(KERN_ERR, sh, "error querying card type\n"); 623 aha1542_intr_reset(sh->io_port); 624 625 aha1542->bios_translation = BIOS_TRANSLATION_6432; /* Default case */ 626 627 /* For an AHA1740 series board, we ignore the board since there is a 628 hardware bug which can lead to wrong blocks being returned if the board 629 is operating in the 1542 emulation mode. Since there is an extended mode 630 driver, we simply ignore the board and let the 1740 driver pick it up. 631 */ 632 633 if (inquiry_result[0] == 0x43) { 634 shost_printk(KERN_INFO, sh, "Emulation mode not supported for AHA-1740 hardware, use aha1740 driver instead.\n"); 635 return 1; 636 }; 637 638 /* Always call this - boards that do not support extended bios translation 639 will ignore the command, and we will set the proper default */ 640 641 aha1542->bios_translation = aha1542_mbenable(sh); 642 643 return 0; 644 } 645 646 static u8 dma_speed_hw(int dma_speed) 647 { 648 switch (dma_speed) { 649 case 5: 650 return 0x00; 651 case 6: 652 return 0x04; 653 case 7: 654 return 0x01; 655 case 8: 656 return 0x02; 657 case 10: 658 return 0x03; 659 } 660 661 return 0xff; /* invalid */ 662 } 663 664 /* Set the Bus on/off-times as not to ruin floppy performance */ 665 static void aha1542_set_bus_times(struct Scsi_Host *sh, int bus_on, int bus_off, int dma_speed) 666 { 667 if (bus_on > 0) { 668 u8 oncmd[] = { CMD_BUSON_TIME, clamp(bus_on, 2, 15) }; 669 670 aha1542_intr_reset(sh->io_port); 671 if (aha1542_out(sh->io_port, oncmd, 2)) 672 goto fail; 673 } 674 675 if (bus_off > 0) { 676 u8 offcmd[] = { CMD_BUSOFF_TIME, clamp(bus_off, 1, 64) }; 677 678 aha1542_intr_reset(sh->io_port); 679 if (aha1542_out(sh->io_port, offcmd, 2)) 680 goto fail; 681 } 682 683 if (dma_speed_hw(dma_speed) != 0xff) { 684 u8 dmacmd[] = { CMD_DMASPEED, dma_speed_hw(dma_speed) }; 685 686 aha1542_intr_reset(sh->io_port); 687 if (aha1542_out(sh->io_port, dmacmd, 2)) 688 goto fail; 689 } 690 aha1542_intr_reset(sh->io_port); 691 return; 692 fail: 693 shost_printk(KERN_ERR, sh, "setting bus on/off-time failed\n"); 694 aha1542_intr_reset(sh->io_port); 695 } 696 697 /* return non-zero on detection */ 698 static struct Scsi_Host *aha1542_hw_init(struct scsi_host_template *tpnt, struct device *pdev, int indx) 699 { 700 unsigned int base_io = io[indx]; 701 struct Scsi_Host *sh; 702 struct aha1542_hostdata *aha1542; 703 char dma_info[] = "no DMA"; 704 705 if (base_io == 0) 706 return NULL; 707 708 if (!request_region(base_io, AHA1542_REGION_SIZE, "aha1542")) 709 return NULL; 710 711 sh = scsi_host_alloc(tpnt, sizeof(struct aha1542_hostdata)); 712 if (!sh) 713 goto release; 714 aha1542 = shost_priv(sh); 715 716 sh->unique_id = base_io; 717 sh->io_port = base_io; 718 sh->n_io_port = AHA1542_REGION_SIZE; 719 aha1542->aha1542_last_mbi_used = 2 * AHA1542_MAILBOXES - 1; 720 aha1542->aha1542_last_mbo_used = AHA1542_MAILBOXES - 1; 721 722 if (!aha1542_test_port(sh)) 723 goto unregister; 724 725 aha1542_set_bus_times(sh, bus_on[indx], bus_off[indx], dma_speed[indx]); 726 if (aha1542_query(sh)) 727 goto unregister; 728 if (aha1542_getconfig(sh) == -1) 729 goto unregister; 730 731 if (sh->dma_channel != 0xFF) 732 snprintf(dma_info, sizeof(dma_info), "DMA %d", sh->dma_channel); 733 shost_printk(KERN_INFO, sh, "Adaptec AHA-1542 (SCSI-ID %d) at IO 0x%x, IRQ %d, %s\n", 734 sh->this_id, base_io, sh->irq, dma_info); 735 if (aha1542->bios_translation == BIOS_TRANSLATION_25563) 736 shost_printk(KERN_INFO, sh, "Using extended bios translation\n"); 737 738 setup_mailboxes(sh); 739 740 if (request_irq(sh->irq, aha1542_interrupt, 0, "aha1542", sh)) { 741 shost_printk(KERN_ERR, sh, "Unable to allocate IRQ.\n"); 742 goto unregister; 743 } 744 if (sh->dma_channel != 0xFF) { 745 if (request_dma(sh->dma_channel, "aha1542")) { 746 shost_printk(KERN_ERR, sh, "Unable to allocate DMA channel.\n"); 747 goto free_irq; 748 } 749 if (sh->dma_channel == 0 || sh->dma_channel >= 5) { 750 set_dma_mode(sh->dma_channel, DMA_MODE_CASCADE); 751 enable_dma(sh->dma_channel); 752 } 753 } 754 755 if (scsi_add_host(sh, pdev)) 756 goto free_dma; 757 758 scsi_scan_host(sh); 759 760 return sh; 761 free_dma: 762 if (sh->dma_channel != 0xff) 763 free_dma(sh->dma_channel); 764 free_irq: 765 free_irq(sh->irq, sh); 766 unregister: 767 scsi_host_put(sh); 768 release: 769 release_region(base_io, AHA1542_REGION_SIZE); 770 771 return NULL; 772 } 773 774 static int aha1542_release(struct Scsi_Host *sh) 775 { 776 scsi_remove_host(sh); 777 if (sh->dma_channel != 0xff) 778 free_dma(sh->dma_channel); 779 if (sh->irq) 780 free_irq(sh->irq, sh); 781 if (sh->io_port && sh->n_io_port) 782 release_region(sh->io_port, sh->n_io_port); 783 scsi_host_put(sh); 784 return 0; 785 } 786 787 788 /* 789 * This is a device reset. This is handled by sending a special command 790 * to the device. 791 */ 792 static int aha1542_dev_reset(struct scsi_cmnd *cmd) 793 { 794 struct Scsi_Host *sh = cmd->device->host; 795 struct aha1542_hostdata *aha1542 = shost_priv(sh); 796 unsigned long flags; 797 struct mailbox *mb = aha1542->mb; 798 u8 target = cmd->device->id; 799 u8 lun = cmd->device->lun; 800 int mbo; 801 struct ccb *ccb = aha1542->ccb; 802 803 spin_lock_irqsave(sh->host_lock, flags); 804 mbo = aha1542->aha1542_last_mbo_used + 1; 805 if (mbo >= AHA1542_MAILBOXES) 806 mbo = 0; 807 808 do { 809 if (mb[mbo].status == 0 && aha1542->int_cmds[mbo] == NULL) 810 break; 811 mbo++; 812 if (mbo >= AHA1542_MAILBOXES) 813 mbo = 0; 814 } while (mbo != aha1542->aha1542_last_mbo_used); 815 816 if (mb[mbo].status || aha1542->int_cmds[mbo]) 817 panic("Unable to find empty mailbox for aha1542.\n"); 818 819 aha1542->int_cmds[mbo] = cmd; /* This will effectively 820 prevent someone else from 821 screwing with this cdb. */ 822 823 aha1542->aha1542_last_mbo_used = mbo; 824 825 any2scsi(mb[mbo].ccbptr, isa_virt_to_bus(&ccb[mbo])); /* This gets trashed for some reason */ 826 827 memset(&ccb[mbo], 0, sizeof(struct ccb)); 828 829 ccb[mbo].op = 0x81; /* BUS DEVICE RESET */ 830 831 ccb[mbo].idlun = (target & 7) << 5 | (lun & 7); /*SCSI Target Id */ 832 833 ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0; 834 ccb[mbo].commlinkid = 0; 835 836 /* 837 * Now tell the 1542 to flush all pending commands for this 838 * target 839 */ 840 aha1542_outb(sh->io_port, CMD_START_SCSI); 841 spin_unlock_irqrestore(sh->host_lock, flags); 842 843 scmd_printk(KERN_WARNING, cmd, 844 "Trying device reset for target\n"); 845 846 return SUCCESS; 847 } 848 849 static int aha1542_reset(struct scsi_cmnd *cmd, u8 reset_cmd) 850 { 851 struct Scsi_Host *sh = cmd->device->host; 852 struct aha1542_hostdata *aha1542 = shost_priv(sh); 853 unsigned long flags; 854 int i; 855 856 spin_lock_irqsave(sh->host_lock, flags); 857 /* 858 * This does a scsi reset for all devices on the bus. 859 * In principle, we could also reset the 1542 - should 860 * we do this? Try this first, and we can add that later 861 * if it turns out to be useful. 862 */ 863 outb(reset_cmd, CONTROL(cmd->device->host->io_port)); 864 865 if (!wait_mask(STATUS(cmd->device->host->io_port), 866 STATMASK, IDLE, STST | DIAGF | INVDCMD | DF | CDF, 0)) { 867 spin_unlock_irqrestore(sh->host_lock, flags); 868 return FAILED; 869 } 870 871 /* 872 * We need to do this too before the 1542 can interact with 873 * us again after host reset. 874 */ 875 if (reset_cmd & HRST) 876 setup_mailboxes(cmd->device->host); 877 878 /* 879 * Now try to pick up the pieces. For all pending commands, 880 * free any internal data structures, and basically clear things 881 * out. We do not try and restart any commands or anything - 882 * the strategy handler takes care of that crap. 883 */ 884 shost_printk(KERN_WARNING, cmd->device->host, "Sent BUS RESET to scsi host %d\n", cmd->device->host->host_no); 885 886 for (i = 0; i < AHA1542_MAILBOXES; i++) { 887 if (aha1542->int_cmds[i] != NULL) { 888 struct scsi_cmnd *tmp_cmd; 889 tmp_cmd = aha1542->int_cmds[i]; 890 891 if (tmp_cmd->device->soft_reset) { 892 /* 893 * If this device implements the soft reset option, 894 * then it is still holding onto the command, and 895 * may yet complete it. In this case, we don't 896 * flush the data. 897 */ 898 continue; 899 } 900 kfree(tmp_cmd->host_scribble); 901 tmp_cmd->host_scribble = NULL; 902 aha1542->int_cmds[i] = NULL; 903 aha1542->mb[i].status = 0; 904 } 905 } 906 907 spin_unlock_irqrestore(sh->host_lock, flags); 908 return SUCCESS; 909 } 910 911 static int aha1542_bus_reset(struct scsi_cmnd *cmd) 912 { 913 return aha1542_reset(cmd, SCRST); 914 } 915 916 static int aha1542_host_reset(struct scsi_cmnd *cmd) 917 { 918 return aha1542_reset(cmd, HRST | SCRST); 919 } 920 921 static int aha1542_biosparam(struct scsi_device *sdev, 922 struct block_device *bdev, sector_t capacity, int geom[]) 923 { 924 struct aha1542_hostdata *aha1542 = shost_priv(sdev->host); 925 926 if (capacity >= 0x200000 && 927 aha1542->bios_translation == BIOS_TRANSLATION_25563) { 928 /* Please verify that this is the same as what DOS returns */ 929 geom[0] = 255; /* heads */ 930 geom[1] = 63; /* sectors */ 931 } else { 932 geom[0] = 64; /* heads */ 933 geom[1] = 32; /* sectors */ 934 } 935 geom[2] = sector_div(capacity, geom[0] * geom[1]); /* cylinders */ 936 937 return 0; 938 } 939 MODULE_LICENSE("GPL"); 940 941 static struct scsi_host_template driver_template = { 942 .module = THIS_MODULE, 943 .proc_name = "aha1542", 944 .name = "Adaptec 1542", 945 .queuecommand = aha1542_queuecommand, 946 .eh_device_reset_handler= aha1542_dev_reset, 947 .eh_bus_reset_handler = aha1542_bus_reset, 948 .eh_host_reset_handler = aha1542_host_reset, 949 .bios_param = aha1542_biosparam, 950 .can_queue = AHA1542_MAILBOXES, 951 .this_id = 7, 952 .sg_tablesize = 16, 953 .unchecked_isa_dma = 1, 954 .use_clustering = ENABLE_CLUSTERING, 955 }; 956 957 static int aha1542_isa_match(struct device *pdev, unsigned int ndev) 958 { 959 struct Scsi_Host *sh = aha1542_hw_init(&driver_template, pdev, ndev); 960 961 if (!sh) 962 return 0; 963 964 dev_set_drvdata(pdev, sh); 965 return 1; 966 } 967 968 static int aha1542_isa_remove(struct device *pdev, 969 unsigned int ndev) 970 { 971 aha1542_release(dev_get_drvdata(pdev)); 972 dev_set_drvdata(pdev, NULL); 973 return 0; 974 } 975 976 static struct isa_driver aha1542_isa_driver = { 977 .match = aha1542_isa_match, 978 .remove = aha1542_isa_remove, 979 .driver = { 980 .name = "aha1542" 981 }, 982 }; 983 static int isa_registered; 984 985 #ifdef CONFIG_PNP 986 static struct pnp_device_id aha1542_pnp_ids[] = { 987 { .id = "ADP1542" }, 988 { .id = "" } 989 }; 990 MODULE_DEVICE_TABLE(pnp, aha1542_pnp_ids); 991 992 static int aha1542_pnp_probe(struct pnp_dev *pdev, const struct pnp_device_id *id) 993 { 994 int indx; 995 struct Scsi_Host *sh; 996 997 for (indx = 0; indx < ARRAY_SIZE(io); indx++) { 998 if (io[indx]) 999 continue; 1000 1001 if (pnp_activate_dev(pdev) < 0) 1002 continue; 1003 1004 io[indx] = pnp_port_start(pdev, 0); 1005 1006 /* The card can be queried for its DMA, we have 1007 the DMA set up that is enough */ 1008 1009 dev_info(&pdev->dev, "ISAPnP found an AHA1535 at I/O 0x%03X", io[indx]); 1010 } 1011 1012 sh = aha1542_hw_init(&driver_template, &pdev->dev, indx); 1013 if (!sh) 1014 return -ENODEV; 1015 1016 pnp_set_drvdata(pdev, sh); 1017 return 0; 1018 } 1019 1020 static void aha1542_pnp_remove(struct pnp_dev *pdev) 1021 { 1022 aha1542_release(pnp_get_drvdata(pdev)); 1023 pnp_set_drvdata(pdev, NULL); 1024 } 1025 1026 static struct pnp_driver aha1542_pnp_driver = { 1027 .name = "aha1542", 1028 .id_table = aha1542_pnp_ids, 1029 .probe = aha1542_pnp_probe, 1030 .remove = aha1542_pnp_remove, 1031 }; 1032 static int pnp_registered; 1033 #endif /* CONFIG_PNP */ 1034 1035 static int __init aha1542_init(void) 1036 { 1037 int ret = 0; 1038 1039 #ifdef CONFIG_PNP 1040 if (isapnp) { 1041 ret = pnp_register_driver(&aha1542_pnp_driver); 1042 if (!ret) 1043 pnp_registered = 1; 1044 } 1045 #endif 1046 ret = isa_register_driver(&aha1542_isa_driver, MAXBOARDS); 1047 if (!ret) 1048 isa_registered = 1; 1049 1050 #ifdef CONFIG_PNP 1051 if (pnp_registered) 1052 ret = 0; 1053 #endif 1054 if (isa_registered) 1055 ret = 0; 1056 1057 return ret; 1058 } 1059 1060 static void __exit aha1542_exit(void) 1061 { 1062 #ifdef CONFIG_PNP 1063 if (pnp_registered) 1064 pnp_unregister_driver(&aha1542_pnp_driver); 1065 #endif 1066 if (isa_registered) 1067 isa_unregister_driver(&aha1542_isa_driver); 1068 } 1069 1070 module_init(aha1542_init); 1071 module_exit(aha1542_exit); 1072