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_array(io, int, 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(sizeof(*cptr) * sg_count, GFP_KERNEL | GFP_DMA);
 404                 if (!cptr)
 405                         return SCSI_MLQUEUE_HOST_BUSY;
 406         }
 407
 408         /* Use the outgoing mailboxes in a round-robin fashion, because this
 409            is how the host adapter will scan for them */
 410
 411         spin_lock_irqsave(sh->host_lock, flags);
 412         mbo = aha1542->aha1542_last_mbo_used + 1;
 413         if (mbo >= AHA1542_MAILBOXES)
 414                 mbo = 0;
 415
 416         do {
 417                 if (mb[mbo].status == 0 && aha1542->int_cmds[mbo] == NULL)
 418                         break;
 419                 mbo++;
 420                 if (mbo >= AHA1542_MAILBOXES)
 421                         mbo = 0;
 422         } while (mbo != aha1542->aha1542_last_mbo_used);
 423
 424         if (mb[mbo].status || aha1542->int_cmds[mbo])
 425                 panic("Unable to find empty mailbox for aha1542.\n");
 426
 427         aha1542->int_cmds[mbo] = cmd;   /* This will effectively prevent someone else from
 428                                            screwing with this cdb. */
 429
 430         aha1542->aha1542_last_mbo_used = mbo;
 431
 432 #ifdef DEBUG
 433         shost_printk(KERN_DEBUG, sh, "Sending command (%d %p)...", mbo, cmd->scsi_done);
 434 #endif
 435
 436         any2scsi(mb[mbo].ccbptr, isa_virt_to_bus(&ccb[mbo]));   /* This gets trashed for some reason */
 437
 438         memset(&ccb[mbo], 0, sizeof(struct ccb));
 439
 440         ccb[mbo].cdblen = cmd->cmd_len;
 441
 442         direction = 0;
 443         if (*cmd->cmnd == READ_10 || *cmd->cmnd == READ_6)
 444                 direction = 8;
 445         else if (*cmd->cmnd == WRITE_10 || *cmd->cmnd == WRITE_6)
 446                 direction = 16;
 447
 448         memcpy(ccb[mbo].cdb, cmd->cmnd, ccb[mbo].cdblen);
 449
 450         if (bufflen) {
 451                 struct scatterlist *sg;
 452                 int i;
 453
 454                 ccb[mbo].op = 2;        /* SCSI Initiator Command  w/scatter-gather */
 455                 cmd->host_scribble = (void *)cptr;
 456                 scsi_for_each_sg(cmd, sg, sg_count, i) {
 457                         any2scsi(cptr[i].dataptr, isa_page_to_bus(sg_page(sg))
 458                                                                 + sg->offset);
 459                         any2scsi(cptr[i].datalen, sg->length);
 460                 };
 461                 any2scsi(ccb[mbo].datalen, sg_count * sizeof(struct chain));
 462                 any2scsi(ccb[mbo].dataptr, isa_virt_to_bus(cptr));
 463 #ifdef DEBUG
 464                 shost_printk(KERN_DEBUG, sh, "cptr %p: ", cptr);
 465                 print_hex_dump_bytes("cptr: ", DUMP_PREFIX_NONE, cptr, 18);
 466 #endif
 467         } else {
 468                 ccb[mbo].op = 0;        /* SCSI Initiator Command */
 469                 cmd->host_scribble = NULL;
 470                 any2scsi(ccb[mbo].datalen, 0);
 471                 any2scsi(ccb[mbo].dataptr, 0);
 472         };
 473         ccb[mbo].idlun = (target & 7) << 5 | direction | (lun & 7);     /*SCSI Target Id */
 474         ccb[mbo].rsalen = 16;
 475         ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
 476         ccb[mbo].commlinkid = 0;
 477
 478 #ifdef DEBUG
 479         print_hex_dump_bytes("sending: ", DUMP_PREFIX_NONE, &ccb[mbo], sizeof(ccb[mbo]) - 10);
 480         printk("aha1542_queuecommand: now waiting for interrupt ");
 481 #endif
 482         mb[mbo].status = 1;
 483         aha1542_outb(cmd->device->host->io_port, CMD_START_SCSI);
 484         spin_unlock_irqrestore(sh->host_lock, flags);
 485
 486         return 0;
 487 }
 488
 489 /* Initialize mailboxes */
 490 static void setup_mailboxes(struct Scsi_Host *sh)
 491 {
 492         struct aha1542_hostdata *aha1542 = shost_priv(sh);
 493         int i;
 494         struct mailbox *mb = aha1542->mb;
 495         struct ccb *ccb = aha1542->ccb;
 496
 497         u8 mb_cmd[5] = { CMD_MBINIT, AHA1542_MAILBOXES, 0, 0, 0};
 498
 499         for (i = 0; i < AHA1542_MAILBOXES; i++) {
 500                 mb[i].status = mb[AHA1542_MAILBOXES + i].status = 0;
 501                 any2scsi(mb[i].ccbptr, isa_virt_to_bus(&ccb[i]));
 502         };
 503         aha1542_intr_reset(sh->io_port);        /* reset interrupts, so they don't block */
 504         any2scsi((mb_cmd + 2), isa_virt_to_bus(mb));
 505         if (aha1542_out(sh->io_port, mb_cmd, 5))
 506                 shost_printk(KERN_ERR, sh, "failed setting up mailboxes\n");
 507         aha1542_intr_reset(sh->io_port);
 508 }
 509
 510 static int aha1542_getconfig(struct Scsi_Host *sh)
 511 {
 512         u8 inquiry_result[3];
 513         int i;
 514         i = inb(STATUS(sh->io_port));
 515         if (i & DF) {
 516                 i = inb(DATA(sh->io_port));
 517         };
 518         aha1542_outb(sh->io_port, CMD_RETCONF);
 519         aha1542_in(sh->io_port, inquiry_result, 3, 0);
 520         if (!wait_mask(INTRFLAGS(sh->io_port), INTRMASK, HACC, 0, 0))
 521                 shost_printk(KERN_ERR, sh, "error querying board settings\n");
 522         aha1542_intr_reset(sh->io_port);
 523         switch (inquiry_result[0]) {
 524         case 0x80:
 525                 sh->dma_channel = 7;
 526                 break;
 527         case 0x40:
 528                 sh->dma_channel = 6;
 529                 break;
 530         case 0x20:
 531                 sh->dma_channel = 5;
 532                 break;
 533         case 0x01:
 534                 sh->dma_channel = 0;
 535                 break;
 536         case 0:
 537                 /* This means that the adapter, although Adaptec 1542 compatible, doesn't use a DMA channel.
 538                    Currently only aware of the BusLogic BT-445S VL-Bus adapter which needs this. */
 539                 sh->dma_channel = 0xFF;
 540                 break;
 541         default:
 542                 shost_printk(KERN_ERR, sh, "Unable to determine DMA channel.\n");
 543                 return -1;
 544         };
 545         switch (inquiry_result[1]) {
 546         case 0x40:
 547                 sh->irq = 15;
 548                 break;
 549         case 0x20:
 550                 sh->irq = 14;
 551                 break;
 552         case 0x8:
 553                 sh->irq = 12;
 554                 break;
 555         case 0x4:
 556                 sh->irq = 11;
 557                 break;
 558         case 0x2:
 559                 sh->irq = 10;
 560                 break;
 561         case 0x1:
 562                 sh->irq = 9;
 563                 break;
 564         default:
 565                 shost_printk(KERN_ERR, sh, "Unable to determine IRQ level.\n");
 566                 return -1;
 567         };
 568         sh->this_id = inquiry_result[2] & 7;
 569         return 0;
 570 }
 571
 572 /* This function should only be called for 1542C boards - we can detect
 573    the special firmware settings and unlock the board */
 574
 575 static int aha1542_mbenable(struct Scsi_Host *sh)
 576 {
 577         static u8 mbenable_cmd[3];
 578         static u8 mbenable_result[2];
 579         int retval;
 580
 581         retval = BIOS_TRANSLATION_6432;
 582
 583         aha1542_outb(sh->io_port, CMD_EXTBIOS);
 584         if (aha1542_in(sh->io_port, mbenable_result, 2, 100))
 585                 return retval;
 586         if (!wait_mask(INTRFLAGS(sh->io_port), INTRMASK, HACC, 0, 100))
 587                 goto fail;
 588         aha1542_intr_reset(sh->io_port);
 589
 590         if ((mbenable_result[0] & 0x08) || mbenable_result[1]) {
 591                 mbenable_cmd[0] = CMD_MBENABLE;
 592                 mbenable_cmd[1] = 0;
 593                 mbenable_cmd[2] = mbenable_result[1];
 594
 595                 if ((mbenable_result[0] & 0x08) && (mbenable_result[1] & 0x03))
 596                         retval = BIOS_TRANSLATION_25563;
 597
 598                 if (aha1542_out(sh->io_port, mbenable_cmd, 3))
 599                         goto fail;
 600         };
 601         while (0) {
 602 fail:
 603                 shost_printk(KERN_ERR, sh, "Mailbox init failed\n");
 604         }
 605         aha1542_intr_reset(sh->io_port);
 606         return retval;
 607 }
 608
 609 /* Query the board to find out if it is a 1542 or a 1740, or whatever. */
 610 static int aha1542_query(struct Scsi_Host *sh)
 611 {
 612         struct aha1542_hostdata *aha1542 = shost_priv(sh);
 613         u8 inquiry_result[4];
 614         int i;
 615         i = inb(STATUS(sh->io_port));
 616         if (i & DF) {
 617                 i = inb(DATA(sh->io_port));
 618         };
 619         aha1542_outb(sh->io_port, CMD_INQUIRY);
 620         aha1542_in(sh->io_port, inquiry_result, 4, 0);
 621         if (!wait_mask(INTRFLAGS(sh->io_port), INTRMASK, HACC, 0, 0))
 622                 shost_printk(KERN_ERR, sh, "error querying card type\n");
 623         aha1542_intr_reset(sh->io_port);
 624
 625         aha1542->bios_translation = BIOS_TRANSLATION_6432;      /* Default case */
 626
 627         /* For an AHA1740 series board, we ignore the board since there is a
 628            hardware bug which can lead to wrong blocks being returned if the board
 629            is operating in the 1542 emulation mode.  Since there is an extended mode
 630            driver, we simply ignore the board and let the 1740 driver pick it up.
 631          */
 632
 633         if (inquiry_result[0] == 0x43) {
 634                 shost_printk(KERN_INFO, sh, "Emulation mode not supported for AHA-1740 hardware, use aha1740 driver instead.\n");
 635                 return 1;
 636         };
 637
 638         /* Always call this - boards that do not support extended bios translation
 639            will ignore the command, and we will set the proper default */
 640
 641         aha1542->bios_translation = aha1542_mbenable(sh);
 642
 643         return 0;
 644 }
 645
 646 static u8 dma_speed_hw(int dma_speed)
 647 {
 648         switch (dma_speed) {
 649         case 5:
 650                 return 0x00;
 651         case 6:
 652                 return 0x04;
 653         case 7:
 654                 return 0x01;
 655         case 8:
 656                 return 0x02;
 657         case 10:
 658                 return 0x03;
 659         }
 660
 661         return 0xff;    /* invalid */
 662 }
 663
 664 /* Set the Bus on/off-times as not to ruin floppy performance */
 665 static void aha1542_set_bus_times(struct Scsi_Host *sh, int bus_on, int bus_off, int dma_speed)
 666 {
 667         if (bus_on > 0) {
 668                 u8 oncmd[] = { CMD_BUSON_TIME, clamp(bus_on, 2, 15) };
 669
 670                 aha1542_intr_reset(sh->io_port);
 671                 if (aha1542_out(sh->io_port, oncmd, 2))
 672                         goto fail;
 673         }
 674
 675         if (bus_off > 0) {
 676                 u8 offcmd[] = { CMD_BUSOFF_TIME, clamp(bus_off, 1, 64) };
 677
 678                 aha1542_intr_reset(sh->io_port);
 679                 if (aha1542_out(sh->io_port, offcmd, 2))
 680                         goto fail;
 681         }
 682
 683         if (dma_speed_hw(dma_speed) != 0xff) {
 684                 u8 dmacmd[] = { CMD_DMASPEED, dma_speed_hw(dma_speed) };
 685
 686                 aha1542_intr_reset(sh->io_port);
 687                 if (aha1542_out(sh->io_port, dmacmd, 2))
 688                         goto fail;
 689         }
 690         aha1542_intr_reset(sh->io_port);
 691         return;
 692 fail:
 693         shost_printk(KERN_ERR, sh, "setting bus on/off-time failed\n");
 694         aha1542_intr_reset(sh->io_port);
 695 }
 696
 697 /* return non-zero on detection */
 698 static struct Scsi_Host *aha1542_hw_init(struct scsi_host_template *tpnt, struct device *pdev, int indx)
 699 {
 700         unsigned int base_io = io[indx];
 701         struct Scsi_Host *sh;
 702         struct aha1542_hostdata *aha1542;
 703         char dma_info[] = "no DMA";
 704
 705         if (base_io == 0)
 706                 return NULL;
 707
 708         if (!request_region(base_io, AHA1542_REGION_SIZE, "aha1542"))
 709                 return NULL;
 710
 711         sh = scsi_host_alloc(tpnt, sizeof(struct aha1542_hostdata));
 712         if (!sh)
 713                 goto release;
 714         aha1542 = shost_priv(sh);
 715
 716         sh->unique_id = base_io;
 717         sh->io_port = base_io;
 718         sh->n_io_port = AHA1542_REGION_SIZE;
 719         aha1542->aha1542_last_mbi_used = 2 * AHA1542_MAILBOXES - 1;
 720         aha1542->aha1542_last_mbo_used = AHA1542_MAILBOXES - 1;
 721
 722         if (!aha1542_test_port(sh))
 723                 goto unregister;
 724
 725         aha1542_set_bus_times(sh, bus_on[indx], bus_off[indx], dma_speed[indx]);
 726         if (aha1542_query(sh))
 727                 goto unregister;
 728         if (aha1542_getconfig(sh) == -1)
 729                 goto unregister;
 730
 731         if (sh->dma_channel != 0xFF)
 732                 snprintf(dma_info, sizeof(dma_info), "DMA %d", sh->dma_channel);
 733         shost_printk(KERN_INFO, sh, "Adaptec AHA-1542 (SCSI-ID %d) at IO 0x%x, IRQ %d, %s\n",
 734                                 sh->this_id, base_io, sh->irq, dma_info);
 735         if (aha1542->bios_translation == BIOS_TRANSLATION_25563)
 736                 shost_printk(KERN_INFO, sh, "Using extended bios translation\n");
 737
 738         setup_mailboxes(sh);
 739
 740         if (request_irq(sh->irq, aha1542_interrupt, 0, "aha1542", sh)) {
 741                 shost_printk(KERN_ERR, sh, "Unable to allocate IRQ.\n");
 742                 goto unregister;
 743         }
 744         if (sh->dma_channel != 0xFF) {
 745                 if (request_dma(sh->dma_channel, "aha1542")) {
 746                         shost_printk(KERN_ERR, sh, "Unable to allocate DMA channel.\n");
 747                         goto free_irq;
 748                 }
 749                 if (sh->dma_channel == 0 || sh->dma_channel >= 5) {
 750                         set_dma_mode(sh->dma_channel, DMA_MODE_CASCADE);
 751                         enable_dma(sh->dma_channel);
 752                 }
 753         }
 754
 755         if (scsi_add_host(sh, pdev))
 756                 goto free_dma;
 757
 758         scsi_scan_host(sh);
 759
 760         return sh;
 761 free_dma:
 762         if (sh->dma_channel != 0xff)
 763                 free_dma(sh->dma_channel);
 764 free_irq:
 765         free_irq(sh->irq, sh);
 766 unregister:
 767         scsi_host_put(sh);
 768 release:
 769         release_region(base_io, AHA1542_REGION_SIZE);
 770
 771         return NULL;
 772 }
 773
 774 static int aha1542_release(struct Scsi_Host *sh)
 775 {
 776         scsi_remove_host(sh);
 777         if (sh->dma_channel != 0xff)
 778                 free_dma(sh->dma_channel);
 779         if (sh->irq)
 780                 free_irq(sh->irq, sh);
 781         if (sh->io_port && sh->n_io_port)
 782                 release_region(sh->io_port, sh->n_io_port);
 783         scsi_host_put(sh);
 784         return 0;
 785 }
 786
 787
 788 /*
 789  * This is a device reset.  This is handled by sending a special command
 790  * to the device.
 791  */
 792 static int aha1542_dev_reset(struct scsi_cmnd *cmd)
 793 {
 794         struct Scsi_Host *sh = cmd->device->host;
 795         struct aha1542_hostdata *aha1542 = shost_priv(sh);
 796         unsigned long flags;
 797         struct mailbox *mb = aha1542->mb;
 798         u8 target = cmd->device->id;
 799         u8 lun = cmd->device->lun;
 800         int mbo;
 801         struct ccb *ccb = aha1542->ccb;
 802
 803         spin_lock_irqsave(sh->host_lock, flags);
 804         mbo = aha1542->aha1542_last_mbo_used + 1;
 805         if (mbo >= AHA1542_MAILBOXES)
 806                 mbo = 0;
 807
 808         do {
 809                 if (mb[mbo].status == 0 && aha1542->int_cmds[mbo] == NULL)
 810                         break;
 811                 mbo++;
 812                 if (mbo >= AHA1542_MAILBOXES)
 813                         mbo = 0;
 814         } while (mbo != aha1542->aha1542_last_mbo_used);
 815
 816         if (mb[mbo].status || aha1542->int_cmds[mbo])
 817                 panic("Unable to find empty mailbox for aha1542.\n");
 818
 819         aha1542->int_cmds[mbo] = cmd;   /* This will effectively
 820                                            prevent someone else from
 821                                            screwing with this cdb. */
 822
 823         aha1542->aha1542_last_mbo_used = mbo;
 824
 825         any2scsi(mb[mbo].ccbptr, isa_virt_to_bus(&ccb[mbo]));   /* This gets trashed for some reason */
 826
 827         memset(&ccb[mbo], 0, sizeof(struct ccb));
 828
 829         ccb[mbo].op = 0x81;     /* BUS DEVICE RESET */
 830
 831         ccb[mbo].idlun = (target & 7) << 5 | (lun & 7);         /*SCSI Target Id */
 832
 833         ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
 834         ccb[mbo].commlinkid = 0;
 835
 836         /*
 837          * Now tell the 1542 to flush all pending commands for this
 838          * target
 839          */
 840         aha1542_outb(sh->io_port, CMD_START_SCSI);
 841         spin_unlock_irqrestore(sh->host_lock, flags);
 842
 843         scmd_printk(KERN_WARNING, cmd,
 844                 "Trying device reset for target\n");
 845
 846         return SUCCESS;
 847 }
 848
 849 static int aha1542_reset(struct scsi_cmnd *cmd, u8 reset_cmd)
 850 {
 851         struct Scsi_Host *sh = cmd->device->host;
 852         struct aha1542_hostdata *aha1542 = shost_priv(sh);
 853         unsigned long flags;
 854         int i;
 855
 856         spin_lock_irqsave(sh->host_lock, flags);
 857         /*
 858          * This does a scsi reset for all devices on the bus.
 859          * In principle, we could also reset the 1542 - should
 860          * we do this?  Try this first, and we can add that later
 861          * if it turns out to be useful.
 862          */
 863         outb(reset_cmd, CONTROL(cmd->device->host->io_port));
 864
 865         if (!wait_mask(STATUS(cmd->device->host->io_port),
 866              STATMASK, IDLE, STST | DIAGF | INVDCMD | DF | CDF, 0)) {
 867                 spin_unlock_irqrestore(sh->host_lock, flags);
 868                 return FAILED;
 869         }
 870
 871         /*
 872          * We need to do this too before the 1542 can interact with
 873          * us again after host reset.
 874          */
 875         if (reset_cmd & HRST)
 876                 setup_mailboxes(cmd->device->host);
 877
 878         /*
 879          * Now try to pick up the pieces.  For all pending commands,
 880          * free any internal data structures, and basically clear things
 881          * out.  We do not try and restart any commands or anything -
 882          * the strategy handler takes care of that crap.
 883          */
 884         shost_printk(KERN_WARNING, cmd->device->host, "Sent BUS RESET to scsi host %d\n", cmd->device->host->host_no);
 885
 886         for (i = 0; i < AHA1542_MAILBOXES; i++) {
 887                 if (aha1542->int_cmds[i] != NULL) {
 888                         struct scsi_cmnd *tmp_cmd;
 889                         tmp_cmd = aha1542->int_cmds[i];
 890
 891                         if (tmp_cmd->device->soft_reset) {
 892                                 /*
 893                                  * If this device implements the soft reset option,
 894                                  * then it is still holding onto the command, and
 895                                  * may yet complete it.  In this case, we don't
 896                                  * flush the data.
 897                                  */
 898                                 continue;
 899                         }
 900                         kfree(tmp_cmd->host_scribble);
 901                         tmp_cmd->host_scribble = NULL;
 902                         aha1542->int_cmds[i] = NULL;
 903                         aha1542->mb[i].status = 0;
 904                 }
 905         }
 906
 907         spin_unlock_irqrestore(sh->host_lock, flags);
 908         return SUCCESS;
 909 }
 910
 911 static int aha1542_bus_reset(struct scsi_cmnd *cmd)
 912 {
 913         return aha1542_reset(cmd, SCRST);
 914 }
 915
 916 static int aha1542_host_reset(struct scsi_cmnd *cmd)
 917 {
 918         return aha1542_reset(cmd, HRST | SCRST);
 919 }
 920
 921 static int aha1542_biosparam(struct scsi_device *sdev,
 922                 struct block_device *bdev, sector_t capacity, int geom[])
 923 {
 924         struct aha1542_hostdata *aha1542 = shost_priv(sdev->host);
 925
 926         if (capacity >= 0x200000 &&
 927                         aha1542->bios_translation == BIOS_TRANSLATION_25563) {
 928                 /* Please verify that this is the same as what DOS returns */
 929                 geom[0] = 255;  /* heads */
 930                 geom[1] = 63;   /* sectors */
 931         } else {
 932                 geom[0] = 64;   /* heads */
 933                 geom[1] = 32;   /* sectors */
 934         }
 935         geom[2] = sector_div(capacity, geom[0] * geom[1]);      /* cylinders */
 936
 937         return 0;
 938 }
 939 MODULE_LICENSE("GPL");
 940
 941 static struct scsi_host_template driver_template = {
 942         .module                 = THIS_MODULE,
 943         .proc_name              = "aha1542",
 944         .name                   = "Adaptec 1542",
 945         .queuecommand           = aha1542_queuecommand,
 946         .eh_device_reset_handler= aha1542_dev_reset,
 947         .eh_bus_reset_handler   = aha1542_bus_reset,
 948         .eh_host_reset_handler  = aha1542_host_reset,
 949         .bios_param             = aha1542_biosparam,
 950         .can_queue              = AHA1542_MAILBOXES,
 951         .this_id                = 7,
 952         .sg_tablesize           = 16,
 953         .unchecked_isa_dma      = 1,
 954         .use_clustering         = ENABLE_CLUSTERING,
 955 };
 956
 957 static int aha1542_isa_match(struct device *pdev, unsigned int ndev)
 958 {
 959         struct Scsi_Host *sh = aha1542_hw_init(&driver_template, pdev, ndev);
 960
 961         if (!sh)
 962                 return 0;
 963
 964         dev_set_drvdata(pdev, sh);
 965         return 1;
 966 }
 967
 968 static int aha1542_isa_remove(struct device *pdev,
 969                                     unsigned int ndev)
 970 {
 971         aha1542_release(dev_get_drvdata(pdev));
 972         dev_set_drvdata(pdev, NULL);
 973         return 0;
 974 }
 975
 976 static struct isa_driver aha1542_isa_driver = {
 977         .match          = aha1542_isa_match,
 978         .remove         = aha1542_isa_remove,
 979         .driver         = {
 980                 .name   = "aha1542"
 981         },
 982 };
 983 static int isa_registered;
 984
 985 #ifdef CONFIG_PNP
 986 static struct pnp_device_id aha1542_pnp_ids[] = {
 987         { .id = "ADP1542" },
 988         { .id = "" }
 989 };
 990 MODULE_DEVICE_TABLE(pnp, aha1542_pnp_ids);
 991
 992 static int aha1542_pnp_probe(struct pnp_dev *pdev, const struct pnp_device_id *id)
 993 {
 994         int indx;
 995         struct Scsi_Host *sh;
 996
 997         for (indx = 0; indx < ARRAY_SIZE(io); indx++) {
 998                 if (io[indx])
 999                         continue;
1000
1001                 if (pnp_activate_dev(pdev) < 0)
1002                         continue;
1003
1004                 io[indx] = pnp_port_start(pdev, 0);
1005
1006                 /* The card can be queried for its DMA, we have
1007                    the DMA set up that is enough */
1008
1009                 dev_info(&pdev->dev, "ISAPnP found an AHA1535 at I/O 0x%03X", io[indx]);
1010         }
1011
1012         sh = aha1542_hw_init(&driver_template, &pdev->dev, indx);
1013         if (!sh)
1014                 return -ENODEV;
1015
1016         pnp_set_drvdata(pdev, sh);
1017         return 0;
1018 }
1019
1020 static void aha1542_pnp_remove(struct pnp_dev *pdev)
1021 {
1022         aha1542_release(pnp_get_drvdata(pdev));
1023         pnp_set_drvdata(pdev, NULL);
1024 }
1025
1026 static struct pnp_driver aha1542_pnp_driver = {
1027         .name           = "aha1542",
1028         .id_table       = aha1542_pnp_ids,
1029         .probe          = aha1542_pnp_probe,
1030         .remove         = aha1542_pnp_remove,
1031 };
1032 static int pnp_registered;
1033 #endif /* CONFIG_PNP */
1034
1035 static int __init aha1542_init(void)
1036 {
1037         int ret = 0;
1038
1039 #ifdef CONFIG_PNP
1040         if (isapnp) {
1041                 ret = pnp_register_driver(&aha1542_pnp_driver);
1042                 if (!ret)
1043                         pnp_registered = 1;
1044         }
1045 #endif
1046         ret = isa_register_driver(&aha1542_isa_driver, MAXBOARDS);
1047         if (!ret)
1048                 isa_registered = 1;
1049
1050 #ifdef CONFIG_PNP
1051         if (pnp_registered)
1052                 ret = 0;
1053 #endif
1054         if (isa_registered)
1055                 ret = 0;
1056
1057         return ret;
1058 }
1059
1060 static void __exit aha1542_exit(void)
1061 {
1062 #ifdef CONFIG_PNP
1063         if (pnp_registered)
1064                 pnp_unregister_driver(&aha1542_pnp_driver);
1065 #endif
1066         if (isa_registered)
1067                 isa_unregister_driver(&aha1542_isa_driver);
1068 }
1069
1070 module_init(aha1542_init);
1071 module_exit(aha1542_exit);