// SPDX-License-Identifier: GPL-2.0-only /* * Driver for Adaptec AHA-1542 SCSI host adapters * * Copyright (C) 1992 Tommy Thorn * Copyright (C) 1993, 1994, 1995 Eric Youngdale * Copyright (C) 2015 Ondrej Zary */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "aha1542.h" #define MAXBOARDS 4 static bool isapnp = 1; module_param(isapnp, bool, 0); MODULE_PARM_DESC(isapnp, "enable PnP support (default=1)"); static int io[MAXBOARDS] = { 0x330, 0x334, 0, 0 }; module_param_hw_array(io, int, ioport, NULL, 0); MODULE_PARM_DESC(io, "base IO address of controller (0x130,0x134,0x230,0x234,0x330,0x334, default=0x330,0x334)"); /* time AHA spends on the AT-bus during data transfer */ static int bus_on[MAXBOARDS] = { -1, -1, -1, -1 }; /* power-on default: 11us */ module_param_array(bus_on, int, NULL, 0); MODULE_PARM_DESC(bus_on, "bus on time [us] (2-15, default=-1 [HW default: 11])"); /* time AHA spends off the bus (not to monopolize it) during data transfer */ static int bus_off[MAXBOARDS] = { -1, -1, -1, -1 }; /* power-on default: 4us */ module_param_array(bus_off, int, NULL, 0); MODULE_PARM_DESC(bus_off, "bus off time [us] (1-64, default=-1 [HW default: 4])"); /* default is jumper selected (J1 on 1542A), factory default = 5 MB/s */ static int dma_speed[MAXBOARDS] = { -1, -1, -1, -1 }; module_param_array(dma_speed, int, NULL, 0); MODULE_PARM_DESC(dma_speed, "DMA speed [MB/s] (5,6,7,8,10, default=-1 [by jumper])"); #define BIOS_TRANSLATION_6432 1 /* Default case these days */ #define BIOS_TRANSLATION_25563 2 /* Big disk case */ struct aha1542_hostdata { /* This will effectively start both of them at the first mailbox */ int bios_translation; /* Mapping bios uses - for compatibility */ int aha1542_last_mbi_used; int aha1542_last_mbo_used; struct scsi_cmnd *int_cmds[AHA1542_MAILBOXES]; struct mailbox *mb; dma_addr_t mb_handle; struct ccb *ccb; dma_addr_t ccb_handle; }; #define AHA1542_MAX_SECTORS 16 struct aha1542_cmd { /* bounce buffer */ void *data_buffer; dma_addr_t data_buffer_handle; }; static inline void aha1542_intr_reset(u16 base) { outb(IRST, CONTROL(base)); } static inline bool wait_mask(u16 port, u8 mask, u8 allof, u8 noneof, int timeout) { bool delayed = true; if (timeout == 0) { timeout = 3000000; delayed = false; } while (1) { u8 bits = inb(port) & mask; if ((bits & allof) == allof && ((bits & noneof) == 0)) break; if (delayed) mdelay(1); if (--timeout == 0) return false; } return true; } static int aha1542_outb(unsigned int base, u8 val) { if (!wait_mask(STATUS(base), CDF, 0, CDF, 0)) return 1; outb(val, DATA(base)); return 0; } static int aha1542_out(unsigned int base, u8 *buf, int len) { while (len--) { if (!wait_mask(STATUS(base), CDF, 0, CDF, 0)) return 1; outb(*buf++, DATA(base)); } if (!wait_mask(INTRFLAGS(base), INTRMASK, HACC, 0, 0)) return 1; return 0; } /* * Only used at boot time, so we do not need to worry about latency as much * here */ static int aha1542_in(unsigned int base, u8 *buf, int len, int timeout) { while (len--) { if (!wait_mask(STATUS(base), DF, DF, 0, timeout)) return 1; *buf++ = inb(DATA(base)); } return 0; } static int makecode(unsigned hosterr, unsigned scsierr) { switch (hosterr) { case 0x0: case 0xa: /* Linked command complete without error and linked normally */ case 0xb: /* Linked command complete without error, interrupt generated */ hosterr = 0; break; case 0x11: /* Selection time out-The initiator selection or target * reselection was not complete within the SCSI Time out period */ hosterr = DID_TIME_OUT; break; case 0x12: /* Data overrun/underrun-The target attempted to transfer more data * than was allocated by the Data Length field or the sum of the * Scatter / Gather Data Length fields. */ case 0x13: /* Unexpected bus free-The target dropped the SCSI BSY at an unexpected time. */ case 0x15: /* MBO command was not 00, 01 or 02-The first byte of the CB was * invalid. This usually indicates a software failure. */ case 0x16: /* Invalid CCB Operation Code-The first byte of the CCB was invalid. * This usually indicates a software failure. */ case 0x17: /* Linked CCB does not have the same LUN-A subsequent CCB of a set * of linked CCB's does not specify the same logical unit number as * the first. */ case 0x18: /* Invalid Target Direction received from Host-The direction of a * Target Mode CCB was invalid. */ case 0x19: /* Duplicate CCB Received in Target Mode-More than once CCB was * received to service data transfer between the same target LUN * and initiator SCSI ID in the same direction. */ case 0x1a: /* Invalid CCB or Segment List Parameter-A segment list with a zero * length segment or invalid segment list boundaries was received. * A CCB parameter was invalid. */ #ifdef DEBUG printk("Aha1542: %x %x\n", hosterr, scsierr); #endif hosterr = DID_ERROR; /* Couldn't find any better */ break; case 0x14: /* Target bus phase sequence failure-An invalid bus phase or bus * phase sequence was requested by the target. The host adapter * will generate a SCSI Reset Condition, notifying the host with * a SCRD interrupt */ hosterr = DID_RESET; break; default: printk(KERN_ERR "aha1542: makecode: unknown hoststatus %x\n", hosterr); break; } return scsierr | (hosterr << 16); } static int aha1542_test_port(struct Scsi_Host *sh) { int i; /* Quick and dirty test for presence of the card. */ if (inb(STATUS(sh->io_port)) == 0xff) return 0; /* Reset the adapter. I ought to make a hard reset, but it's not really necessary */ /* In case some other card was probing here, reset interrupts */ aha1542_intr_reset(sh->io_port); /* reset interrupts, so they don't block */ outb(SRST | IRST /*|SCRST */ , CONTROL(sh->io_port)); mdelay(20); /* Wait a little bit for things to settle down. */ /* Expect INIT and IDLE, any of the others are bad */ if (!wait_mask(STATUS(sh->io_port), STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF, 0)) return 0; /* Shouldn't have generated any interrupts during reset */ if (inb(INTRFLAGS(sh->io_port)) & INTRMASK) return 0; /* * Perform a host adapter inquiry instead so we do not need to set * up the mailboxes ahead of time */ aha1542_outb(sh->io_port, CMD_INQUIRY); for (i = 0; i < 4; i++) { if (!wait_mask(STATUS(sh->io_port), DF, DF, 0, 0)) return 0; (void)inb(DATA(sh->io_port)); } /* Reading port should reset DF */ if (inb(STATUS(sh->io_port)) & DF) return 0; /* When HACC, command is completed, and we're though testing */ if (!wait_mask(INTRFLAGS(sh->io_port), HACC, HACC, 0, 0)) return 0; /* Clear interrupts */ outb(IRST, CONTROL(sh->io_port)); return 1; } static void aha1542_free_cmd(struct scsi_cmnd *cmd) { struct aha1542_cmd *acmd = scsi_cmd_priv(cmd); if (cmd->sc_data_direction == DMA_FROM_DEVICE) { struct request *rq = scsi_cmd_to_rq(cmd); void *buf = acmd->data_buffer; struct req_iterator iter; struct bio_vec bv; rq_for_each_segment(bv, rq, iter) { memcpy_to_bvec(&bv, buf); buf += bv.bv_len; } } scsi_dma_unmap(cmd); } static irqreturn_t aha1542_interrupt(int irq, void *dev_id) { struct Scsi_Host *sh = dev_id; struct aha1542_hostdata *aha1542 = shost_priv(sh); int errstatus, mbi, mbo, mbistatus; int number_serviced; unsigned long flags; struct scsi_cmnd *tmp_cmd; int flag; struct mailbox *mb = aha1542->mb; struct ccb *ccb = aha1542->ccb; #ifdef DEBUG { flag = inb(INTRFLAGS(sh->io_port)); shost_printk(KERN_DEBUG, sh, "aha1542_intr_handle: "); if (!(flag & ANYINTR)) printk("no interrupt?"); if (flag & MBIF) printk("MBIF "); if (flag & MBOA) printk("MBOF "); if (flag & HACC) printk("HACC "); if (flag & SCRD) printk("SCRD "); printk("status %02x\n", inb(STATUS(sh->io_port))); } #endif number_serviced = 0; spin_lock_irqsave(sh->host_lock, flags); while (1) { flag = inb(INTRFLAGS(sh->io_port)); /* * Check for unusual interrupts. If any of these happen, we should * probably do something special, but for now just printing a message * is sufficient. A SCSI reset detected is something that we really * need to deal with in some way. */ if (flag & ~MBIF) { if (flag & MBOA) printk("MBOF "); if (flag & HACC) printk("HACC "); if (flag & SCRD) printk("SCRD "); } aha1542_intr_reset(sh->io_port); mbi = aha1542->aha1542_last_mbi_used + 1; if (mbi >= 2 * AHA1542_MAILBOXES) mbi = AHA1542_MAILBOXES; do { if (mb[mbi].status != 0) break; mbi++; if (mbi >= 2 * AHA1542_MAILBOXES) mbi = AHA1542_MAILBOXES; } while (mbi != aha1542->aha1542_last_mbi_used); if (mb[mbi].status == 0) { spin_unlock_irqrestore(sh->host_lock, flags); /* Hmm, no mail. Must have read it the last time around */ if (!number_serviced) shost_printk(KERN_WARNING, sh, "interrupt received, but no mail.\n"); return IRQ_HANDLED; } mbo = (scsi2int(mb[mbi].ccbptr) - (unsigned long)aha1542->ccb_handle) / sizeof(struct ccb); mbistatus = mb[mbi].status; mb[mbi].status = 0; aha1542->aha1542_last_mbi_used = mbi; #ifdef DEBUG if (ccb[mbo].tarstat | ccb[mbo].hastat) shost_printk(KERN_DEBUG, sh, "aha1542_command: returning %x (status %d)\n", ccb[mbo].tarstat + ((int) ccb[mbo].hastat << 16), mb[mbi].status); #endif if (mbistatus == 3) continue; /* Aborted command not found */ #ifdef DEBUG shost_printk(KERN_DEBUG, sh, "...done %d %d\n", mbo, mbi); #endif tmp_cmd = aha1542->int_cmds[mbo]; if (!tmp_cmd) { spin_unlock_irqrestore(sh->host_lock, flags); shost_printk(KERN_WARNING, sh, "Unexpected interrupt\n"); shost_printk(KERN_WARNING, sh, "tarstat=%x, hastat=%x idlun=%x ccb#=%d\n", ccb[mbo].tarstat, ccb[mbo].hastat, ccb[mbo].idlun, mbo); return IRQ_HANDLED; } aha1542_free_cmd(tmp_cmd); /* * Fetch the sense data, and tuck it away, in the required slot. The * Adaptec automatically fetches it, and there is no guarantee that * we will still have it in the cdb when we come back */ if (ccb[mbo].tarstat == 2) memcpy(tmp_cmd->sense_buffer, &ccb[mbo].cdb[ccb[mbo].cdblen], SCSI_SENSE_BUFFERSIZE); /* is there mail :-) */ /* more error checking left out here */ if (mbistatus != 1) /* This is surely wrong, but I don't know what's right */ errstatus = makecode(ccb[mbo].hastat, ccb[mbo].tarstat); else errstatus = 0; #ifdef DEBUG if (errstatus) shost_printk(KERN_DEBUG, sh, "(aha1542 error:%x %x %x) ", errstatus, ccb[mbo].hastat, ccb[mbo].tarstat); if (ccb[mbo].tarstat == 2) print_hex_dump_bytes("sense: ", DUMP_PREFIX_NONE, &ccb[mbo].cdb[ccb[mbo].cdblen], 12); if (errstatus) printk("aha1542_intr_handle: returning %6x\n", errstatus); #endif tmp_cmd->result = errstatus; aha1542->int_cmds[mbo] = NULL; /* This effectively frees up the mailbox slot, as * far as queuecommand is concerned */ scsi_done(tmp_cmd); number_serviced++; } } static int aha1542_queuecommand(struct Scsi_Host *sh, struct scsi_cmnd *cmd) { struct aha1542_cmd *acmd = scsi_cmd_priv(cmd); struct aha1542_hostdata *aha1542 = shost_priv(sh); u8 direction; u8 target = cmd->device->id; u8 lun = cmd->device->lun; unsigned long flags; int bufflen = scsi_bufflen(cmd); int mbo; struct mailbox *mb = aha1542->mb; struct ccb *ccb = aha1542->ccb; if (*cmd->cmnd == REQUEST_SENSE) { /* Don't do the command - we have the sense data already */ cmd->result = 0; scsi_done(cmd); return 0; } #ifdef DEBUG { int i = -1; if (*cmd->cmnd == READ_10 || *cmd->cmnd == WRITE_10) i = xscsi2int(cmd->cmnd + 2); else if (*cmd->cmnd == READ_6 || *cmd->cmnd == WRITE_6) i = scsi2int(cmd->cmnd + 2); shost_printk(KERN_DEBUG, sh, "aha1542_queuecommand: dev %d cmd %02x pos %d len %d", target, *cmd->cmnd, i, bufflen); print_hex_dump_bytes("command: ", DUMP_PREFIX_NONE, cmd->cmnd, cmd->cmd_len); } #endif if (cmd->sc_data_direction == DMA_TO_DEVICE) { struct request *rq = scsi_cmd_to_rq(cmd); void *buf = acmd->data_buffer; struct req_iterator iter; struct bio_vec bv; rq_for_each_segment(bv, rq, iter) { memcpy_from_bvec(buf, &bv); buf += bv.bv_len; } } /* * Use the outgoing mailboxes in a round-robin fashion, because this * is how the host adapter will scan for them */ spin_lock_irqsave(sh->host_lock, flags); mbo = aha1542->aha1542_last_mbo_used + 1; if (mbo >= AHA1542_MAILBOXES) mbo = 0; do { if (mb[mbo].status == 0 && aha1542->int_cmds[mbo] == NULL) break; mbo++; if (mbo >= AHA1542_MAILBOXES) mbo = 0; } while (mbo != aha1542->aha1542_last_mbo_used); if (mb[mbo].status || aha1542->int_cmds[mbo]) panic("Unable to find empty mailbox for aha1542.\n"); aha1542->int_cmds[mbo] = cmd; /* This will effectively prevent someone else from * screwing with this cdb. */ aha1542->aha1542_last_mbo_used = mbo; #ifdef DEBUG shost_printk(KERN_DEBUG, sh, "Sending command (%d)...", mbo); #endif /* This gets trashed for some reason */ any2scsi(mb[mbo].ccbptr, aha1542->ccb_handle + mbo * sizeof(*ccb)); memset(&ccb[mbo], 0, sizeof(struct ccb)); ccb[mbo].cdblen = cmd->cmd_len; direction = 0; if (*cmd->cmnd == READ_10 || *cmd->cmnd == READ_6) direction = 8; else if (*cmd->cmnd == WRITE_10 || *cmd->cmnd == WRITE_6) direction = 16; memcpy(ccb[mbo].cdb, cmd->cmnd, ccb[mbo].cdblen); ccb[mbo].op = 0; /* SCSI Initiator Command */ any2scsi(ccb[mbo].datalen, bufflen); if (bufflen) any2scsi(ccb[mbo].dataptr, acmd->data_buffer_handle); else any2scsi(ccb[mbo].dataptr, 0); ccb[mbo].idlun = (target & 7) << 5 | direction | (lun & 7); /*SCSI Target Id */ ccb[mbo].rsalen = 16; ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0; ccb[mbo].commlinkid = 0; #ifdef DEBUG print_hex_dump_bytes("sending: ", DUMP_PREFIX_NONE, &ccb[mbo], sizeof(ccb[mbo]) - 10); printk("aha1542_queuecommand: now waiting for interrupt "); #endif mb[mbo].status = 1; aha1542_outb(cmd->device->host->io_port, CMD_START_SCSI); spin_unlock_irqrestore(sh->host_lock, flags); return 0; } /* Initialize mailboxes */ static void setup_mailboxes(struct Scsi_Host *sh) { struct aha1542_hostdata *aha1542 = shost_priv(sh); u8 mb_cmd[5] = { CMD_MBINIT, AHA1542_MAILBOXES, 0, 0, 0}; int i; for (i = 0; i < AHA1542_MAILBOXES; i++) { aha1542->mb[i].status = 0; any2scsi(aha1542->mb[i].ccbptr, aha1542->ccb_handle + i * sizeof(struct ccb)); aha1542->mb[AHA1542_MAILBOXES + i].status = 0; } aha1542_intr_reset(sh->io_port); /* reset interrupts, so they don't block */ any2scsi(mb_cmd + 2, aha1542->mb_handle); if (aha1542_out(sh->io_port, mb_cmd, 5)) shost_printk(KERN_ERR, sh, "failed setting up mailboxes\n"); aha1542_intr_reset(sh->io_port); } static int aha1542_getconfig(struct Scsi_Host *sh) { u8 inquiry_result[3]; int i; i = inb(STATUS(sh->io_port)); if (i & DF) { i = inb(DATA(sh->io_port)); } aha1542_outb(sh->io_port, CMD_RETCONF); aha1542_in(sh->io_port, inquiry_result, 3, 0); if (!wait_mask(INTRFLAGS(sh->io_port), INTRMASK, HACC, 0, 0)) shost_printk(KERN_ERR, sh, "error querying board settings\n"); aha1542_intr_reset(sh->io_port); switch (inquiry_result[0]) { case 0x80: sh->dma_channel = 7; break; case 0x40: sh->dma_channel = 6; break; case 0x20: sh->dma_channel = 5; break; case 0x01: sh->dma_channel = 0; break; case 0: /* * This means that the adapter, although Adaptec 1542 compatible, doesn't use a DMA channel. * Currently only aware of the BusLogic BT-445S VL-Bus adapter which needs this. */ sh->dma_channel = 0xFF; break; default: shost_printk(KERN_ERR, sh, "Unable to determine DMA channel.\n"); return -1; } switch (inquiry_result[1]) { case 0x40: sh->irq = 15; break; case 0x20: sh->irq = 14; break; case 0x8: sh->irq = 12; break; case 0x4: sh->irq = 11; break; case 0x2: sh->irq = 10; break; case 0x1: sh->irq = 9; break; default: shost_printk(KERN_ERR, sh, "Unable to determine IRQ level.\n"); return -1; } sh->this_id = inquiry_result[2] & 7; return 0; } /* * This function should only be called for 1542C boards - we can detect * the special firmware settings and unlock the board */ static int aha1542_mbenable(struct Scsi_Host *sh) { static u8 mbenable_cmd[3]; static u8 mbenable_result[2]; int retval; retval = BIOS_TRANSLATION_6432; aha1542_outb(sh->io_port, CMD_EXTBIOS); if (aha1542_in(sh->io_port, mbenable_result, 2, 100)) return retval; if (!wait_mask(INTRFLAGS(sh->io_port), INTRMASK, HACC, 0, 100)) goto fail; aha1542_intr_reset(sh->io_port); if ((mbenable_result[0] & 0x08) || mbenable_result[1]) { mbenable_cmd[0] = CMD_MBENABLE; mbenable_cmd[1] = 0; mbenable_cmd[2] = mbenable_result[1]; if ((mbenable_result[0] & 0x08) && (mbenable_result[1] & 0x03)) retval = BIOS_TRANSLATION_25563; if (aha1542_out(sh->io_port, mbenable_cmd, 3)) goto fail; } while (0) { fail: shost_printk(KERN_ERR, sh, "Mailbox init failed\n"); } aha1542_intr_reset(sh->io_port); return retval; } /* Query the board to find out if it is a 1542 or a 1740, or whatever. */ static int aha1542_query(struct Scsi_Host *sh) { struct aha1542_hostdata *aha1542 = shost_priv(sh); u8 inquiry_result[4]; int i; i = inb(STATUS(sh->io_port)); if (i & DF) { i = inb(DATA(sh->io_port)); } aha1542_outb(sh->io_port, CMD_INQUIRY); aha1542_in(sh->io_port, inquiry_result, 4, 0); if (!wait_mask(INTRFLAGS(sh->io_port), INTRMASK, HACC, 0, 0)) shost_printk(KERN_ERR, sh, "error querying card type\n"); aha1542_intr_reset(sh->io_port); aha1542->bios_translation = BIOS_TRANSLATION_6432; /* Default case */ /* * For an AHA1740 series board, we ignore the board since there is a * hardware bug which can lead to wrong blocks being returned if the board * is operating in the 1542 emulation mode. Since there is an extended mode * driver, we simply ignore the board and let the 1740 driver pick it up. */ if (inquiry_result[0] == 0x43) { shost_printk(KERN_INFO, sh, "Emulation mode not supported for AHA-1740 hardware, use aha1740 driver instead.\n"); return 1; } /* * Always call this - boards that do not support extended bios translation * will ignore the command, and we will set the proper default */ aha1542->bios_translation = aha1542_mbenable(sh); return 0; } static u8 dma_speed_hw(int dma_speed) { switch (dma_speed) { case 5: return 0x00; case 6: return 0x04; case 7: return 0x01; case 8: return 0x02; case 10: return 0x03; } return 0xff; /* invalid */ } /* Set the Bus on/off-times as not to ruin floppy performance */ static void aha1542_set_bus_times(struct Scsi_Host *sh, int bus_on, int bus_off, int dma_speed) { if (bus_on > 0) { u8 oncmd[] = { CMD_BUSON_TIME, clamp(bus_on, 2, 15) }; aha1542_intr_reset(sh->io_port); if (aha1542_out(sh->io_port, oncmd, 2)) goto fail; } if (bus_off > 0) { u8 offcmd[] = { CMD_BUSOFF_TIME, clamp(bus_off, 1, 64) }; aha1542_intr_reset(sh->io_port); if (aha1542_out(sh->io_port, offcmd, 2)) goto fail; } if (dma_speed_hw(dma_speed) != 0xff) { u8 dmacmd[] = { CMD_DMASPEED, dma_speed_hw(dma_speed) }; aha1542_intr_reset(sh->io_port); if (aha1542_out(sh->io_port, dmacmd, 2)) goto fail; } aha1542_intr_reset(sh->io_port); return; fail: shost_printk(KERN_ERR, sh, "setting bus on/off-time failed\n"); aha1542_intr_reset(sh->io_port); } /* return non-zero on detection */ static struct Scsi_Host *aha1542_hw_init(struct scsi_host_template *tpnt, struct device *pdev, int indx) { unsigned int base_io = io[indx]; struct Scsi_Host *sh; struct aha1542_hostdata *aha1542; char dma_info[] = "no DMA"; if (base_io == 0) return NULL; if (!request_region(base_io, AHA1542_REGION_SIZE, "aha1542")) return NULL; sh = scsi_host_alloc(tpnt, sizeof(struct aha1542_hostdata)); if (!sh) goto release; aha1542 = shost_priv(sh); sh->unique_id = base_io; sh->io_port = base_io; sh->n_io_port = AHA1542_REGION_SIZE; aha1542->aha1542_last_mbi_used = 2 * AHA1542_MAILBOXES - 1; aha1542->aha1542_last_mbo_used = AHA1542_MAILBOXES - 1; if (!aha1542_test_port(sh)) goto unregister; aha1542_set_bus_times(sh, bus_on[indx], bus_off[indx], dma_speed[indx]); if (aha1542_query(sh)) goto unregister; if (aha1542_getconfig(sh) == -1) goto unregister; if (sh->dma_channel != 0xFF) snprintf(dma_info, sizeof(dma_info), "DMA %d", sh->dma_channel); shost_printk(KERN_INFO, sh, "Adaptec AHA-1542 (SCSI-ID %d) at IO 0x%x, IRQ %d, %s\n", sh->this_id, base_io, sh->irq, dma_info); if (aha1542->bios_translation == BIOS_TRANSLATION_25563) shost_printk(KERN_INFO, sh, "Using extended bios translation\n"); if (dma_set_mask_and_coherent(pdev, DMA_BIT_MASK(24)) < 0) goto unregister; aha1542->mb = dma_alloc_coherent(pdev, AHA1542_MAILBOXES * 2 * sizeof(struct mailbox), &aha1542->mb_handle, GFP_KERNEL); if (!aha1542->mb) goto unregister; aha1542->ccb = dma_alloc_coherent(pdev, AHA1542_MAILBOXES * sizeof(struct ccb), &aha1542->ccb_handle, GFP_KERNEL); if (!aha1542->ccb) goto free_mb; setup_mailboxes(sh); if (request_irq(sh->irq, aha1542_interrupt, 0, "aha1542", sh)) { shost_printk(KERN_ERR, sh, "Unable to allocate IRQ.\n"); goto free_ccb; } if (sh->dma_channel != 0xFF) { if (request_dma(sh->dma_channel, "aha1542")) { shost_printk(KERN_ERR, sh, "Unable to allocate DMA channel.\n"); goto free_irq; } if (sh->dma_channel == 0 || sh->dma_channel >= 5) { set_dma_mode(sh->dma_channel, DMA_MODE_CASCADE); enable_dma(sh->dma_channel); } } if (scsi_add_host(sh, pdev)) goto free_dma; scsi_scan_host(sh); return sh; free_dma: if (sh->dma_channel != 0xff) free_dma(sh->dma_channel); free_irq: free_irq(sh->irq, sh); free_ccb: dma_free_coherent(pdev, AHA1542_MAILBOXES * sizeof(struct ccb), aha1542->ccb, aha1542->ccb_handle); free_mb: dma_free_coherent(pdev, AHA1542_MAILBOXES * 2 * sizeof(struct mailbox), aha1542->mb, aha1542->mb_handle); unregister: scsi_host_put(sh); release: release_region(base_io, AHA1542_REGION_SIZE); return NULL; } static int aha1542_release(struct Scsi_Host *sh) { struct aha1542_hostdata *aha1542 = shost_priv(sh); struct device *dev = sh->dma_dev; scsi_remove_host(sh); if (sh->dma_channel != 0xff) free_dma(sh->dma_channel); dma_free_coherent(dev, AHA1542_MAILBOXES * sizeof(struct ccb), aha1542->ccb, aha1542->ccb_handle); dma_free_coherent(dev, AHA1542_MAILBOXES * 2 * sizeof(struct mailbox), aha1542->mb, aha1542->mb_handle); if (sh->irq) free_irq(sh->irq, sh); if (sh->io_port && sh->n_io_port) release_region(sh->io_port, sh->n_io_port); scsi_host_put(sh); return 0; } /* * This is a device reset. This is handled by sending a special command * to the device. */ static int aha1542_dev_reset(struct scsi_cmnd *cmd) { struct Scsi_Host *sh = cmd->device->host; struct aha1542_hostdata *aha1542 = shost_priv(sh); unsigned long flags; struct mailbox *mb = aha1542->mb; u8 target = cmd->device->id; u8 lun = cmd->device->lun; int mbo; struct ccb *ccb = aha1542->ccb; spin_lock_irqsave(sh->host_lock, flags); mbo = aha1542->aha1542_last_mbo_used + 1; if (mbo >= AHA1542_MAILBOXES) mbo = 0; do { if (mb[mbo].status == 0 && aha1542->int_cmds[mbo] == NULL) break; mbo++; if (mbo >= AHA1542_MAILBOXES) mbo = 0; } while (mbo != aha1542->aha1542_last_mbo_used); if (mb[mbo].status || aha1542->int_cmds[mbo]) panic("Unable to find empty mailbox for aha1542.\n"); aha1542->int_cmds[mbo] = cmd; /* This will effectively * prevent someone else from * screwing with this cdb. */ aha1542->aha1542_last_mbo_used = mbo; /* This gets trashed for some reason */ any2scsi(mb[mbo].ccbptr, aha1542->ccb_handle + mbo * sizeof(*ccb)); memset(&ccb[mbo], 0, sizeof(struct ccb)); ccb[mbo].op = 0x81; /* BUS DEVICE RESET */ ccb[mbo].idlun = (target & 7) << 5 | (lun & 7); /*SCSI Target Id */ ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0; ccb[mbo].commlinkid = 0; /* * Now tell the 1542 to flush all pending commands for this * target */ aha1542_outb(sh->io_port, CMD_START_SCSI); spin_unlock_irqrestore(sh->host_lock, flags); scmd_printk(KERN_WARNING, cmd, "Trying device reset for target\n"); return SUCCESS; } static int aha1542_reset(struct scsi_cmnd *cmd, u8 reset_cmd) { struct Scsi_Host *sh = cmd->device->host; struct aha1542_hostdata *aha1542 = shost_priv(sh); unsigned long flags; int i; spin_lock_irqsave(sh->host_lock, flags); /* * This does a scsi reset for all devices on the bus. * In principle, we could also reset the 1542 - should * we do this? Try this first, and we can add that later * if it turns out to be useful. */ outb(reset_cmd, CONTROL(cmd->device->host->io_port)); if (!wait_mask(STATUS(cmd->device->host->io_port), STATMASK, IDLE, STST | DIAGF | INVDCMD | DF | CDF, 0)) { spin_unlock_irqrestore(sh->host_lock, flags); return FAILED; } /* * We need to do this too before the 1542 can interact with * us again after host reset. */ if (reset_cmd & HRST) setup_mailboxes(cmd->device->host); /* * Now try to pick up the pieces. For all pending commands, * free any internal data structures, and basically clear things * out. We do not try and restart any commands or anything - * the strategy handler takes care of that crap. */ shost_printk(KERN_WARNING, cmd->device->host, "Sent BUS RESET to scsi host %d\n", cmd->device->host->host_no); for (i = 0; i < AHA1542_MAILBOXES; i++) { if (aha1542->int_cmds[i] != NULL) { struct scsi_cmnd *tmp_cmd; tmp_cmd = aha1542->int_cmds[i]; if (tmp_cmd->device->soft_reset) { /* * If this device implements the soft reset option, * then it is still holding onto the command, and * may yet complete it. In this case, we don't * flush the data. */ continue; } aha1542_free_cmd(tmp_cmd); aha1542->int_cmds[i] = NULL; aha1542->mb[i].status = 0; } } spin_unlock_irqrestore(sh->host_lock, flags); return SUCCESS; } static int aha1542_bus_reset(struct scsi_cmnd *cmd) { return aha1542_reset(cmd, SCRST); } static int aha1542_host_reset(struct scsi_cmnd *cmd) { return aha1542_reset(cmd, HRST | SCRST); } static int aha1542_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int geom[]) { struct aha1542_hostdata *aha1542 = shost_priv(sdev->host); if (capacity >= 0x200000 && aha1542->bios_translation == BIOS_TRANSLATION_25563) { /* Please verify that this is the same as what DOS returns */ geom[0] = 255; /* heads */ geom[1] = 63; /* sectors */ } else { geom[0] = 64; /* heads */ geom[1] = 32; /* sectors */ } geom[2] = sector_div(capacity, geom[0] * geom[1]); /* cylinders */ return 0; } MODULE_LICENSE("GPL"); static int aha1542_init_cmd_priv(struct Scsi_Host *shost, struct scsi_cmnd *cmd) { struct aha1542_cmd *acmd = scsi_cmd_priv(cmd); acmd->data_buffer = dma_alloc_coherent(shost->dma_dev, SECTOR_SIZE * AHA1542_MAX_SECTORS, &acmd->data_buffer_handle, GFP_KERNEL); if (!acmd->data_buffer) return -ENOMEM; return 0; } static int aha1542_exit_cmd_priv(struct Scsi_Host *shost, struct scsi_cmnd *cmd) { struct aha1542_cmd *acmd = scsi_cmd_priv(cmd); dma_free_coherent(shost->dma_dev, SECTOR_SIZE * AHA1542_MAX_SECTORS, acmd->data_buffer, acmd->data_buffer_handle); return 0; } static struct scsi_host_template driver_template = { .module = THIS_MODULE, .proc_name = "aha1542", .name = "Adaptec 1542", .cmd_size = sizeof(struct aha1542_cmd), .queuecommand = aha1542_queuecommand, .eh_device_reset_handler= aha1542_dev_reset, .eh_bus_reset_handler = aha1542_bus_reset, .eh_host_reset_handler = aha1542_host_reset, .bios_param = aha1542_biosparam, .init_cmd_priv = aha1542_init_cmd_priv, .exit_cmd_priv = aha1542_exit_cmd_priv, .can_queue = AHA1542_MAILBOXES, .this_id = 7, .max_sectors = AHA1542_MAX_SECTORS, .sg_tablesize = SG_ALL, }; static int aha1542_isa_match(struct device *pdev, unsigned int ndev) { struct Scsi_Host *sh = aha1542_hw_init(&driver_template, pdev, ndev); if (!sh) return 0; dev_set_drvdata(pdev, sh); return 1; } static void aha1542_isa_remove(struct device *pdev, unsigned int ndev) { aha1542_release(dev_get_drvdata(pdev)); dev_set_drvdata(pdev, NULL); } static struct isa_driver aha1542_isa_driver = { .match = aha1542_isa_match, .remove = aha1542_isa_remove, .driver = { .name = "aha1542" }, }; static int isa_registered; #ifdef CONFIG_PNP static const struct pnp_device_id aha1542_pnp_ids[] = { { .id = "ADP1542" }, { .id = "" } }; MODULE_DEVICE_TABLE(pnp, aha1542_pnp_ids); static int aha1542_pnp_probe(struct pnp_dev *pdev, const struct pnp_device_id *id) { int indx; struct Scsi_Host *sh; for (indx = 0; indx < ARRAY_SIZE(io); indx++) { if (io[indx]) continue; if (pnp_activate_dev(pdev) < 0) continue; io[indx] = pnp_port_start(pdev, 0); /* * The card can be queried for its DMA, we have * the DMA set up that is enough */ dev_info(&pdev->dev, "ISAPnP found an AHA1535 at I/O 0x%03X", io[indx]); } sh = aha1542_hw_init(&driver_template, &pdev->dev, indx); if (!sh) return -ENODEV; pnp_set_drvdata(pdev, sh); return 0; } static void aha1542_pnp_remove(struct pnp_dev *pdev) { aha1542_release(pnp_get_drvdata(pdev)); pnp_set_drvdata(pdev, NULL); } static struct pnp_driver aha1542_pnp_driver = { .name = "aha1542", .id_table = aha1542_pnp_ids, .probe = aha1542_pnp_probe, .remove = aha1542_pnp_remove, }; static int pnp_registered; #endif /* CONFIG_PNP */ static int __init aha1542_init(void) { int ret = 0; #ifdef CONFIG_PNP if (isapnp) { ret = pnp_register_driver(&aha1542_pnp_driver); if (!ret) pnp_registered = 1; } #endif ret = isa_register_driver(&aha1542_isa_driver, MAXBOARDS); if (!ret) isa_registered = 1; #ifdef CONFIG_PNP if (pnp_registered) ret = 0; #endif if (isa_registered) ret = 0; return ret; } static void __exit aha1542_exit(void) { #ifdef CONFIG_PNP if (pnp_registered) pnp_unregister_driver(&aha1542_pnp_driver); #endif if (isa_registered) isa_unregister_driver(&aha1542_isa_driver); } module_init(aha1542_init); module_exit(aha1542_exit);