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