drivers/scsi/aha1542.c

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

DEFINITIONS
