diff options
Diffstat (limited to 'drivers/scsi/aha1542.c')
| -rw-r--r-- | drivers/scsi/aha1542.c | 1168 |
1 files changed, 1168 insertions, 0 deletions
diff --git a/drivers/scsi/aha1542.c b/drivers/scsi/aha1542.c new file mode 100644 index 0000000000..9503996c63 --- /dev/null +++ b/drivers/scsi/aha1542.c @@ -0,0 +1,1168 @@ +// 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 <linux/module.h> +#include <linux/interrupt.h> +#include <linux/kernel.h> +#include <linux/types.h> +#include <linux/string.h> +#include <linux/delay.h> +#include <linux/init.h> +#include <linux/spinlock.h> +#include <linux/isa.h> +#include <linux/pnp.h> +#include <linux/slab.h> +#include <linux/io.h> +#include <asm/dma.h> +#include <scsi/scsi_cmnd.h> +#include <scsi/scsi_device.h> +#include <scsi/scsi_host.h> +#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(const 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 const 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); |