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