drivers/scsi/aha1542.c

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