drivers/scsi/aha1542.c

   1 /* $Id: aha1542.c,v 1.1 1992/07/24 06:27:38 root Exp root $
   2  *  linux/kernel/aha1542.c
   3  *
   4  *  Copyright (C) 1992  Tommy Thorn
   5  *  Copyright (C) 1993, 1994, 1995 Eric Youngdale
   6  *
   7  *  Modified by Eric Youngdale
   8  *        Use request_irq and request_dma to help prevent unexpected conflicts
   9  *        Set up on-board DMA controller, such that we do not have to
  10  *        have the bios enabled to use the aha1542.
  11  *  Modified by David Gentzel
  12  *        Don't call request_dma if dma mask is 0 (for BusLogic BT-445S VL-Bus
  13  *        controller).
  14  *  Modified by Matti Aarnio
  15  *        Accept parameters from LILO cmd-line. -- 1-Oct-94
  16  *  Modified by Mike McLagan <mike.mclagan@linux.org>
  17  *        Recognise extended mode on AHA1542CP, different bit than 1542CF
  18  *        1-Jan-97
  19  *  Modified by Bjorn L. Thordarson and Einar Thor Einarsson
  20  *        Recognize that DMA0 is valid DMA channel -- 13-Jul-98
  21  *  Modified by Chris Faulhaber <jedgar@fxp.org>
  22  *        Added module command-line options
  23  *        19-Jul-99
  24  *  Modified by Adam Fritzler <mid@auk.cx>
  25  *        Added proper detection of the AHA-1640 (MCA version of AHA-1540)
  26  */
  27
  28 #include <linux/config.h>
  29 #include <linux/module.h>
  30 #include <linux/interrupt.h>
  31 #include <linux/kernel.h>
  32 #include <linux/types.h>
  33 #include <linux/string.h>
  34 #include <linux/ioport.h>
  35 #include <linux/delay.h>
  36 #include <linux/proc_fs.h>
  37 #include <linux/init.h>
  38 #include <linux/spinlock.h>
  39 #include <linux/pci.h>
  40 #include <linux/isapnp.h>
  41 #include <linux/blkdev.h>
  42 #include <linux/mca.h>
  43 #include <linux/mca-legacy.h>
  44
  45 #include <asm/dma.h>
  46 #include <asm/system.h>
  47 #include <asm/io.h>
  48
  49 #include "scsi.h"
  50 #include "hosts.h"
  51 #include "aha1542.h"
  52
  53 #define SCSI_BUF_PA(address)    isa_virt_to_bus(address)
  54 #define SCSI_SG_PA(sgent)       (isa_page_to_bus((sgent)->page) + (sgent)->offset)
  55
  56 static void BAD_DMA(void *address, unsigned int length)
  57 {
  58         printk(KERN_CRIT "buf vaddress %p paddress 0x%lx length %d\n",
  59                address,
  60                SCSI_BUF_PA(address),
  61                length);
  62         panic("Buffer at physical address > 16Mb used for aha1542");
  63 }
  64
  65 static void BAD_SG_DMA(Scsi_Cmnd * SCpnt,
  66                        struct scatterlist *sgpnt,
  67                        int nseg,
  68                        int badseg)
  69 {
  70         printk(KERN_CRIT "sgpnt[%d:%d] page %p/0x%llx length %u\n",
  71                badseg, nseg,
  72                page_address(sgpnt[badseg].page) + sgpnt[badseg].offset,
  73                (unsigned long long)SCSI_SG_PA(&sgpnt[badseg]),
  74                sgpnt[badseg].length);
  75
  76         /*
  77          * Not safe to continue.
  78          */
  79         panic("Buffer at physical address > 16Mb used for aha1542");
  80 }
  81
  82 #include<linux/stat.h>
  83
  84 #ifdef DEBUG
  85 #define DEB(x) x
  86 #else
  87 #define DEB(x)
  88 #endif
  89
  90 /*
  91    static const char RCSid[] = "$Header: /usr/src/linux/kernel/blk_drv/scsi/RCS/aha1542.c,v 1.1 1992/07/24 06:27:38 root Exp root $";
  92  */
  93
  94 /* The adaptec can be configured for quite a number of addresses, but
  95    I generally do not want the card poking around at random.  We allow
  96    two addresses - this allows people to use the Adaptec with a Midi
  97    card, which also used 0x330 -- can be overridden with LILO! */
  98
  99 #define MAXBOARDS 4             /* Increase this and the sizes of the
 100                                    arrays below, if you need more.. */
 101
 102 /* Boards 3,4 slots are reserved for ISAPnP/MCA scans */
 103
 104 static unsigned int bases[MAXBOARDS] __initdata = {0x330, 0x334, 0, 0};
 105
 106 /* set by aha1542_setup according to the command line; they also may
 107    be marked __initdata, but require zero initializers then */
 108
 109 static int setup_called[MAXBOARDS];
 110 static int setup_buson[MAXBOARDS];
 111 static int setup_busoff[MAXBOARDS];
 112 static int setup_dmaspeed[MAXBOARDS] __initdata = { -1, -1, -1, -1 };
 113
 114 /*
 115  * LILO/Module params:  aha1542=<PORTBASE>[,<BUSON>,<BUSOFF>[,<DMASPEED>]]
 116  *
 117  * Where:  <PORTBASE> is any of the valid AHA addresses:
 118  *                      0x130, 0x134, 0x230, 0x234, 0x330, 0x334
 119  *         <BUSON>  is the time (in microsecs) that AHA spends on the AT-bus
 120  *                  when transferring data.  1542A power-on default is 11us,
 121  *                  valid values are in range: 2..15 (decimal)
 122  *         <BUSOFF> is the time that AHA spends OFF THE BUS after while
 123  *                  it is transferring data (not to monopolize the bus).
 124  *                  Power-on default is 4us, valid range: 1..64 microseconds.
 125  *         <DMASPEED> Default is jumper selected (1542A: on the J1),
 126  *                  but experimenter can alter it with this.
 127  *                  Valid values: 5, 6, 7, 8, 10 (MB/s)
 128  *                  Factory default is 5 MB/s.
 129  */
 130
 131 #if defined(MODULE)
 132 int isapnp = 0;
 133 int aha1542[] = {0x330, 11, 4, -1};
 134 MODULE_PARM(aha1542, "1-4i");
 135 MODULE_PARM(isapnp, "i");
 136
 137 static struct isapnp_device_id id_table[] __initdata = {
 138         {
 139                 ISAPNP_ANY_ID, ISAPNP_ANY_ID,
 140                 ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1542),
 141                 0
 142         },
 143         {0}
 144 };
 145
 146 MODULE_DEVICE_TABLE(isapnp, id_table);
 147
 148 #else
 149 static int isapnp = 1;
 150 #endif
 151
 152 #define BIOS_TRANSLATION_1632 0 /* Used by some old 1542A boards */
 153 #define BIOS_TRANSLATION_6432 1 /* Default case these days */
 154 #define BIOS_TRANSLATION_25563 2        /* Big disk case */
 155
 156 struct aha1542_hostdata {
 157         /* This will effectively start both of them at the first mailbox */
 158         int bios_translation;   /* Mapping bios uses - for compatibility */
 159         int aha1542_last_mbi_used;
 160         int aha1542_last_mbo_used;
 161         Scsi_Cmnd *SCint[AHA1542_MAILBOXES];
 162         struct mailbox mb[2 * AHA1542_MAILBOXES];
 163         struct ccb ccb[AHA1542_MAILBOXES];
 164 };
 165
 166 #define HOSTDATA(host) ((struct aha1542_hostdata *) &host->hostdata)
 167
 168 static struct Scsi_Host *aha_host[7];   /* One for each IRQ level (9-15) */
 169
 170 static spinlock_t aha1542_lock = SPIN_LOCK_UNLOCKED;
 171
 172
 173
 174 #define WAITnexttimeout 3000000
 175
 176 static void setup_mailboxes(int base_io, struct Scsi_Host *shpnt);
 177 static int aha1542_restart(struct Scsi_Host *shost);
 178 static void aha1542_intr_handle(struct Scsi_Host *shost, void *dev_id, struct pt_regs *regs);
 179 static irqreturn_t do_aha1542_intr_handle(int irq, void *dev_id,
 180                                         struct pt_regs *regs);
 181
 182 #define aha1542_intr_reset(base)  outb(IRST, CONTROL(base))
 183
 184 #define WAIT(port, mask, allof, noneof)                                 \
 185  { register int WAITbits;                                               \
 186    register int WAITtimeout = WAITnexttimeout;                          \
 187    while (1) {                                                          \
 188      WAITbits = inb(port) & (mask);                                     \
 189      if ((WAITbits & (allof)) == (allof) && ((WAITbits & (noneof)) == 0)) \
 190        break;                                                           \
 191      if (--WAITtimeout == 0) goto fail;                                 \
 192    }                                                                    \
 193  }
 194
 195 /* Similar to WAIT, except we use the udelay call to regulate the
 196    amount of time we wait.  */
 197 #define WAITd(port, mask, allof, noneof, timeout)                       \
 198  { register int WAITbits;                                               \
 199    register int WAITtimeout = timeout;                                  \
 200    while (1) {                                                          \
 201      WAITbits = inb(port) & (mask);                                     \
 202      if ((WAITbits & (allof)) == (allof) && ((WAITbits & (noneof)) == 0)) \
 203        break;                                                           \
 204      mdelay(1);                                                 \
 205      if (--WAITtimeout == 0) goto fail;                                 \
 206    }                                                                    \
 207  }
 208
 209 static void aha1542_stat(void)
 210 {
 211 /*      int s = inb(STATUS), i = inb(INTRFLAGS);
 212         printk("status=%x intrflags=%x\n", s, i, WAITnexttimeout-WAITtimeout); */
 213 }
 214
 215 /* This is a bit complicated, but we need to make sure that an interrupt
 216    routine does not send something out while we are in the middle of this.
 217    Fortunately, it is only at boot time that multi-byte messages
 218    are ever sent. */
 219 static int aha1542_out(unsigned int base, unchar * cmdp, int len)
 220 {
 221         unsigned long flags = 0;
 222         int got_lock;
 223
 224         if (len == 1) {
 225                 got_lock = 0;
 226                 while (1 == 1) {
 227                         WAIT(STATUS(base), CDF, 0, CDF);
 228                         spin_lock_irqsave(&aha1542_lock, flags);
 229                         if (inb(STATUS(base)) & CDF) {
 230                                 spin_unlock_irqrestore(&aha1542_lock, flags);
 231                                 continue;
 232                         }
 233                         outb(*cmdp, DATA(base));
 234                         spin_unlock_irqrestore(&aha1542_lock, flags);
 235                         return 0;
 236                 }
 237         } else {
 238                 spin_lock_irqsave(&aha1542_lock, flags);
 239                 got_lock = 1;
 240                 while (len--) {
 241                         WAIT(STATUS(base), CDF, 0, CDF);
 242                         outb(*cmdp++, DATA(base));
 243                 }
 244                 spin_unlock_irqrestore(&aha1542_lock, flags);
 245         }
 246         return 0;
 247 fail:
 248         if (got_lock)
 249                 spin_unlock_irqrestore(&aha1542_lock, flags);
 250         printk(KERN_ERR "aha1542_out failed(%d): ", len + 1);
 251         aha1542_stat();
 252         return 1;
 253 }
 254
 255 /* Only used at boot time, so we do not need to worry about latency as much
 256    here */
 257
 258 static int __init aha1542_in(unsigned int base, unchar * cmdp, int len)
 259 {
 260         unsigned long flags;
 261
 262         spin_lock_irqsave(&aha1542_lock, flags);
 263         while (len--) {
 264                 WAIT(STATUS(base), DF, DF, 0);
 265                 *cmdp++ = inb(DATA(base));
 266         }
 267         spin_unlock_irqrestore(&aha1542_lock, flags);
 268         return 0;
 269 fail:
 270         spin_unlock_irqrestore(&aha1542_lock, flags);
 271         printk(KERN_ERR "aha1542_in failed(%d): ", len + 1);
 272         aha1542_stat();
 273         return 1;
 274 }
 275
 276 /* Similar to aha1542_in, except that we wait a very short period of time.
 277    We use this if we know the board is alive and awake, but we are not sure
 278    if the board will respond to the command we are about to send or not */
 279 static int __init aha1542_in1(unsigned int base, unchar * cmdp, int len)
 280 {
 281         unsigned long flags;
 282
 283         spin_lock_irqsave(&aha1542_lock, flags);
 284         while (len--) {
 285                 WAITd(STATUS(base), DF, DF, 0, 100);
 286                 *cmdp++ = inb(DATA(base));
 287         }
 288         spin_unlock_irqrestore(&aha1542_lock, flags);
 289         return 0;
 290 fail:
 291         spin_unlock_irqrestore(&aha1542_lock, flags);
 292         return 1;
 293 }
 294
 295 static int makecode(unsigned hosterr, unsigned scsierr)
 296 {
 297         switch (hosterr) {
 298         case 0x0:
 299         case 0xa:               /* Linked command complete without error and linked normally */
 300         case 0xb:               /* Linked command complete without error, interrupt generated */
 301                 hosterr = 0;
 302                 break;
 303
 304         case 0x11:              /* Selection time out-The initiator selection or target
 305                                    reselection was not complete within the SCSI Time out period */
 306                 hosterr = DID_TIME_OUT;
 307                 break;
 308
 309         case 0x12:              /* Data overrun/underrun-The target attempted to transfer more data
 310                                    than was allocated by the Data Length field or the sum of the
 311                                    Scatter / Gather Data Length fields. */
 312
 313         case 0x13:              /* Unexpected bus free-The target dropped the SCSI BSY at an unexpected time. */
 314
 315         case 0x15:              /* MBO command was not 00, 01 or 02-The first byte of the CB was
 316                                    invalid. This usually indicates a software failure. */
 317
 318         case 0x16:              /* Invalid CCB Operation Code-The first byte of the CCB was invalid.
 319                                    This usually indicates a software failure. */
 320
 321         case 0x17:              /* Linked CCB does not have the same LUN-A subsequent CCB of a set
 322                                    of linked CCB's does not specify the same logical unit number as
 323                                    the first. */
 324         case 0x18:              /* Invalid Target Direction received from Host-The direction of a
 325                                    Target Mode CCB was invalid. */
 326
 327         case 0x19:              /* Duplicate CCB Received in Target Mode-More than once CCB was
 328                                    received to service data transfer between the same target LUN
 329                                    and initiator SCSI ID in the same direction. */
 330
 331         case 0x1a:              /* Invalid CCB or Segment List Parameter-A segment list with a zero
 332                                    length segment or invalid segment list boundaries was received.
 333                                    A CCB parameter was invalid. */
 334                 DEB(printk("Aha1542: %x %x\n", hosterr, scsierr));
 335                 hosterr = DID_ERROR;    /* Couldn't find any better */
 336                 break;
 337
 338         case 0x14:              /* Target bus phase sequence failure-An invalid bus phase or bus
 339                                    phase sequence was requested by the target. The host adapter
 340                                    will generate a SCSI Reset Condition, notifying the host with
 341                                    a SCRD interrupt */
 342                 hosterr = DID_RESET;
 343                 break;
 344         default:
 345                 printk(KERN_ERR "aha1542: makecode: unknown hoststatus %x\n", hosterr);
 346                 break;
 347         }
 348         return scsierr | (hosterr << 16);
 349 }
 350
 351 static int __init aha1542_test_port(int bse, struct Scsi_Host *shpnt)
 352 {
 353         unchar inquiry_cmd[] = {CMD_INQUIRY};
 354         unchar inquiry_result[4];
 355         unchar *cmdp;
 356         int len;
 357         volatile int debug = 0;
 358
 359         /* Quick and dirty test for presence of the card. */
 360         if (inb(STATUS(bse)) == 0xff)
 361                 return 0;
 362
 363         /* Reset the adapter. I ought to make a hard reset, but it's not really necessary */
 364
 365         /*  DEB(printk("aha1542_test_port called \n")); */
 366
 367         /* In case some other card was probing here, reset interrupts */
 368         aha1542_intr_reset(bse);        /* reset interrupts, so they don't block */
 369
 370         outb(SRST | IRST /*|SCRST */ , CONTROL(bse));
 371
 372         mdelay(20);             /* Wait a little bit for things to settle down. */
 373
 374         debug = 1;
 375         /* Expect INIT and IDLE, any of the others are bad */
 376         WAIT(STATUS(bse), STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
 377
 378         debug = 2;
 379         /* Shouldn't have generated any interrupts during reset */
 380         if (inb(INTRFLAGS(bse)) & INTRMASK)
 381                 goto fail;
 382
 383
 384         /* Perform a host adapter inquiry instead so we do not need to set
 385            up the mailboxes ahead of time */
 386
 387         aha1542_out(bse, inquiry_cmd, 1);
 388
 389         debug = 3;
 390         len = 4;
 391         cmdp = &inquiry_result[0];
 392
 393         while (len--) {
 394                 WAIT(STATUS(bse), DF, DF, 0);
 395                 *cmdp++ = inb(DATA(bse));
 396         }
 397
 398         debug = 8;
 399         /* Reading port should reset DF */
 400         if (inb(STATUS(bse)) & DF)
 401                 goto fail;
 402
 403         debug = 9;
 404         /* When HACC, command is completed, and we're though testing */
 405         WAIT(INTRFLAGS(bse), HACC, HACC, 0);
 406         /* now initialize adapter */
 407
 408         debug = 10;
 409         /* Clear interrupts */
 410         outb(IRST, CONTROL(bse));
 411
 412         debug = 11;
 413
 414         return debug;           /* 1 = ok */
 415 fail:
 416         return 0;               /* 0 = not ok */
 417 }
 418
 419 /* A quick wrapper for do_aha1542_intr_handle to grab the spin lock */
 420 static irqreturn_t do_aha1542_intr_handle(int irq, void *dev_id,
 421                                         struct pt_regs *regs)
 422 {
 423         unsigned long flags;
 424         struct Scsi_Host *shost;
 425
 426         shost = aha_host[irq - 9];
 427         if (!shost)
 428                 panic("Splunge!");
 429
 430         spin_lock_irqsave(shost->host_lock, flags);
 431         aha1542_intr_handle(shost, dev_id, regs);
 432         spin_unlock_irqrestore(shost->host_lock, flags);
 433         return IRQ_HANDLED;
 434 }
 435
 436 /* A "high" level interrupt handler */
 437 static void aha1542_intr_handle(struct Scsi_Host *shost, void *dev_id, struct pt_regs *regs)
 438 {
 439         void (*my_done) (Scsi_Cmnd *) = NULL;
 440         int errstatus, mbi, mbo, mbistatus;
 441         int number_serviced;
 442         unsigned long flags;
 443         Scsi_Cmnd *SCtmp;
 444         int flag;
 445         int needs_restart;
 446         struct mailbox *mb;
 447         struct ccb *ccb;
 448
 449         mb = HOSTDATA(shost)->mb;
 450         ccb = HOSTDATA(shost)->ccb;
 451
 452 #ifdef DEBUG
 453         {
 454                 flag = inb(INTRFLAGS(shost->io_port));
 455                 printk(KERN_DEBUG "aha1542_intr_handle: ");
 456                 if (!(flag & ANYINTR))
 457                         printk("no interrupt?");
 458                 if (flag & MBIF)
 459                         printk("MBIF ");
 460                 if (flag & MBOA)
 461                         printk("MBOF ");
 462                 if (flag & HACC)
 463                         printk("HACC ");
 464                 if (flag & SCRD)
 465                         printk("SCRD ");
 466                 printk("status %02x\n", inb(STATUS(shost->io_port)));
 467         };
 468 #endif
 469         number_serviced = 0;
 470         needs_restart = 0;
 471
 472         while (1 == 1) {
 473                 flag = inb(INTRFLAGS(shost->io_port));
 474
 475                 /* Check for unusual interrupts.  If any of these happen, we should
 476                    probably do something special, but for now just printing a message
 477                    is sufficient.  A SCSI reset detected is something that we really
 478                    need to deal with in some way. */
 479                 if (flag & ~MBIF) {
 480                         if (flag & MBOA)
 481                                 printk("MBOF ");
 482                         if (flag & HACC)
 483                                 printk("HACC ");
 484                         if (flag & SCRD) {
 485                                 needs_restart = 1;
 486                                 printk("SCRD ");
 487                         }
 488                 }
 489                 aha1542_intr_reset(shost->io_port);
 490
 491                 spin_lock_irqsave(&aha1542_lock, flags);
 492                 mbi = HOSTDATA(shost)->aha1542_last_mbi_used + 1;
 493                 if (mbi >= 2 * AHA1542_MAILBOXES)
 494                         mbi = AHA1542_MAILBOXES;
 495
 496                 do {
 497                         if (mb[mbi].status != 0)
 498                                 break;
 499                         mbi++;
 500                         if (mbi >= 2 * AHA1542_MAILBOXES)
 501                                 mbi = AHA1542_MAILBOXES;
 502                 } while (mbi != HOSTDATA(shost)->aha1542_last_mbi_used);
 503
 504                 if (mb[mbi].status == 0) {
 505                         spin_unlock_irqrestore(&aha1542_lock, flags);
 506                         /* Hmm, no mail.  Must have read it the last time around */
 507                         if (!number_serviced && !needs_restart)
 508                                 printk(KERN_WARNING "aha1542.c: interrupt received, but no mail.\n");
 509                         /* We detected a reset.  Restart all pending commands for
 510                            devices that use the hard reset option */
 511                         if (needs_restart)
 512                                 aha1542_restart(shost);
 513                         return;
 514                 };
 515
 516                 mbo = (scsi2int(mb[mbi].ccbptr) - (SCSI_BUF_PA(&ccb[0]))) / sizeof(struct ccb);
 517                 mbistatus = mb[mbi].status;
 518                 mb[mbi].status = 0;
 519                 HOSTDATA(shost)->aha1542_last_mbi_used = mbi;
 520                 spin_unlock_irqrestore(&aha1542_lock, flags);
 521
 522 #ifdef DEBUG
 523                 {
 524                         if (ccb[mbo].tarstat | ccb[mbo].hastat)
 525                                 printk(KERN_DEBUG "aha1542_command: returning %x (status %d)\n",
 526                                        ccb[mbo].tarstat + ((int) ccb[mbo].hastat << 16), mb[mbi].status);
 527                 };
 528 #endif
 529
 530                 if (mbistatus == 3)
 531                         continue;       /* Aborted command not found */
 532
 533 #ifdef DEBUG
 534                 printk(KERN_DEBUG "...done %d %d\n", mbo, mbi);
 535 #endif
 536
 537                 SCtmp = HOSTDATA(shost)->SCint[mbo];
 538
 539                 if (!SCtmp || !SCtmp->scsi_done) {
 540                         printk(KERN_WARNING "aha1542_intr_handle: Unexpected interrupt\n");
 541                         printk(KERN_WARNING "tarstat=%x, hastat=%x idlun=%x ccb#=%d \n", ccb[mbo].tarstat,
 542                                ccb[mbo].hastat, ccb[mbo].idlun, mbo);
 543                         return;
 544                 }
 545                 my_done = SCtmp->scsi_done;
 546                 if (SCtmp->host_scribble) {
 547                         kfree(SCtmp->host_scribble);
 548                         SCtmp->host_scribble = 0;
 549                 }
 550                 /* Fetch the sense data, and tuck it away, in the required slot.  The
 551                    Adaptec automatically fetches it, and there is no guarantee that
 552                    we will still have it in the cdb when we come back */
 553                 if (ccb[mbo].tarstat == 2)
 554                         memcpy(SCtmp->sense_buffer, &ccb[mbo].cdb[ccb[mbo].cdblen],
 555                                sizeof(SCtmp->sense_buffer));
 556
 557
 558                 /* is there mail :-) */
 559
 560                 /* more error checking left out here */
 561                 if (mbistatus != 1)
 562                         /* This is surely wrong, but I don't know what's right */
 563                         errstatus = makecode(ccb[mbo].hastat, ccb[mbo].tarstat);
 564                 else
 565                         errstatus = 0;
 566
 567 #ifdef DEBUG
 568                 if (errstatus)
 569                         printk(KERN_DEBUG "(aha1542 error:%x %x %x) ", errstatus,
 570                                ccb[mbo].hastat, ccb[mbo].tarstat);
 571 #endif
 572
 573                 if (ccb[mbo].tarstat == 2) {
 574 #ifdef DEBUG
 575                         int i;
 576 #endif
 577                         DEB(printk("aha1542_intr_handle: sense:"));
 578 #ifdef DEBUG
 579                         for (i = 0; i < 12; i++)
 580                                 printk("%02x ", ccb[mbo].cdb[ccb[mbo].cdblen + i]);
 581                         printk("\n");
 582 #endif
 583                         /*
 584                            DEB(printk("aha1542_intr_handle: buf:"));
 585                            for (i = 0; i < bufflen; i++)
 586                            printk("%02x ", ((unchar *)buff)[i]);
 587                            printk("\n");
 588                          */
 589                 }
 590                 DEB(if (errstatus) printk("aha1542_intr_handle: returning %6x\n", errstatus));
 591                 SCtmp->result = errstatus;
 592                 HOSTDATA(shost)->SCint[mbo] = NULL;     /* This effectively frees up the mailbox slot, as
 593                                                            far as queuecommand is concerned */
 594                 my_done(SCtmp);
 595                 number_serviced++;
 596         };
 597 }
 598
 599 static int aha1542_queuecommand(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
 600 {
 601         unchar ahacmd = CMD_START_SCSI;
 602         unchar direction;
 603         unchar *cmd = (unchar *) SCpnt->cmnd;
 604         unchar target = SCpnt->device->id;
 605         unchar lun = SCpnt->device->lun;
 606         unsigned long flags;
 607         void *buff = SCpnt->request_buffer;
 608         int bufflen = SCpnt->request_bufflen;
 609         int mbo;
 610         struct mailbox *mb;
 611         struct ccb *ccb;
 612
 613         DEB(int i);
 614
 615         mb = HOSTDATA(SCpnt->device->host)->mb;
 616         ccb = HOSTDATA(SCpnt->device->host)->ccb;
 617
 618         DEB(if (target > 1) {
 619             SCpnt->result = DID_TIME_OUT << 16;
 620             done(SCpnt); return 0;
 621             }
 622         );
 623
 624         if (*cmd == REQUEST_SENSE) {
 625                 /* Don't do the command - we have the sense data already */
 626 #if 0
 627                 /* scsi_request_sense() provides a buffer of size 256,
 628                    so there is no reason to expect equality */
 629                 if (bufflen != sizeof(SCpnt->sense_buffer))
 630                         printk(KERN_CRIT "aha1542: Wrong buffer length supplied "
 631                                "for request sense (%d)\n", bufflen);
 632 #endif
 633                 SCpnt->result = 0;
 634                 done(SCpnt);
 635                 return 0;
 636         }
 637 #ifdef DEBUG
 638         if (*cmd == READ_10 || *cmd == WRITE_10)
 639                 i = xscsi2int(cmd + 2);
 640         else if (*cmd == READ_6 || *cmd == WRITE_6)
 641                 i = scsi2int(cmd + 2);
 642         else
 643                 i = -1;
 644         if (done)
 645                 printk(KERN_DEBUG "aha1542_queuecommand: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
 646         else
 647                 printk(KERN_DEBUG "aha1542_command: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
 648         aha1542_stat();
 649         printk(KERN_DEBUG "aha1542_queuecommand: dumping scsi cmd:");
 650         for (i = 0; i < SCpnt->cmd_len; i++)
 651                 printk("%02x ", cmd[i]);
 652         printk("\n");
 653         if (*cmd == WRITE_10 || *cmd == WRITE_6)
 654                 return 0;       /* we are still testing, so *don't* write */
 655 #endif
 656         /* Use the outgoing mailboxes in a round-robin fashion, because this
 657            is how the host adapter will scan for them */
 658
 659         spin_lock_irqsave(&aha1542_lock, flags);
 660         mbo = HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used + 1;
 661         if (mbo >= AHA1542_MAILBOXES)
 662                 mbo = 0;
 663
 664         do {
 665                 if (mb[mbo].status == 0 && HOSTDATA(SCpnt->device->host)->SCint[mbo] == NULL)
 666                         break;
 667                 mbo++;
 668                 if (mbo >= AHA1542_MAILBOXES)
 669                         mbo = 0;
 670         } while (mbo != HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used);
 671
 672         if (mb[mbo].status || HOSTDATA(SCpnt->device->host)->SCint[mbo])
 673                 panic("Unable to find empty mailbox for aha1542.\n");
 674
 675         HOSTDATA(SCpnt->device->host)->SCint[mbo] = SCpnt;      /* This will effectively prevent someone else from
 676                                                            screwing with this cdb. */
 677
 678         HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used = mbo;
 679         spin_unlock_irqrestore(&aha1542_lock, flags);
 680
 681 #ifdef DEBUG
 682         printk(KERN_DEBUG "Sending command (%d %x)...", mbo, done);
 683 #endif
 684
 685         any2scsi(mb[mbo].ccbptr, SCSI_BUF_PA(&ccb[mbo]));       /* This gets trashed for some reason */
 686
 687         memset(&ccb[mbo], 0, sizeof(struct ccb));
 688
 689         ccb[mbo].cdblen = SCpnt->cmd_len;
 690
 691         direction = 0;
 692         if (*cmd == READ_10 || *cmd == READ_6)
 693                 direction = 8;
 694         else if (*cmd == WRITE_10 || *cmd == WRITE_6)
 695                 direction = 16;
 696
 697         memcpy(ccb[mbo].cdb, cmd, ccb[mbo].cdblen);
 698
 699         if (SCpnt->use_sg) {
 700                 struct scatterlist *sgpnt;
 701                 struct chain *cptr;
 702 #ifdef DEBUG
 703                 unsigned char *ptr;
 704 #endif
 705                 int i;
 706                 ccb[mbo].op = 2;        /* SCSI Initiator Command  w/scatter-gather */
 707                 SCpnt->host_scribble = (unsigned char *) kmalloc(512, GFP_KERNEL | GFP_DMA);
 708                 sgpnt = (struct scatterlist *) SCpnt->request_buffer;
 709                 cptr = (struct chain *) SCpnt->host_scribble;
 710                 if (cptr == NULL) {
 711                         /* free the claimed mailbox slot */
 712                         HOSTDATA(SCpnt->device->host)->SCint[mbo] = NULL;
 713                         return SCSI_MLQUEUE_HOST_BUSY;
 714                 }
 715                 for (i = 0; i < SCpnt->use_sg; i++) {
 716                         if (sgpnt[i].length == 0 || SCpnt->use_sg > 16 ||
 717                             (((int) sgpnt[i].offset) & 1) || (sgpnt[i].length & 1)) {
 718                                 unsigned char *ptr;
 719                                 printk(KERN_CRIT "Bad segment list supplied to aha1542.c (%d, %d)\n", SCpnt->use_sg, i);
 720                                 for (i = 0; i < SCpnt->use_sg; i++) {
 721                                         printk(KERN_CRIT "%d: %p %d\n", i,
 722                                                (page_address(sgpnt[i].page) +
 723                                                 sgpnt[i].offset),
 724                                                sgpnt[i].length);
 725                                 };
 726                                 printk(KERN_CRIT "cptr %x: ", (unsigned int) cptr);
 727                                 ptr = (unsigned char *) &cptr[i];
 728                                 for (i = 0; i < 18; i++)
 729                                         printk("%02x ", ptr[i]);
 730                                 panic("Foooooooood fight!");
 731                         };
 732                         any2scsi(cptr[i].dataptr, SCSI_SG_PA(&sgpnt[i]));
 733                         if (SCSI_SG_PA(&sgpnt[i]) + sgpnt[i].length - 1 > ISA_DMA_THRESHOLD)
 734                                 BAD_SG_DMA(SCpnt, sgpnt, SCpnt->use_sg, i);
 735                         any2scsi(cptr[i].datalen, sgpnt[i].length);
 736                 };
 737                 any2scsi(ccb[mbo].datalen, SCpnt->use_sg * sizeof(struct chain));
 738                 any2scsi(ccb[mbo].dataptr, SCSI_BUF_PA(cptr));
 739 #ifdef DEBUG
 740                 printk("cptr %x: ", cptr);
 741                 ptr = (unsigned char *) cptr;
 742                 for (i = 0; i < 18; i++)
 743                         printk("%02x ", ptr[i]);
 744 #endif
 745         } else {
 746                 ccb[mbo].op = 0;        /* SCSI Initiator Command */
 747                 SCpnt->host_scribble = NULL;
 748                 any2scsi(ccb[mbo].datalen, bufflen);
 749                 if (buff && SCSI_BUF_PA(buff + bufflen - 1) > ISA_DMA_THRESHOLD)
 750                         BAD_DMA(buff, bufflen);
 751                 any2scsi(ccb[mbo].dataptr, SCSI_BUF_PA(buff));
 752         };
 753         ccb[mbo].idlun = (target & 7) << 5 | direction | (lun & 7);     /*SCSI Target Id */
 754         ccb[mbo].rsalen = 16;
 755         ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
 756         ccb[mbo].commlinkid = 0;
 757
 758 #ifdef DEBUG
 759         {
 760                 int i;
 761                 printk(KERN_DEBUG "aha1542_command: sending.. ");
 762                 for (i = 0; i < sizeof(ccb[mbo]) - 10; i++)
 763                         printk("%02x ", ((unchar *) & ccb[mbo])[i]);
 764         };
 765 #endif
 766
 767         if (done) {
 768                 DEB(printk("aha1542_queuecommand: now waiting for interrupt ");
 769                     aha1542_stat());
 770                 SCpnt->scsi_done = done;
 771                 mb[mbo].status = 1;
 772                 aha1542_out(SCpnt->device->host->io_port, &ahacmd, 1);  /* start scsi command */
 773                 DEB(aha1542_stat());
 774         } else
 775                 printk("aha1542_queuecommand: done can't be NULL\n");
 776
 777         return 0;
 778 }
 779
 780 /* Initialize mailboxes */
 781 static void setup_mailboxes(int bse, struct Scsi_Host *shpnt)
 782 {
 783         int i;
 784         struct mailbox *mb;
 785         struct ccb *ccb;
 786
 787         unchar cmd[5] = { CMD_MBINIT, AHA1542_MAILBOXES, 0, 0, 0};
 788
 789         mb = HOSTDATA(shpnt)->mb;
 790         ccb = HOSTDATA(shpnt)->ccb;
 791
 792         for (i = 0; i < AHA1542_MAILBOXES; i++) {
 793                 mb[i].status = mb[AHA1542_MAILBOXES + i].status = 0;
 794                 any2scsi(mb[i].ccbptr, SCSI_BUF_PA(&ccb[i]));
 795         };
 796         aha1542_intr_reset(bse);        /* reset interrupts, so they don't block */
 797         any2scsi((cmd + 2), SCSI_BUF_PA(mb));
 798         aha1542_out(bse, cmd, 5);
 799         WAIT(INTRFLAGS(bse), INTRMASK, HACC, 0);
 800         while (0) {
 801 fail:
 802                 printk(KERN_ERR "aha1542_detect: failed setting up mailboxes\n");
 803         }
 804         aha1542_intr_reset(bse);
 805 }
 806
 807 static int __init aha1542_getconfig(int base_io, unsigned char *irq_level, unsigned char *dma_chan, unsigned char *scsi_id)
 808 {
 809         unchar inquiry_cmd[] = {CMD_RETCONF};
 810         unchar inquiry_result[3];
 811         int i;
 812         i = inb(STATUS(base_io));
 813         if (i & DF) {
 814                 i = inb(DATA(base_io));
 815         };
 816         aha1542_out(base_io, inquiry_cmd, 1);
 817         aha1542_in(base_io, inquiry_result, 3);
 818         WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
 819         while (0) {
 820 fail:
 821                 printk(KERN_ERR "aha1542_detect: query board settings\n");
 822         }
 823         aha1542_intr_reset(base_io);
 824         switch (inquiry_result[0]) {
 825         case 0x80:
 826                 *dma_chan = 7;
 827                 break;
 828         case 0x40:
 829                 *dma_chan = 6;
 830                 break;
 831         case 0x20:
 832                 *dma_chan = 5;
 833                 break;
 834         case 0x01:
 835                 *dma_chan = 0;
 836                 break;
 837         case 0:
 838                 /* This means that the adapter, although Adaptec 1542 compatible, doesn't use a DMA channel.
 839                    Currently only aware of the BusLogic BT-445S VL-Bus adapter which needs this. */
 840                 *dma_chan = 0xFF;
 841                 break;
 842         default:
 843                 printk(KERN_ERR "Unable to determine Adaptec DMA priority.  Disabling board\n");
 844                 return -1;
 845         };
 846         switch (inquiry_result[1]) {
 847         case 0x40:
 848                 *irq_level = 15;
 849                 break;
 850         case 0x20:
 851                 *irq_level = 14;
 852                 break;
 853         case 0x8:
 854                 *irq_level = 12;
 855                 break;
 856         case 0x4:
 857                 *irq_level = 11;
 858                 break;
 859         case 0x2:
 860                 *irq_level = 10;
 861                 break;
 862         case 0x1:
 863                 *irq_level = 9;
 864                 break;
 865         default:
 866                 printk(KERN_ERR "Unable to determine Adaptec IRQ level.  Disabling board\n");
 867                 return -1;
 868         };
 869         *scsi_id = inquiry_result[2] & 7;
 870         return 0;
 871 }
 872
 873 /* This function should only be called for 1542C boards - we can detect
 874    the special firmware settings and unlock the board */
 875
 876 static int __init aha1542_mbenable(int base)
 877 {
 878         static unchar mbenable_cmd[3];
 879         static unchar mbenable_result[2];
 880         int retval;
 881
 882         retval = BIOS_TRANSLATION_6432;
 883
 884         mbenable_cmd[0] = CMD_EXTBIOS;
 885         aha1542_out(base, mbenable_cmd, 1);
 886         if (aha1542_in1(base, mbenable_result, 2))
 887                 return retval;
 888         WAITd(INTRFLAGS(base), INTRMASK, HACC, 0, 100);
 889         aha1542_intr_reset(base);
 890
 891         if ((mbenable_result[0] & 0x08) || mbenable_result[1]) {
 892                 mbenable_cmd[0] = CMD_MBENABLE;
 893                 mbenable_cmd[1] = 0;
 894                 mbenable_cmd[2] = mbenable_result[1];
 895
 896                 if ((mbenable_result[0] & 0x08) && (mbenable_result[1] & 0x03))
 897                         retval = BIOS_TRANSLATION_25563;
 898
 899                 aha1542_out(base, mbenable_cmd, 3);
 900                 WAIT(INTRFLAGS(base), INTRMASK, HACC, 0);
 901         };
 902         while (0) {
 903 fail:
 904                 printk(KERN_ERR "aha1542_mbenable: Mailbox init failed\n");
 905         }
 906         aha1542_intr_reset(base);
 907         return retval;
 908 }
 909
 910 /* Query the board to find out if it is a 1542 or a 1740, or whatever. */
 911 static int __init aha1542_query(int base_io, int *transl)
 912 {
 913         unchar inquiry_cmd[] = {CMD_INQUIRY};
 914         unchar inquiry_result[4];
 915         int i;
 916         i = inb(STATUS(base_io));
 917         if (i & DF) {
 918                 i = inb(DATA(base_io));
 919         };
 920         aha1542_out(base_io, inquiry_cmd, 1);
 921         aha1542_in(base_io, inquiry_result, 4);
 922         WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
 923         while (0) {
 924 fail:
 925                 printk(KERN_ERR "aha1542_detect: query card type\n");
 926         }
 927         aha1542_intr_reset(base_io);
 928
 929         *transl = BIOS_TRANSLATION_6432;        /* Default case */
 930
 931         /* For an AHA1740 series board, we ignore the board since there is a
 932            hardware bug which can lead to wrong blocks being returned if the board
 933            is operating in the 1542 emulation mode.  Since there is an extended mode
 934            driver, we simply ignore the board and let the 1740 driver pick it up.
 935          */
 936
 937         if (inquiry_result[0] == 0x43) {
 938                 printk(KERN_INFO "aha1542.c: Emulation mode not supported for AHA 174N hardware.\n");
 939                 return 1;
 940         };
 941
 942         /* Always call this - boards that do not support extended bios translation
 943            will ignore the command, and we will set the proper default */
 944
 945         *transl = aha1542_mbenable(base_io);
 946
 947         return 0;
 948 }
 949
 950 #ifndef MODULE
 951 static char *setup_str[MAXBOARDS] __initdata;
 952 static int setup_idx = 0;
 953
 954 void __init aha1542_setup(char *str, int *ints)
 955 {
 956         const char *ahausage = "aha1542: usage: aha1542=<PORTBASE>[,<BUSON>,<BUSOFF>[,<DMASPEED>]]\n";
 957         int setup_portbase;
 958
 959         if (setup_idx >= MAXBOARDS) {
 960                 printk(KERN_ERR "aha1542: aha1542_setup called too many times! Bad LILO params ?\n");
 961                 printk(KERN_ERR "   Entryline 1: %s\n", setup_str[0]);
 962                 printk(KERN_ERR "   Entryline 2: %s\n", setup_str[1]);
 963                 printk(KERN_ERR "   This line:   %s\n", str);
 964                 return;
 965         }
 966         if (ints[0] < 1 || ints[0] > 4) {
 967                 printk(KERN_ERR "aha1542: %s\n", str);
 968                 printk(ahausage);
 969                 printk(KERN_ERR "aha1542: Wrong parameters may cause system malfunction.. We try anyway..\n");
 970         }
 971         setup_called[setup_idx] = ints[0];
 972         setup_str[setup_idx] = str;
 973
 974         setup_portbase = ints[0] >= 1 ? ints[1] : 0;    /* Preserve the default value.. */
 975         setup_buson[setup_idx] = ints[0] >= 2 ? ints[2] : 7;
 976         setup_busoff[setup_idx] = ints[0] >= 3 ? ints[3] : 5;
 977         if (ints[0] >= 4)
 978         {
 979                 int atbt = -1;
 980                 switch (ints[4]) {
 981                 case 5:
 982                         atbt = 0x00;
 983                         break;
 984                 case 6:
 985                         atbt = 0x04;
 986                         break;
 987                 case 7:
 988                         atbt = 0x01;
 989                         break;
 990                 case 8:
 991                         atbt = 0x02;
 992                         break;
 993                 case 10:
 994                         atbt = 0x03;
 995                         break;
 996                 default:
 997                         printk(KERN_ERR "aha1542: %s\n", str);
 998                         printk(ahausage);
 999                         printk(KERN_ERR "aha1542: Valid values for DMASPEED are 5-8, 10 MB/s.  Using jumper defaults.\n");
1000                         break;
1001                 }
1002                 setup_dmaspeed[setup_idx] = atbt;
1003         }
1004         if (setup_portbase != 0)
1005                 bases[setup_idx] = setup_portbase;
1006
1007         ++setup_idx;
1008 }
1009
1010 static int __init do_setup(char *str)
1011 {
1012         int ints[5];
1013
1014         int count=setup_idx;
1015
1016         get_options(str, sizeof(ints)/sizeof(int), ints);
1017         aha1542_setup(str,ints);
1018
1019         return count<setup_idx;
1020 }
1021
1022 __setup("aha1542=",do_setup);
1023 #endif
1024
1025 /* return non-zero on detection */
1026 static int __init aha1542_detect(Scsi_Host_Template * tpnt)
1027 {
1028         unsigned char dma_chan;
1029         unsigned char irq_level;
1030         unsigned char scsi_id;
1031         unsigned long flags;
1032         unsigned int base_io;
1033         int trans;
1034         struct Scsi_Host *shpnt = NULL;
1035         int count = 0;
1036         int indx;
1037
1038         DEB(printk("aha1542_detect: \n"));
1039
1040         tpnt->proc_name = "aha1542";
1041
1042 #ifdef MODULE
1043         bases[0] = aha1542[0];
1044         setup_buson[0] = aha1542[1];
1045         setup_busoff[0] = aha1542[2];
1046         {
1047                 int atbt = -1;
1048                 switch (aha1542[3]) {
1049                 case 5:
1050                         atbt = 0x00;
1051                         break;
1052                 case 6:
1053                         atbt = 0x04;
1054                         break;
1055                 case 7:
1056                         atbt = 0x01;
1057                         break;
1058                 case 8:
1059                         atbt = 0x02;
1060                         break;
1061                 case 10:
1062                         atbt = 0x03;
1063                         break;
1064                 };
1065                 setup_dmaspeed[0] = atbt;
1066         }
1067 #endif
1068
1069         /*
1070          *      Find MicroChannel cards (AHA1640)
1071          */
1072 #ifdef CONFIG_MCA
1073         if(MCA_bus) {
1074                 int slot = 0;
1075                 int pos = 0;
1076
1077                 for (indx = 0; (slot !=  MCA_NOTFOUND) &&
1078                              (indx < sizeof(bases)/sizeof(bases[0])); indx++) {
1079
1080                         if (bases[indx])
1081                                 continue;
1082
1083                         /* Detect only AHA-1640 cards -- MCA ID 0F1F */
1084                         slot = mca_find_unused_adapter(0x0f1f, slot);
1085                         if (slot == MCA_NOTFOUND)
1086                                 break;
1087
1088
1089                         /* Found one */
1090                         pos = mca_read_stored_pos(slot, 3);
1091
1092                         /* Decode address */
1093                         if (pos & 0x80) {
1094                                 if (pos & 0x02) {
1095                                         if (pos & 0x01)
1096                                                 bases[indx] = 0x334;
1097                                         else
1098                                                 bases[indx] = 0x234;
1099                                 } else {
1100                                         if (pos & 0x01)
1101                                                 bases[indx] = 0x134;
1102                                 }
1103                         } else {
1104                                 if (pos & 0x02) {
1105                                         if (pos & 0x01)
1106                                                 bases[indx] = 0x330;
1107                                         else
1108                                                 bases[indx] = 0x230;
1109                                 } else {
1110                                         if (pos & 0x01)
1111                                                 bases[indx] = 0x130;
1112                                 }
1113                         }
1114
1115                         /* No need to decode IRQ and Arb level -- those are
1116                          * read off the card later.
1117                          */
1118                         printk(KERN_INFO "Found an AHA-1640 in MCA slot %d, I/O 0x%04x\n", slot, bases[indx]);
1119
1120                         mca_set_adapter_name(slot, "Adapter AHA-1640");
1121                         mca_set_adapter_procfn(slot, NULL, NULL);
1122                         mca_mark_as_used(slot);
1123
1124                         /* Go on */
1125                         slot++;
1126                 }
1127
1128         }
1129 #endif
1130
1131         /*
1132          *      Hunt for ISA Plug'n'Pray Adaptecs (AHA1535)
1133          */
1134
1135         if(isapnp)
1136         {
1137                 struct pnp_dev *pdev = NULL;
1138                 for(indx = 0; indx <sizeof(bases)/sizeof(bases[0]);indx++)
1139                 {
1140                         if(bases[indx])
1141                                 continue;
1142                         pdev = pnp_find_dev(NULL, ISAPNP_VENDOR('A', 'D', 'P'),
1143                                 ISAPNP_FUNCTION(0x1542), pdev);
1144                         if(pdev==NULL)
1145                                 break;
1146                         /*
1147                          *      Activate the PnP card
1148                          */
1149
1150                         if(pnp_device_attach(pdev)<0)
1151                                 continue;
1152
1153                         if(pnp_activate_dev(pdev)<0) {
1154                                 pnp_device_detach(pdev);
1155                                 continue;
1156                         }
1157
1158                         if(!pnp_port_valid(pdev, 0)) {
1159                                 pnp_device_detach(pdev);
1160                                 continue;
1161                         }
1162
1163                         bases[indx] = pnp_port_start(pdev, 0);
1164
1165                         /* The card can be queried for its DMA, we have
1166                            the DMA set up that is enough */
1167
1168                         printk(KERN_INFO "ISAPnP found an AHA1535 at I/O 0x%03X\n", bases[indx]);
1169                 }
1170         }
1171         for (indx = 0; indx < sizeof(bases) / sizeof(bases[0]); indx++)
1172                 if (bases[indx] != 0 && request_region(bases[indx], 4, "aha1542")) {
1173                         shpnt = scsi_register(tpnt,
1174                                         sizeof(struct aha1542_hostdata));
1175
1176                         if(shpnt==NULL) {
1177                                 release_region(bases[indx], 4);
1178                                 continue;
1179                         }
1180                         /* For now we do this - until kmalloc is more intelligent
1181                            we are resigned to stupid hacks like this */
1182                         if (SCSI_BUF_PA(shpnt) >= ISA_DMA_THRESHOLD) {
1183                                 printk(KERN_ERR "Invalid address for shpnt with 1542.\n");
1184                                 goto unregister;
1185                         }
1186                         if (!aha1542_test_port(bases[indx], shpnt))
1187                                 goto unregister;
1188
1189
1190                         base_io = bases[indx];
1191
1192                         /* Set the Bus on/off-times as not to ruin floppy performance */
1193                         {
1194                                 unchar oncmd[] = {CMD_BUSON_TIME, 7};
1195                                 unchar offcmd[] = {CMD_BUSOFF_TIME, 5};
1196
1197                                 if (setup_called[indx]) {
1198                                         oncmd[1] = setup_buson[indx];
1199                                         offcmd[1] = setup_busoff[indx];
1200                                 }
1201                                 aha1542_intr_reset(base_io);
1202                                 aha1542_out(base_io, oncmd, 2);
1203                                 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
1204                                 aha1542_intr_reset(base_io);
1205                                 aha1542_out(base_io, offcmd, 2);
1206                                 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
1207                                 if (setup_dmaspeed[indx] >= 0) {
1208                                         unchar dmacmd[] = {CMD_DMASPEED, 0};
1209                                         dmacmd[1] = setup_dmaspeed[indx];
1210                                         aha1542_intr_reset(base_io);
1211                                         aha1542_out(base_io, dmacmd, 2);
1212                                         WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
1213                                 }
1214                                 while (0) {
1215 fail:
1216                                         printk(KERN_ERR "aha1542_detect: setting bus on/off-time failed\n");
1217                                 }
1218                                 aha1542_intr_reset(base_io);
1219                         }
1220                         if (aha1542_query(base_io, &trans))
1221                                 goto unregister;
1222
1223                         if (aha1542_getconfig(base_io, &irq_level, &dma_chan, &scsi_id) == -1)
1224                                 goto unregister;
1225
1226                         printk(KERN_INFO "Configuring Adaptec (SCSI-ID %d) at IO:%x, IRQ %d", scsi_id, base_io, irq_level);
1227                         if (dma_chan != 0xFF)
1228                                 printk(", DMA priority %d", dma_chan);
1229                         printk("\n");
1230
1231                         DEB(aha1542_stat());
1232                         setup_mailboxes(base_io, shpnt);
1233
1234                         DEB(aha1542_stat());
1235
1236                         DEB(printk("aha1542_detect: enable interrupt channel %d\n", irq_level));
1237                         spin_lock_irqsave(&aha1542_lock, flags);
1238                         if (request_irq(irq_level, do_aha1542_intr_handle, 0, "aha1542", NULL)) {
1239                                 printk(KERN_ERR "Unable to allocate IRQ for adaptec controller.\n");
1240                                 spin_unlock_irqrestore(&aha1542_lock, flags);
1241                                 goto unregister;
1242                         }
1243                         if (dma_chan != 0xFF) {
1244                                 if (request_dma(dma_chan, "aha1542")) {
1245                                         printk(KERN_ERR "Unable to allocate DMA channel for Adaptec.\n");
1246                                         free_irq(irq_level, NULL);
1247                                         spin_unlock_irqrestore(&aha1542_lock, flags);
1248                                         goto unregister;
1249                                 }
1250                                 if (dma_chan == 0 || dma_chan >= 5) {
1251                                         set_dma_mode(dma_chan, DMA_MODE_CASCADE);
1252                                         enable_dma(dma_chan);
1253                                 }
1254                         }
1255                         aha_host[irq_level - 9] = shpnt;
1256                         shpnt->this_id = scsi_id;
1257                         shpnt->unique_id = base_io;
1258                         shpnt->io_port = base_io;
1259                         shpnt->n_io_port = 4;   /* Number of bytes of I/O space used */
1260                         shpnt->dma_channel = dma_chan;
1261                         shpnt->irq = irq_level;
1262                         HOSTDATA(shpnt)->bios_translation = trans;
1263                         if (trans == BIOS_TRANSLATION_25563)
1264                                 printk(KERN_INFO "aha1542.c: Using extended bios translation\n");
1265                         HOSTDATA(shpnt)->aha1542_last_mbi_used = (2 * AHA1542_MAILBOXES - 1);
1266                         HOSTDATA(shpnt)->aha1542_last_mbo_used = (AHA1542_MAILBOXES - 1);
1267                         memset(HOSTDATA(shpnt)->SCint, 0, sizeof(HOSTDATA(shpnt)->SCint));
1268                         spin_unlock_irqrestore(&aha1542_lock, flags);
1269 #if 0
1270                         DEB(printk(" *** READ CAPACITY ***\n"));
1271
1272                         {
1273                                 unchar buf[8];
1274                                 static unchar cmd[] = { READ_CAPACITY, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
1275                                 int i;
1276
1277                                 for (i = 0; i < sizeof(buf); ++i)
1278                                         buf[i] = 0x87;
1279                                 for (i = 0; i < 2; ++i)
1280                                         if (!aha1542_command(i, cmd, buf, sizeof(buf))) {
1281                                                 printk(KERN_DEBUG "aha_detect: LU %d sector_size %d device_size %d\n",
1282                                                        i, xscsi2int(buf + 4), xscsi2int(buf));
1283                                         }
1284                         }
1285
1286                         DEB(printk(" *** NOW RUNNING MY OWN TEST *** \n"));
1287
1288                         for (i = 0; i < 4; ++i) {
1289                                 unsigned char cmd[10];
1290                                 static buffer[512];
1291
1292                                 cmd[0] = READ_10;
1293                                 cmd[1] = 0;
1294                                 xany2scsi(cmd + 2, i);
1295                                 cmd[6] = 0;
1296                                 cmd[7] = 0;
1297                                 cmd[8] = 1;
1298                                 cmd[9] = 0;
1299                                 aha1542_command(0, cmd, buffer, 512);
1300                         }
1301 #endif
1302                         count++;
1303                         continue;
1304 unregister:
1305                         release_region(bases[indx], 4);
1306                         scsi_unregister(shpnt);
1307                         continue;
1308
1309                 };
1310
1311         return count;
1312 }
1313
1314 static int aha1542_release(struct Scsi_Host *shost)
1315 {
1316         if (shost->irq)
1317                 free_irq(shost->irq, NULL);
1318         if (shost->dma_channel != 0xff)
1319                 free_dma(shost->dma_channel);
1320         if (shost->io_port && shost->n_io_port)
1321                 release_region(shost->io_port, shost->n_io_port);
1322         scsi_unregister(shost);
1323         return 0;
1324 }
1325
1326 static int aha1542_restart(struct Scsi_Host *shost)
1327 {
1328         int i;
1329         int count = 0;
1330 #if 0
1331         unchar ahacmd = CMD_START_SCSI;
1332 #endif
1333
1334         for (i = 0; i < AHA1542_MAILBOXES; i++)
1335                 if (HOSTDATA(shost)->SCint[i] &&
1336                     !(HOSTDATA(shost)->SCint[i]->device->soft_reset)) {
1337 #if 0
1338                         HOSTDATA(shost)->mb[i].status = 1;      /* Indicate ready to restart... */
1339 #endif
1340                         count++;
1341                 }
1342         printk(KERN_DEBUG "Potential to restart %d stalled commands...\n", count);
1343 #if 0
1344         /* start scsi command */
1345         if (count)
1346                 aha1542_out(shost->io_port, &ahacmd, 1);
1347 #endif
1348         return 0;
1349 }
1350
1351 static int aha1542_abort(Scsi_Cmnd * SCpnt)
1352 {
1353
1354         /*
1355          * The abort command does not leave the device in a clean state where
1356          *  it is available to be used again.  Until this gets worked out, we
1357          * will leave it commented out.
1358          */
1359
1360         printk(KERN_ERR "aha1542.c: Unable to abort command for target %d\n",
1361                SCpnt->device->id);
1362         return FAILED;
1363 }
1364
1365 /*
1366  * This is a device reset.  This is handled by sending a special command
1367  * to the device.
1368  */
1369 static int aha1542_dev_reset(Scsi_Cmnd * SCpnt)
1370 {
1371         unsigned long flags;
1372         struct mailbox *mb;
1373         unchar target = SCpnt->device->id;
1374         unchar lun = SCpnt->device->lun;
1375         int mbo;
1376         struct ccb *ccb;
1377         unchar ahacmd = CMD_START_SCSI;
1378
1379         ccb = HOSTDATA(SCpnt->device->host)->ccb;
1380         mb = HOSTDATA(SCpnt->device->host)->mb;
1381
1382         spin_lock_irqsave(&aha1542_lock, flags);
1383         mbo = HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used + 1;
1384         if (mbo >= AHA1542_MAILBOXES)
1385                 mbo = 0;
1386
1387         do {
1388                 if (mb[mbo].status == 0 && HOSTDATA(SCpnt->device->host)->SCint[mbo] == NULL)
1389                         break;
1390                 mbo++;
1391                 if (mbo >= AHA1542_MAILBOXES)
1392                         mbo = 0;
1393         } while (mbo != HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used);
1394
1395         if (mb[mbo].status || HOSTDATA(SCpnt->device->host)->SCint[mbo])
1396                 panic("Unable to find empty mailbox for aha1542.\n");
1397
1398         HOSTDATA(SCpnt->device->host)->SCint[mbo] = SCpnt;      /* This will effectively
1399                                                            prevent someone else from
1400                                                            screwing with this cdb. */
1401
1402         HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used = mbo;
1403         spin_unlock_irqrestore(&aha1542_lock, flags);
1404
1405         any2scsi(mb[mbo].ccbptr, SCSI_BUF_PA(&ccb[mbo]));       /* This gets trashed for some reason */
1406
1407         memset(&ccb[mbo], 0, sizeof(struct ccb));
1408
1409         ccb[mbo].op = 0x81;     /* BUS DEVICE RESET */
1410
1411         ccb[mbo].idlun = (target & 7) << 5 | (lun & 7);         /*SCSI Target Id */
1412
1413         ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
1414         ccb[mbo].commlinkid = 0;
1415
1416         /*
1417          * Now tell the 1542 to flush all pending commands for this
1418          * target
1419          */
1420         aha1542_out(SCpnt->device->host->io_port, &ahacmd, 1);
1421
1422         printk(KERN_WARNING "aha1542.c: Trying device reset for target %d\n", SCpnt->device->id);
1423
1424         return SUCCESS;
1425
1426
1427 #ifdef ERIC_neverdef
1428         /*
1429          * With the 1542 we apparently never get an interrupt to
1430          * acknowledge a device reset being sent.  Then again, Leonard
1431          * says we are doing this wrong in the first place...
1432          *
1433          * Take a wait and see attitude.  If we get spurious interrupts,
1434          * then the device reset is doing something sane and useful, and
1435          * we will wait for the interrupt to post completion.
1436          */
1437         printk(KERN_WARNING "Sent BUS DEVICE RESET to target %d\n", SCpnt->target);
1438
1439         /*
1440          * Free the command block for all commands running on this
1441          * target...
1442          */
1443         for (i = 0; i < AHA1542_MAILBOXES; i++) {
1444                 if (HOSTDATA(SCpnt->host)->SCint[i] &&
1445                     HOSTDATA(SCpnt->host)->SCint[i]->target == SCpnt->target) {
1446                         Scsi_Cmnd *SCtmp;
1447                         SCtmp = HOSTDATA(SCpnt->host)->SCint[i];
1448                         if (SCtmp->host_scribble) {
1449                                 kfree(SCtmp->host_scribble);
1450                                 SCtmp->host_scribble = NULL;
1451                         }
1452                         HOSTDATA(SCpnt->host)->SCint[i] = NULL;
1453                         HOSTDATA(SCpnt->host)->mb[i].status = 0;
1454                 }
1455         }
1456         return SUCCESS;
1457
1458         return FAILED;
1459 #endif                          /* ERIC_neverdef */
1460 }
1461
1462 static int aha1542_bus_reset(Scsi_Cmnd * SCpnt)
1463 {
1464         int i;
1465
1466         /*
1467          * This does a scsi reset for all devices on the bus.
1468          * In principle, we could also reset the 1542 - should
1469          * we do this?  Try this first, and we can add that later
1470          * if it turns out to be useful.
1471          */
1472         outb(SCRST, CONTROL(SCpnt->device->host->io_port));
1473
1474         /*
1475          * Wait for the thing to settle down a bit.  Unfortunately
1476          * this is going to basically lock up the machine while we
1477          * wait for this to complete.  To be 100% correct, we need to
1478          * check for timeout, and if we are doing something like this
1479          * we are pretty desperate anyways.
1480          */
1481         spin_unlock_irq(SCpnt->device->host->host_lock);
1482         scsi_sleep(4 * HZ);
1483         spin_lock_irq(SCpnt->device->host->host_lock);
1484
1485         WAIT(STATUS(SCpnt->device->host->io_port),
1486              STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
1487
1488         /*
1489          * Now try to pick up the pieces.  For all pending commands,
1490          * free any internal data structures, and basically clear things
1491          * out.  We do not try and restart any commands or anything -
1492          * the strategy handler takes care of that crap.
1493          */
1494         printk(KERN_WARNING "Sent BUS RESET to scsi host %d\n", SCpnt->device->host->host_no);
1495
1496         for (i = 0; i < AHA1542_MAILBOXES; i++) {
1497                 if (HOSTDATA(SCpnt->device->host)->SCint[i] != NULL) {
1498                         Scsi_Cmnd *SCtmp;
1499                         SCtmp = HOSTDATA(SCpnt->device->host)->SCint[i];
1500
1501
1502                         if (SCtmp->device->soft_reset) {
1503                                 /*
1504                                  * If this device implements the soft reset option,
1505                                  * then it is still holding onto the command, and
1506                                  * may yet complete it.  In this case, we don't
1507                                  * flush the data.
1508                                  */
1509                                 continue;
1510                         }
1511                         if (SCtmp->host_scribble) {
1512                                 kfree(SCtmp->host_scribble);
1513                                 SCtmp->host_scribble = NULL;
1514                         }
1515                         HOSTDATA(SCpnt->device->host)->SCint[i] = NULL;
1516                         HOSTDATA(SCpnt->device->host)->mb[i].status = 0;
1517                 }
1518         }
1519
1520         return SUCCESS;
1521
1522 fail:
1523         return FAILED;
1524 }
1525
1526 static int aha1542_host_reset(Scsi_Cmnd * SCpnt)
1527 {
1528         int i;
1529
1530         /*
1531          * This does a scsi reset for all devices on the bus.
1532          * In principle, we could also reset the 1542 - should
1533          * we do this?  Try this first, and we can add that later
1534          * if it turns out to be useful.
1535          */
1536         outb(HRST | SCRST, CONTROL(SCpnt->device->host->io_port));
1537
1538         /*
1539          * Wait for the thing to settle down a bit.  Unfortunately
1540          * this is going to basically lock up the machine while we
1541          * wait for this to complete.  To be 100% correct, we need to
1542          * check for timeout, and if we are doing something like this
1543          * we are pretty desperate anyways.
1544          */
1545         spin_unlock_irq(SCpnt->device->host->host_lock);
1546         scsi_sleep(4 * HZ);
1547         spin_lock_irq(SCpnt->device->host->host_lock);
1548
1549         WAIT(STATUS(SCpnt->device->host->io_port),
1550              STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
1551
1552         /*
1553          * We need to do this too before the 1542 can interact with
1554          * us again.
1555          */
1556         setup_mailboxes(SCpnt->device->host->io_port, SCpnt->device->host);
1557
1558         /*
1559          * Now try to pick up the pieces.  For all pending commands,
1560          * free any internal data structures, and basically clear things
1561          * out.  We do not try and restart any commands or anything -
1562          * the strategy handler takes care of that crap.
1563          */
1564         printk(KERN_WARNING "Sent BUS RESET to scsi host %d\n", SCpnt->device->host->host_no);
1565
1566         for (i = 0; i < AHA1542_MAILBOXES; i++) {
1567                 if (HOSTDATA(SCpnt->device->host)->SCint[i] != NULL) {
1568                         Scsi_Cmnd *SCtmp;
1569                         SCtmp = HOSTDATA(SCpnt->device->host)->SCint[i];
1570
1571                         if (SCtmp->device->soft_reset) {
1572                                 /*
1573                                  * If this device implements the soft reset option,
1574                                  * then it is still holding onto the command, and
1575                                  * may yet complete it.  In this case, we don't
1576                                  * flush the data.
1577                                  */
1578                                 continue;
1579                         }
1580                         if (SCtmp->host_scribble) {
1581                                 kfree(SCtmp->host_scribble);
1582                                 SCtmp->host_scribble = NULL;
1583                         }
1584                         HOSTDATA(SCpnt->device->host)->SCint[i] = NULL;
1585                         HOSTDATA(SCpnt->device->host)->mb[i].status = 0;
1586                 }
1587         }
1588
1589         return SUCCESS;
1590
1591 fail:
1592         return FAILED;
1593 }
1594
1595 #if 0
1596 /*
1597  * These are the old error handling routines.  They are only temporarily
1598  * here while we play with the new error handling code.
1599  */
1600 static int aha1542_old_abort(Scsi_Cmnd * SCpnt)
1601 {
1602 #if 0
1603         unchar ahacmd = CMD_START_SCSI;
1604         unsigned long flags;
1605         struct mailbox *mb;
1606         int mbi, mbo, i;
1607
1608         printk(KERN_DEBUG "In aha1542_abort: %x %x\n",
1609                inb(STATUS(SCpnt->host->io_port)),
1610                inb(INTRFLAGS(SCpnt->host->io_port)));
1611
1612         spin_lock_irqsave(&aha1542_lock, flags);
1613         mb = HOSTDATA(SCpnt->host)->mb;
1614         mbi = HOSTDATA(SCpnt->host)->aha1542_last_mbi_used + 1;
1615         if (mbi >= 2 * AHA1542_MAILBOXES)
1616                 mbi = AHA1542_MAILBOXES;
1617
1618         do {
1619                 if (mb[mbi].status != 0)
1620                         break;
1621                 mbi++;
1622                 if (mbi >= 2 * AHA1542_MAILBOXES)
1623                         mbi = AHA1542_MAILBOXES;
1624         } while (mbi != HOSTDATA(SCpnt->host)->aha1542_last_mbi_used);
1625         spin_unlock_irqrestore(&aha1542_lock, flags);
1626
1627         if (mb[mbi].status) {
1628                 printk(KERN_ERR "Lost interrupt discovered on irq %d - attempting to recover\n",
1629                        SCpnt->host->irq);
1630                 aha1542_intr_handle(SCpnt->host, NULL);
1631                 return 0;
1632         }
1633         /* OK, no lost interrupt.  Try looking to see how many pending commands
1634            we think we have. */
1635
1636         for (i = 0; i < AHA1542_MAILBOXES; i++)
1637                 if (HOSTDATA(SCpnt->host)->SCint[i]) {
1638                         if (HOSTDATA(SCpnt->host)->SCint[i] == SCpnt) {
1639                                 printk(KERN_ERR "Timed out command pending for %s\n",
1640                                        SCpnt->request->rq_disk ?
1641                                        SCpnt->request->rq_disk->disk_name : "?"
1642                                        );
1643                                 if (HOSTDATA(SCpnt->host)->mb[i].status) {
1644                                         printk(KERN_ERR "OGMB still full - restarting\n");
1645                                         aha1542_out(SCpnt->host->io_port, &ahacmd, 1);
1646                                 };
1647                         } else
1648                                 printk(KERN_ERR "Other pending command %s\n",
1649                                        SCpnt->request->rq_disk ?
1650                                        SCpnt->request->rq_disk->disk_name : "?"
1651                                        );
1652                 }
1653 #endif
1654
1655         DEB(printk("aha1542_abort\n"));
1656 #if 0
1657         spin_lock_irqsave(&aha1542_lock, flags);
1658         for (mbo = 0; mbo < AHA1542_MAILBOXES; mbo++) {
1659                 if (SCpnt == HOSTDATA(SCpnt->host)->SCint[mbo]) {
1660                         mb[mbo].status = 2;     /* Abort command */
1661                         aha1542_out(SCpnt->host->io_port, &ahacmd, 1);  /* start scsi command */
1662                         spin_unlock_irqrestore(&aha1542_lock, flags);
1663                         break;
1664                 }
1665         }
1666         if (AHA1542_MAILBOXES == mbo)
1667                 spin_unlock_irqrestore(&aha1542_lock, flags);
1668 #endif
1669         return SCSI_ABORT_SNOOZE;
1670 }
1671
1672 /* We do not implement a reset function here, but the upper level code
1673    assumes that it will get some kind of response for the command in
1674    SCpnt.  We must oblige, or the command will hang the scsi system.
1675    For a first go, we assume that the 1542 notifies us with all of the
1676    pending commands (it does implement soft reset, after all). */
1677
1678 static int aha1542_old_reset(Scsi_Cmnd * SCpnt, unsigned int reset_flags)
1679 {
1680         unchar ahacmd = CMD_START_SCSI;
1681         int i;
1682
1683         /*
1684          * See if a bus reset was suggested.
1685          */
1686         if (reset_flags & SCSI_RESET_SUGGEST_BUS_RESET) {
1687                 /*
1688                  * This does a scsi reset for all devices on the bus.
1689                  * In principle, we could also reset the 1542 - should
1690                  * we do this?  Try this first, and we can add that later
1691                  * if it turns out to be useful.
1692                  */
1693                 outb(HRST | SCRST, CONTROL(SCpnt->host->io_port));
1694
1695                 /*
1696                  * Wait for the thing to settle down a bit.  Unfortunately
1697                  * this is going to basically lock up the machine while we
1698                  * wait for this to complete.  To be 100% correct, we need to
1699                  * check for timeout, and if we are doing something like this
1700                  * we are pretty desperate anyways.
1701                  */
1702                 WAIT(STATUS(SCpnt->host->io_port),
1703                 STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
1704
1705                 /*
1706                  * We need to do this too before the 1542 can interact with
1707                  * us again.
1708                  */
1709                 setup_mailboxes(SCpnt->host->io_port, SCpnt->host);
1710
1711                 /*
1712                  * Now try to pick up the pieces.  Restart all commands
1713                  * that are currently active on the bus, and reset all of
1714                  * the datastructures.  We have some time to kill while
1715                  * things settle down, so print a nice message.
1716                  */
1717                 printk(KERN_WARNING "Sent BUS RESET to scsi host %d\n", SCpnt->host->host_no);
1718
1719                 for (i = 0; i < AHA1542_MAILBOXES; i++)
1720                         if (HOSTDATA(SCpnt->host)->SCint[i] != NULL) {
1721                                 Scsi_Cmnd *SCtmp;
1722                                 SCtmp = HOSTDATA(SCpnt->host)->SCint[i];
1723                                 SCtmp->result = DID_RESET << 16;
1724                                 if (SCtmp->host_scribble) {
1725                                         kfree(SCtmp->host_scribble);
1726                                         SCtmp->host_scribble = NULL;
1727                                 }
1728                                 printk(KERN_WARNING "Sending DID_RESET for target %d\n", SCpnt->target);
1729                                 SCtmp->scsi_done(SCpnt);
1730
1731                                 HOSTDATA(SCpnt->host)->SCint[i] = NULL;
1732                                 HOSTDATA(SCpnt->host)->mb[i].status = 0;
1733                         }
1734                 /*
1735                  * Now tell the mid-level code what we did here.  Since
1736                  * we have restarted all of the outstanding commands,
1737                  * then report SUCCESS.
1738                  */
1739                 return (SCSI_RESET_SUCCESS | SCSI_RESET_BUS_RESET);
1740 fail:
1741                 printk(KERN_CRIT "aha1542.c: Unable to perform hard reset.\n");
1742                 printk(KERN_CRIT "Power cycle machine to reset\n");
1743                 return (SCSI_RESET_ERROR | SCSI_RESET_BUS_RESET);
1744
1745
1746         } else {
1747                 /* This does a selective reset of just the one device */
1748                 /* First locate the ccb for this command */
1749                 for (i = 0; i < AHA1542_MAILBOXES; i++)
1750                         if (HOSTDATA(SCpnt->host)->SCint[i] == SCpnt) {
1751                                 HOSTDATA(SCpnt->host)->ccb[i].op = 0x81;        /* BUS DEVICE RESET */
1752                                 /* Now tell the 1542 to flush all pending commands for this target */
1753                                 aha1542_out(SCpnt->host->io_port, &ahacmd, 1);
1754
1755                                 /* Here is the tricky part.  What to do next.  Do we get an interrupt
1756                                    for the commands that we aborted with the specified target, or
1757                                    do we generate this on our own?  Try it without first and see
1758                                    what happens */
1759                                 printk(KERN_WARNING "Sent BUS DEVICE RESET to target %d\n", SCpnt->target);
1760
1761                                 /* If the first does not work, then try the second.  I think the
1762                                    first option is more likely to be correct. Free the command
1763                                    block for all commands running on this target... */
1764                                 for (i = 0; i < AHA1542_MAILBOXES; i++)
1765                                         if (HOSTDATA(SCpnt->host)->SCint[i] &&
1766                                             HOSTDATA(SCpnt->host)->SCint[i]->target == SCpnt->target) {
1767                                                 Scsi_Cmnd *SCtmp;
1768                                                 SCtmp = HOSTDATA(SCpnt->host)->SCint[i];
1769                                                 SCtmp->result = DID_RESET << 16;
1770                                                 if (SCtmp->host_scribble) {
1771                                                         kfree(SCtmp->host_scribble);
1772                                                         SCtmp->host_scribble = NULL;
1773                                                 }
1774                                                 printk(KERN_WARNING "Sending DID_RESET for target %d\n", SCpnt->target);
1775                                                 SCtmp->scsi_done(SCpnt);
1776
1777                                                 HOSTDATA(SCpnt->host)->SCint[i] = NULL;
1778                                                 HOSTDATA(SCpnt->host)->mb[i].status = 0;
1779                                         }
1780                                 return SCSI_RESET_SUCCESS;
1781                         }
1782         }
1783         /* No active command at this time, so this means that each time we got
1784            some kind of response the last time through.  Tell the mid-level code
1785            to request sense information in order to decide what to do next. */
1786         return SCSI_RESET_PUNT;
1787 }
1788 #endif    /* end of big comment block around old_abort + old_reset */
1789
1790 static int aha1542_biosparam(struct scsi_device *sdev,
1791                 struct block_device *bdev, sector_t capacity, int *ip)
1792 {
1793         int translation_algorithm;
1794         int size = capacity;
1795
1796         translation_algorithm = HOSTDATA(sdev->host)->bios_translation;
1797
1798         if ((size >> 11) > 1024 && translation_algorithm == BIOS_TRANSLATION_25563) {
1799                 /* Please verify that this is the same as what DOS returns */
1800                 ip[0] = 255;
1801                 ip[1] = 63;
1802                 ip[2] = size / 255 / 63;
1803         } else {
1804                 ip[0] = 64;
1805                 ip[1] = 32;
1806                 ip[2] = size >> 11;
1807         }
1808
1809         return 0;
1810 }
1811 MODULE_LICENSE("GPL");
1812
1813
1814 static Scsi_Host_Template driver_template = {
1815         .proc_name              = "aha1542",
1816         .name                   = "Adaptec 1542",
1817         .detect                 = aha1542_detect,
1818         .release                = aha1542_release,
1819         .queuecommand           = aha1542_queuecommand,
1820         .eh_abort_handler       = aha1542_abort,
1821         .eh_device_reset_handler= aha1542_dev_reset,
1822         .eh_bus_reset_handler   = aha1542_bus_reset,
1823         .eh_host_reset_handler  = aha1542_host_reset,
1824         .bios_param             = aha1542_biosparam,
1825         .can_queue              = AHA1542_MAILBOXES,
1826         .this_id                = 7,
1827         .sg_tablesize           = AHA1542_SCATTER,
1828         .cmd_per_lun            = AHA1542_CMDLUN,
1829         .unchecked_isa_dma      = 1,
1830         .use_clustering         = ENABLE_CLUSTERING,
1831 };
1832 #include "scsi_module.c"