Quelle  aha1542.c   Sprache: C

// 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_DESCRIPTION("Adaptec AHA-1542 SCSI host adapter driver");
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);