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