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; 379 struct mailbox *mb = aha1542->mb; 380 struct ccb *ccb = aha1542->ccb; 381 382 if (*cmd->cmnd == REQUEST_SENSE) { 383 /* Don't do the command - we have the sense data already */ 384 cmd->result = 0; 385 cmd->scsi_done(cmd); 386 return 0; 387 } 388 #ifdef DEBUG 389 { 390 int i = -1; 391 if (*cmd->cmnd == READ_10 || *cmd->cmnd == WRITE_10) 392 i = xscsi2int(cmd->cmnd + 2); 393 else if (*cmd->cmnd == READ_6 || *cmd->cmnd == WRITE_6) 394 i = scsi2int(cmd->cmnd + 2); 395 shost_printk(KERN_DEBUG, sh, "aha1542_queuecommand: dev %d cmd %02x pos %d len %d", 396 target, *cmd->cmnd, i, bufflen); 397 print_hex_dump_bytes("command: ", DUMP_PREFIX_NONE, cmd->cmnd, cmd->cmd_len); 398 } 399 #endif 400 /* Use the outgoing mailboxes in a round-robin fashion, because this 401 is how the host adapter will scan for them */ 402 403 spin_lock_irqsave(sh->host_lock, flags); 404 mbo = aha1542->aha1542_last_mbo_used + 1; 405 if (mbo >= AHA1542_MAILBOXES) 406 mbo = 0; 407 408 do { 409 if (mb[mbo].status == 0 && aha1542->int_cmds[mbo] == NULL) 410 break; 411 mbo++; 412 if (mbo >= AHA1542_MAILBOXES) 413 mbo = 0; 414 } while (mbo != aha1542->aha1542_last_mbo_used); 415 416 if (mb[mbo].status || aha1542->int_cmds[mbo]) 417 panic("Unable to find empty mailbox for aha1542.\n"); 418 419 aha1542->int_cmds[mbo] = cmd; /* This will effectively prevent someone else from 420 screwing with this cdb. */ 421 422 aha1542->aha1542_last_mbo_used = mbo; 423 424 #ifdef DEBUG 425 shost_printk(KERN_DEBUG, sh, "Sending command (%d %p)...", mbo, cmd->scsi_done); 426 #endif 427 428 any2scsi(mb[mbo].ccbptr, isa_virt_to_bus(&ccb[mbo])); /* This gets trashed for some reason */ 429 430 memset(&ccb[mbo], 0, sizeof(struct ccb)); 431 432 ccb[mbo].cdblen = cmd->cmd_len; 433 434 direction = 0; 435 if (*cmd->cmnd == READ_10 || *cmd->cmnd == READ_6) 436 direction = 8; 437 else if (*cmd->cmnd == WRITE_10 || *cmd->cmnd == WRITE_6) 438 direction = 16; 439 440 memcpy(ccb[mbo].cdb, cmd->cmnd, ccb[mbo].cdblen); 441 442 if (bufflen) { 443 struct scatterlist *sg; 444 struct chain *cptr; 445 int i, sg_count = scsi_sg_count(cmd); 446 447 ccb[mbo].op = 2; /* SCSI Initiator Command w/scatter-gather */ 448 cmd->host_scribble = kmalloc(sizeof(*cptr)*sg_count, 449 GFP_KERNEL | GFP_DMA); 450 cptr = (struct chain *) cmd->host_scribble; 451 if (cptr == NULL) { 452 /* free the claimed mailbox slot */ 453 aha1542->int_cmds[mbo] = NULL; 454 spin_unlock_irqrestore(sh->host_lock, flags); 455 return SCSI_MLQUEUE_HOST_BUSY; 456 } 457 scsi_for_each_sg(cmd, sg, sg_count, i) { 458 any2scsi(cptr[i].dataptr, isa_page_to_bus(sg_page(sg)) 459 + sg->offset); 460 any2scsi(cptr[i].datalen, sg->length); 461 }; 462 any2scsi(ccb[mbo].datalen, sg_count * sizeof(struct chain)); 463 any2scsi(ccb[mbo].dataptr, isa_virt_to_bus(cptr)); 464 #ifdef DEBUG 465 shost_printk(KERN_DEBUG, sh, "cptr %p: ", cptr); 466 print_hex_dump_bytes("cptr: ", DUMP_PREFIX_NONE, cptr, 18); 467 #endif 468 } else { 469 ccb[mbo].op = 0; /* SCSI Initiator Command */ 470 cmd->host_scribble = NULL; 471 any2scsi(ccb[mbo].datalen, 0); 472 any2scsi(ccb[mbo].dataptr, 0); 473 }; 474 ccb[mbo].idlun = (target & 7) << 5 | direction | (lun & 7); /*SCSI Target Id */ 475 ccb[mbo].rsalen = 16; 476 ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0; 477 ccb[mbo].commlinkid = 0; 478 479 #ifdef DEBUG 480 print_hex_dump_bytes("sending: ", DUMP_PREFIX_NONE, &ccb[mbo], sizeof(ccb[mbo]) - 10); 481 printk("aha1542_queuecommand: now waiting for interrupt "); 482 #endif 483 mb[mbo].status = 1; 484 aha1542_outb(cmd->device->host->io_port, CMD_START_SCSI); 485 spin_unlock_irqrestore(sh->host_lock, flags); 486 487 return 0; 488 } 489 490 /* Initialize mailboxes */ 491 static void setup_mailboxes(struct Scsi_Host *sh) 492 { 493 struct aha1542_hostdata *aha1542 = shost_priv(sh); 494 int i; 495 struct mailbox *mb = aha1542->mb; 496 struct ccb *ccb = aha1542->ccb; 497 498 u8 mb_cmd[5] = { CMD_MBINIT, AHA1542_MAILBOXES, 0, 0, 0}; 499 500 for (i = 0; i < AHA1542_MAILBOXES; i++) { 501 mb[i].status = mb[AHA1542_MAILBOXES + i].status = 0; 502 any2scsi(mb[i].ccbptr, isa_virt_to_bus(&ccb[i])); 503 }; 504 aha1542_intr_reset(sh->io_port); /* reset interrupts, so they don't block */ 505 any2scsi((mb_cmd + 2), isa_virt_to_bus(mb)); 506 if (aha1542_out(sh->io_port, mb_cmd, 5)) 507 shost_printk(KERN_ERR, sh, "failed setting up mailboxes\n"); 508 aha1542_intr_reset(sh->io_port); 509 } 510 511 static int aha1542_getconfig(struct Scsi_Host *sh) 512 { 513 u8 inquiry_result[3]; 514 int i; 515 i = inb(STATUS(sh->io_port)); 516 if (i & DF) { 517 i = inb(DATA(sh->io_port)); 518 }; 519 aha1542_outb(sh->io_port, CMD_RETCONF); 520 aha1542_in(sh->io_port, inquiry_result, 3, 0); 521 if (!wait_mask(INTRFLAGS(sh->io_port), INTRMASK, HACC, 0, 0)) 522 shost_printk(KERN_ERR, sh, "error querying board settings\n"); 523 aha1542_intr_reset(sh->io_port); 524 switch (inquiry_result[0]) { 525 case 0x80: 526 sh->dma_channel = 7; 527 break; 528 case 0x40: 529 sh->dma_channel = 6; 530 break; 531 case 0x20: 532 sh->dma_channel = 5; 533 break; 534 case 0x01: 535 sh->dma_channel = 0; 536 break; 537 case 0: 538 /* This means that the adapter, although Adaptec 1542 compatible, doesn't use a DMA channel. 539 Currently only aware of the BusLogic BT-445S VL-Bus adapter which needs this. */ 540 sh->dma_channel = 0xFF; 541 break; 542 default: 543 shost_printk(KERN_ERR, sh, "Unable to determine DMA channel.\n"); 544 return -1; 545 }; 546 switch (inquiry_result[1]) { 547 case 0x40: 548 sh->irq = 15; 549 break; 550 case 0x20: 551 sh->irq = 14; 552 break; 553 case 0x8: 554 sh->irq = 12; 555 break; 556 case 0x4: 557 sh->irq = 11; 558 break; 559 case 0x2: 560 sh->irq = 10; 561 break; 562 case 0x1: 563 sh->irq = 9; 564 break; 565 default: 566 shost_printk(KERN_ERR, sh, "Unable to determine IRQ level.\n"); 567 return -1; 568 }; 569 sh->this_id = inquiry_result[2] & 7; 570 return 0; 571 } 572 573 /* This function should only be called for 1542C boards - we can detect 574 the special firmware settings and unlock the board */ 575 576 static int aha1542_mbenable(struct Scsi_Host *sh) 577 { 578 static u8 mbenable_cmd[3]; 579 static u8 mbenable_result[2]; 580 int retval; 581 582 retval = BIOS_TRANSLATION_6432; 583 584 aha1542_outb(sh->io_port, CMD_EXTBIOS); 585 if (aha1542_in(sh->io_port, mbenable_result, 2, 100)) 586 return retval; 587 if (!wait_mask(INTRFLAGS(sh->io_port), INTRMASK, HACC, 0, 100)) 588 goto fail; 589 aha1542_intr_reset(sh->io_port); 590 591 if ((mbenable_result[0] & 0x08) || mbenable_result[1]) { 592 mbenable_cmd[0] = CMD_MBENABLE; 593 mbenable_cmd[1] = 0; 594 mbenable_cmd[2] = mbenable_result[1]; 595 596 if ((mbenable_result[0] & 0x08) && (mbenable_result[1] & 0x03)) 597 retval = BIOS_TRANSLATION_25563; 598 599 if (aha1542_out(sh->io_port, mbenable_cmd, 3)) 600 goto fail; 601 }; 602 while (0) { 603 fail: 604 shost_printk(KERN_ERR, sh, "Mailbox init failed\n"); 605 } 606 aha1542_intr_reset(sh->io_port); 607 return retval; 608 } 609 610 /* Query the board to find out if it is a 1542 or a 1740, or whatever. */ 611 static int aha1542_query(struct Scsi_Host *sh) 612 { 613 struct aha1542_hostdata *aha1542 = shost_priv(sh); 614 u8 inquiry_result[4]; 615 int i; 616 i = inb(STATUS(sh->io_port)); 617 if (i & DF) { 618 i = inb(DATA(sh->io_port)); 619 }; 620 aha1542_outb(sh->io_port, CMD_INQUIRY); 621 aha1542_in(sh->io_port, inquiry_result, 4, 0); 622 if (!wait_mask(INTRFLAGS(sh->io_port), INTRMASK, HACC, 0, 0)) 623 shost_printk(KERN_ERR, sh, "error querying card type\n"); 624 aha1542_intr_reset(sh->io_port); 625 626 aha1542->bios_translation = BIOS_TRANSLATION_6432; /* Default case */ 627 628 /* For an AHA1740 series board, we ignore the board since there is a 629 hardware bug which can lead to wrong blocks being returned if the board 630 is operating in the 1542 emulation mode. Since there is an extended mode 631 driver, we simply ignore the board and let the 1740 driver pick it up. 632 */ 633 634 if (inquiry_result[0] == 0x43) { 635 shost_printk(KERN_INFO, sh, "Emulation mode not supported for AHA-1740 hardware, use aha1740 driver instead.\n"); 636 return 1; 637 }; 638 639 /* Always call this - boards that do not support extended bios translation 640 will ignore the command, and we will set the proper default */ 641 642 aha1542->bios_translation = aha1542_mbenable(sh); 643 644 return 0; 645 } 646 647 static u8 dma_speed_hw(int dma_speed) 648 { 649 switch (dma_speed) { 650 case 5: 651 return 0x00; 652 case 6: 653 return 0x04; 654 case 7: 655 return 0x01; 656 case 8: 657 return 0x02; 658 case 10: 659 return 0x03; 660 } 661 662 return 0xff; /* invalid */ 663 } 664 665 /* Set the Bus on/off-times as not to ruin floppy performance */ 666 static void aha1542_set_bus_times(struct Scsi_Host *sh, int bus_on, int bus_off, int dma_speed) 667 { 668 if (bus_on > 0) { 669 u8 oncmd[] = { CMD_BUSON_TIME, clamp(bus_on, 2, 15) }; 670 671 aha1542_intr_reset(sh->io_port); 672 if (aha1542_out(sh->io_port, oncmd, 2)) 673 goto fail; 674 } 675 676 if (bus_off > 0) { 677 u8 offcmd[] = { CMD_BUSOFF_TIME, clamp(bus_off, 1, 64) }; 678 679 aha1542_intr_reset(sh->io_port); 680 if (aha1542_out(sh->io_port, offcmd, 2)) 681 goto fail; 682 } 683 684 if (dma_speed_hw(dma_speed) != 0xff) { 685 u8 dmacmd[] = { CMD_DMASPEED, dma_speed_hw(dma_speed) }; 686 687 aha1542_intr_reset(sh->io_port); 688 if (aha1542_out(sh->io_port, dmacmd, 2)) 689 goto fail; 690 } 691 aha1542_intr_reset(sh->io_port); 692 return; 693 fail: 694 shost_printk(KERN_ERR, sh, "setting bus on/off-time failed\n"); 695 aha1542_intr_reset(sh->io_port); 696 } 697 698 /* return non-zero on detection */ 699 static struct Scsi_Host *aha1542_hw_init(struct scsi_host_template *tpnt, struct device *pdev, int indx) 700 { 701 unsigned int base_io = io[indx]; 702 struct Scsi_Host *sh; 703 struct aha1542_hostdata *aha1542; 704 char dma_info[] = "no DMA"; 705 706 if (base_io == 0) 707 return NULL; 708 709 if (!request_region(base_io, AHA1542_REGION_SIZE, "aha1542")) 710 return NULL; 711 712 sh = scsi_host_alloc(tpnt, sizeof(struct aha1542_hostdata)); 713 if (!sh) 714 goto release; 715 aha1542 = shost_priv(sh); 716 717 sh->unique_id = base_io; 718 sh->io_port = base_io; 719 sh->n_io_port = AHA1542_REGION_SIZE; 720 aha1542->aha1542_last_mbi_used = 2 * AHA1542_MAILBOXES - 1; 721 aha1542->aha1542_last_mbo_used = AHA1542_MAILBOXES - 1; 722 723 if (!aha1542_test_port(sh)) 724 goto unregister; 725 726 aha1542_set_bus_times(sh, bus_on[indx], bus_off[indx], dma_speed[indx]); 727 if (aha1542_query(sh)) 728 goto unregister; 729 if (aha1542_getconfig(sh) == -1) 730 goto unregister; 731 732 if (sh->dma_channel != 0xFF) 733 snprintf(dma_info, sizeof(dma_info), "DMA %d", sh->dma_channel); 734 shost_printk(KERN_INFO, sh, "Adaptec AHA-1542 (SCSI-ID %d) at IO 0x%x, IRQ %d, %s\n", 735 sh->this_id, base_io, sh->irq, dma_info); 736 if (aha1542->bios_translation == BIOS_TRANSLATION_25563) 737 shost_printk(KERN_INFO, sh, "Using extended bios translation\n"); 738 739 setup_mailboxes(sh); 740 741 if (request_irq(sh->irq, aha1542_interrupt, 0, "aha1542", sh)) { 742 shost_printk(KERN_ERR, sh, "Unable to allocate IRQ.\n"); 743 goto unregister; 744 } 745 if (sh->dma_channel != 0xFF) { 746 if (request_dma(sh->dma_channel, "aha1542")) { 747 shost_printk(KERN_ERR, sh, "Unable to allocate DMA channel.\n"); 748 goto free_irq; 749 } 750 if (sh->dma_channel == 0 || sh->dma_channel >= 5) { 751 set_dma_mode(sh->dma_channel, DMA_MODE_CASCADE); 752 enable_dma(sh->dma_channel); 753 } 754 } 755 756 if (scsi_add_host(sh, pdev)) 757 goto free_dma; 758 759 scsi_scan_host(sh); 760 761 return sh; 762 free_dma: 763 if (sh->dma_channel != 0xff) 764 free_dma(sh->dma_channel); 765 free_irq: 766 free_irq(sh->irq, sh); 767 unregister: 768 scsi_host_put(sh); 769 release: 770 release_region(base_io, AHA1542_REGION_SIZE); 771 772 return NULL; 773 } 774 775 static int aha1542_release(struct Scsi_Host *sh) 776 { 777 scsi_remove_host(sh); 778 if (sh->dma_channel != 0xff) 779 free_dma(sh->dma_channel); 780 if (sh->irq) 781 free_irq(sh->irq, sh); 782 if (sh->io_port && sh->n_io_port) 783 release_region(sh->io_port, sh->n_io_port); 784 scsi_host_put(sh); 785 return 0; 786 } 787 788 789 /* 790 * This is a device reset. This is handled by sending a special command 791 * to the device. 792 */ 793 static int aha1542_dev_reset(struct scsi_cmnd *cmd) 794 { 795 struct Scsi_Host *sh = cmd->device->host; 796 struct aha1542_hostdata *aha1542 = shost_priv(sh); 797 unsigned long flags; 798 struct mailbox *mb = aha1542->mb; 799 u8 target = cmd->device->id; 800 u8 lun = cmd->device->lun; 801 int mbo; 802 struct ccb *ccb = aha1542->ccb; 803 804 spin_lock_irqsave(sh->host_lock, flags); 805 mbo = aha1542->aha1542_last_mbo_used + 1; 806 if (mbo >= AHA1542_MAILBOXES) 807 mbo = 0; 808 809 do { 810 if (mb[mbo].status == 0 && aha1542->int_cmds[mbo] == NULL) 811 break; 812 mbo++; 813 if (mbo >= AHA1542_MAILBOXES) 814 mbo = 0; 815 } while (mbo != aha1542->aha1542_last_mbo_used); 816 817 if (mb[mbo].status || aha1542->int_cmds[mbo]) 818 panic("Unable to find empty mailbox for aha1542.\n"); 819 820 aha1542->int_cmds[mbo] = cmd; /* This will effectively 821 prevent someone else from 822 screwing with this cdb. */ 823 824 aha1542->aha1542_last_mbo_used = mbo; 825 826 any2scsi(mb[mbo].ccbptr, isa_virt_to_bus(&ccb[mbo])); /* This gets trashed for some reason */ 827 828 memset(&ccb[mbo], 0, sizeof(struct ccb)); 829 830 ccb[mbo].op = 0x81; /* BUS DEVICE RESET */ 831 832 ccb[mbo].idlun = (target & 7) << 5 | (lun & 7); /*SCSI Target Id */ 833 834 ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0; 835 ccb[mbo].commlinkid = 0; 836 837 /* 838 * Now tell the 1542 to flush all pending commands for this 839 * target 840 */ 841 aha1542_outb(sh->io_port, CMD_START_SCSI); 842 spin_unlock_irqrestore(sh->host_lock, flags); 843 844 scmd_printk(KERN_WARNING, cmd, 845 "Trying device reset for target\n"); 846 847 return SUCCESS; 848 } 849 850 static int aha1542_reset(struct scsi_cmnd *cmd, u8 reset_cmd) 851 { 852 struct Scsi_Host *sh = cmd->device->host; 853 struct aha1542_hostdata *aha1542 = shost_priv(sh); 854 unsigned long flags; 855 int i; 856 857 spin_lock_irqsave(sh->host_lock, flags); 858 /* 859 * This does a scsi reset for all devices on the bus. 860 * In principle, we could also reset the 1542 - should 861 * we do this? Try this first, and we can add that later 862 * if it turns out to be useful. 863 */ 864 outb(reset_cmd, CONTROL(cmd->device->host->io_port)); 865 866 if (!wait_mask(STATUS(cmd->device->host->io_port), 867 STATMASK, IDLE, STST | DIAGF | INVDCMD | DF | CDF, 0)) { 868 spin_unlock_irqrestore(sh->host_lock, flags); 869 return FAILED; 870 } 871 872 /* 873 * We need to do this too before the 1542 can interact with 874 * us again after host reset. 875 */ 876 if (reset_cmd & HRST) 877 setup_mailboxes(cmd->device->host); 878 879 /* 880 * Now try to pick up the pieces. For all pending commands, 881 * free any internal data structures, and basically clear things 882 * out. We do not try and restart any commands or anything - 883 * the strategy handler takes care of that crap. 884 */ 885 shost_printk(KERN_WARNING, cmd->device->host, "Sent BUS RESET to scsi host %d\n", cmd->device->host->host_no); 886 887 for (i = 0; i < AHA1542_MAILBOXES; i++) { 888 if (aha1542->int_cmds[i] != NULL) { 889 struct scsi_cmnd *tmp_cmd; 890 tmp_cmd = aha1542->int_cmds[i]; 891 892 if (tmp_cmd->device->soft_reset) { 893 /* 894 * If this device implements the soft reset option, 895 * then it is still holding onto the command, and 896 * may yet complete it. In this case, we don't 897 * flush the data. 898 */ 899 continue; 900 } 901 kfree(tmp_cmd->host_scribble); 902 tmp_cmd->host_scribble = NULL; 903 aha1542->int_cmds[i] = NULL; 904 aha1542->mb[i].status = 0; 905 } 906 } 907 908 spin_unlock_irqrestore(sh->host_lock, flags); 909 return SUCCESS; 910 } 911 912 static int aha1542_bus_reset(struct scsi_cmnd *cmd) 913 { 914 return aha1542_reset(cmd, SCRST); 915 } 916 917 static int aha1542_host_reset(struct scsi_cmnd *cmd) 918 { 919 return aha1542_reset(cmd, HRST | SCRST); 920 } 921 922 static int aha1542_biosparam(struct scsi_device *sdev, 923 struct block_device *bdev, sector_t capacity, int geom[]) 924 { 925 struct aha1542_hostdata *aha1542 = shost_priv(sdev->host); 926 927 if (capacity >= 0x200000 && 928 aha1542->bios_translation == BIOS_TRANSLATION_25563) { 929 /* Please verify that this is the same as what DOS returns */ 930 geom[0] = 255; /* heads */ 931 geom[1] = 63; /* sectors */ 932 } else { 933 geom[0] = 64; /* heads */ 934 geom[1] = 32; /* sectors */ 935 } 936 geom[2] = sector_div(capacity, geom[0] * geom[1]); /* cylinders */ 937 938 return 0; 939 } 940 MODULE_LICENSE("GPL"); 941 942 static struct scsi_host_template driver_template = { 943 .module = THIS_MODULE, 944 .proc_name = "aha1542", 945 .name = "Adaptec 1542", 946 .queuecommand = aha1542_queuecommand, 947 .eh_device_reset_handler= aha1542_dev_reset, 948 .eh_bus_reset_handler = aha1542_bus_reset, 949 .eh_host_reset_handler = aha1542_host_reset, 950 .bios_param = aha1542_biosparam, 951 .can_queue = AHA1542_MAILBOXES, 952 .this_id = 7, 953 .sg_tablesize = 16, 954 .cmd_per_lun = 1, 955 .unchecked_isa_dma = 1, 956 .use_clustering = ENABLE_CLUSTERING, 957 }; 958 959 static int aha1542_isa_match(struct device *pdev, unsigned int ndev) 960 { 961 struct Scsi_Host *sh = aha1542_hw_init(&driver_template, pdev, ndev); 962 963 if (!sh) 964 return 0; 965 966 dev_set_drvdata(pdev, sh); 967 return 1; 968 } 969 970 static int aha1542_isa_remove(struct device *pdev, 971 unsigned int ndev) 972 { 973 aha1542_release(dev_get_drvdata(pdev)); 974 dev_set_drvdata(pdev, NULL); 975 return 0; 976 } 977 978 static struct isa_driver aha1542_isa_driver = { 979 .match = aha1542_isa_match, 980 .remove = aha1542_isa_remove, 981 .driver = { 982 .name = "aha1542" 983 }, 984 }; 985 static int isa_registered; 986 987 #ifdef CONFIG_PNP 988 static struct pnp_device_id aha1542_pnp_ids[] = { 989 { .id = "ADP1542" }, 990 { .id = "" } 991 }; 992 MODULE_DEVICE_TABLE(pnp, aha1542_pnp_ids); 993 994 static int aha1542_pnp_probe(struct pnp_dev *pdev, const struct pnp_device_id *id) 995 { 996 int indx; 997 struct Scsi_Host *sh; 998 999 for (indx = 0; indx < ARRAY_SIZE(io); indx++) { 1000 if (io[indx]) 1001 continue; 1002 1003 if (pnp_activate_dev(pdev) < 0) 1004 continue; 1005 1006 io[indx] = pnp_port_start(pdev, 0); 1007 1008 /* The card can be queried for its DMA, we have 1009 the DMA set up that is enough */ 1010 1011 dev_info(&pdev->dev, "ISAPnP found an AHA1535 at I/O 0x%03X", io[indx]); 1012 } 1013 1014 sh = aha1542_hw_init(&driver_template, &pdev->dev, indx); 1015 if (!sh) 1016 return -ENODEV; 1017 1018 pnp_set_drvdata(pdev, sh); 1019 return 0; 1020 } 1021 1022 static void aha1542_pnp_remove(struct pnp_dev *pdev) 1023 { 1024 aha1542_release(pnp_get_drvdata(pdev)); 1025 pnp_set_drvdata(pdev, NULL); 1026 } 1027 1028 static struct pnp_driver aha1542_pnp_driver = { 1029 .name = "aha1542", 1030 .id_table = aha1542_pnp_ids, 1031 .probe = aha1542_pnp_probe, 1032 .remove = aha1542_pnp_remove, 1033 }; 1034 static int pnp_registered; 1035 #endif /* CONFIG_PNP */ 1036 1037 static int __init aha1542_init(void) 1038 { 1039 int ret = 0; 1040 1041 #ifdef CONFIG_PNP 1042 if (isapnp) { 1043 ret = pnp_register_driver(&aha1542_pnp_driver); 1044 if (!ret) 1045 pnp_registered = 1; 1046 } 1047 #endif 1048 ret = isa_register_driver(&aha1542_isa_driver, MAXBOARDS); 1049 if (!ret) 1050 isa_registered = 1; 1051 1052 #ifdef CONFIG_PNP 1053 if (pnp_registered) 1054 ret = 0; 1055 #endif 1056 if (isa_registered) 1057 ret = 0; 1058 1059 return ret; 1060 } 1061 1062 static void __exit aha1542_exit(void) 1063 { 1064 #ifdef CONFIG_PNP 1065 if (pnp_registered) 1066 pnp_unregister_driver(&aha1542_pnp_driver); 1067 #endif 1068 if (isa_registered) 1069 isa_unregister_driver(&aha1542_isa_driver); 1070 } 1071 1072 module_init(aha1542_init); 1073 module_exit(aha1542_exit); 1074