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