drivers/scsi/aha1542.c

/* */
This source file includes following definitions.
aha1542_stat
aha1542_out
aha1542_in
aha1542_in1
makecode
aha1542_test_port
aha1542_intr_handle
aha1542_queuecommand
internal_done
aha1542_command
setup_mailboxes
aha1542_getconfig
aha1542_mbenable
aha1542_query
aha1542_setup
aha1542_detect
aha1542_restart
aha1542_abort
aha1542_reset
aha1542_biosparam
   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 controller).
  13  *  Modified by Matti Aarnio
  14  *        Accept parameters from LILO cmd-line. -- 1-Oct-94
  15  */
  16 
  17 #ifdef MODULE
  18 #include <linux/module.h>
  19 #endif
  20 
  21 #include <linux/kernel.h>
  22 #include <linux/head.h>
  23 #include <linux/types.h>
  24 #include <linux/string.h>
  25 #include <linux/ioport.h>
  26 
  27 #include <linux/delay.h>
  28 
  29 #include <linux/sched.h>
  30 #include <asm/dma.h>
  31 
  32 #include <asm/system.h>
  33 #include <asm/io.h>
  34 #include "../block/blk.h"
  35 #include "scsi.h"
  36 #include "hosts.h"
  37 
  38 #include "aha1542.h"
  39 
  40 #ifdef DEBUG
  41 #define DEB(x) x
  42 #else
  43 #define DEB(x)
  44 #endif
  45 /*
  46 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 $";
  47 */
  48 
  49 /* The adaptec can be configured for quite a number of addresses, but
  50 I generally do not want the card poking around at random.  We allow
  51 two addresses - this allows people to use the Adaptec with a Midi
  52 card, which also used 0x330 -- can be overridden with LILO! */
  53 
  54 #define MAXBOARDS 2     /* Increase this and the sizes of the
  55                            arrays below, if you need more.. */
  56 
  57 static unsigned int bases[MAXBOARDS]={0x330, 0x334};
  58 
  59 /* set by aha1542_setup according to the command line */
  60 static int setup_called[MAXBOARDS]   = {0,0};
  61 static int setup_buson[MAXBOARDS]    = {0,0};
  62 static int setup_busoff[MAXBOARDS]   = {0,0};
  63 static int setup_dmaspeed[MAXBOARDS] = {-1,-1};
  64 
  65 static char *setup_str[MAXBOARDS] = {(char *)NULL,(char *)NULL};
  66 
  67 /*
  68  * LILO params:  aha1542=<PORTBASE>[,<BUSON>,<BUSOFF>[,<DMASPEED>]]
  69  *
  70  * Where:  <PORTBASE> is any of the valid AHA addresses:
  71  *                      0x130, 0x134, 0x230, 0x234, 0x330, 0x334
  72  *         <BUSON>  is the time (in microsecs) that AHA spends on the AT-bus
  73  *                  when transferring data.  1542A power-on default is 11us,
  74  *                  valid values are in range: 2..15 (decimal)
  75  *         <BUSOFF> is the time that AHA spends OFF THE BUS after while
  76  *                  it is transferring data (not to monopolize the bus).
  77  *                  Power-on default is 4us, valid range: 1..64 microseconds.
  78  *         <DMASPEED> Default is jumper selected (1542A: on the J1),
  79  *                  but experimenter can alter it with this.
  80  *                  Valid values: 5, 6, 7, 8, 10 (MB/s)
  81  *                  Factory default is 5 MB/s.
  82  */
  83 
  84 
  85 /* The DMA-Controller.  We need to fool with this because we want to 
  86    be able to use the aha1542 without having to have the bios enabled */
  87 #define DMA_MODE_REG    0xd6
  88 #define DMA_MASK_REG    0xd4
  89 #define CASCADE         0xc0
  90 
  91 #define BIOS_TRANSLATION_1632 0  /* Used by some old 1542A boards */
  92 #define BIOS_TRANSLATION_6432 1 /* Default case these days */
  93 #define BIOS_TRANSLATION_25563 2 /* Big disk case */
  94 
  95 struct aha1542_hostdata{
  96         /* This will effectively start both of them at the first mailbox */
  97         int bios_translation;   /* Mapping bios uses - for compatibility */
  98         int aha1542_last_mbi_used;
  99         int aha1542_last_mbo_used;
 100         Scsi_Cmnd * SCint[AHA1542_MAILBOXES];
 101         struct mailbox mb[2*AHA1542_MAILBOXES];
 102         struct ccb ccb[AHA1542_MAILBOXES];
 103 };
 104 
 105 #define HOSTDATA(host) ((struct aha1542_hostdata *) &host->hostdata)
 106 
 107 static struct Scsi_Host * aha_host[7] = {NULL,};  /* One for each IRQ level (9-15) */
 108 
 109 
 110 
 111 
 112 #define WAITnexttimeout 3000000
 113 
 114 static void setup_mailboxes(int base_io, struct Scsi_Host * shpnt);
 115 static int aha1542_restart(struct Scsi_Host * shost);
 116 
 117 #define aha1542_intr_reset(base)  outb(IRST, CONTROL(base))
 118 
 119 #define WAIT(port, mask, allof, noneof)                                 \
 120  { register WAITbits;                                                   \
 121    register WAITtimeout = WAITnexttimeout;                              \
 122    while (1) {                                                          \
 123      WAITbits = inb(port) & (mask);                                     \
 124      if ((WAITbits & (allof)) == (allof) && ((WAITbits & (noneof)) == 0)) \
 125        break;                                                           \
 126      if (--WAITtimeout == 0) goto fail;                                 \
 127    }                                                                    \
 128  }
 129 
 130 /* Similar to WAIT, except we use the udelay call to regulate the
 131    amount of time we wait.  */
 132 #define WAITd(port, mask, allof, noneof, timeout)                       \
 133  { register WAITbits;                                                   \
 134    register WAITtimeout = timeout;                                      \
 135    while (1) {                                                          \
 136      WAITbits = inb(port) & (mask);                                     \
 137      if ((WAITbits & (allof)) == (allof) && ((WAITbits & (noneof)) == 0)) \
 138        break;                                                           \
 139      udelay(1000);                                                      \
 140      if (--WAITtimeout == 0) goto fail;                                 \
 141    }                                                                    \
 142  }
 143 
 144 static void aha1542_stat(void)
     /*  */
 145 {
 146 /*    int s = inb(STATUS), i = inb(INTRFLAGS);
 147   printk("status=%x intrflags=%x\n", s, i, WAITnexttimeout-WAITtimeout); */
 148 }
 149 
 150 /* This is a bit complicated, but we need to make sure that an interrupt
 151    routine does not send something out while we are in the middle of this.
 152    Fortunately, it is only at boot time that multi-byte messages
 153    are ever sent. */
 154 static int aha1542_out(unsigned int base, unchar *cmdp, int len)
     /*  */
 155 {
 156   unsigned long flags = 0;
 157   
 158   if(len == 1) {
 159     while(1==1){
 160         WAIT(STATUS(base), CDF, 0, CDF);
 161         save_flags(flags);
 162         cli();
 163         if(inb(STATUS(base)) & CDF) {restore_flags(flags); continue;}
 164         outb(*cmdp, DATA(base));
 165         restore_flags(flags);
 166         return 0;
 167       }
 168   } else {
 169     save_flags(flags);
 170     cli();
 171     while (len--)
 172       {
 173         WAIT(STATUS(base), CDF, 0, CDF);
 174         outb(*cmdp++, DATA(base));
 175       }
 176     restore_flags(flags);
 177   }
 178     return 0;
 179   fail:
 180     restore_flags(flags);
 181     printk("aha1542_out failed(%d): ", len+1); aha1542_stat();
 182     return 1;
 183 }
 184 
 185 /* Only used at boot time, so we do not need to worry about latency as much
 186    here */
 187 static int aha1542_in(unsigned int base, unchar *cmdp, int len)
     /*  */
 188 {
 189     unsigned long flags;
 190 
 191     save_flags(flags);
 192     cli();
 193     while (len--)
 194       {
 195           WAIT(STATUS(base), DF, DF, 0);
 196           *cmdp++ = inb(DATA(base));
 197       }
 198     restore_flags(flags);
 199     return 0;
 200   fail:
 201     restore_flags(flags);
 202     printk("aha1542_in failed(%d): ", len+1); aha1542_stat();
 203     return 1;
 204 }
 205 
 206 /* Similar to aha1542_in, except that we wait a very short period of time.
 207    We use this if we know the board is alive and awake, but we are not sure
 208    if the board will respond the the command we are about to send or not */
 209 static int aha1542_in1(unsigned int base, unchar *cmdp, int len)
     /*  */
 210 {
 211     unsigned long flags;
 212     
 213     save_flags(flags);
 214     cli();
 215     while (len--)
 216       {
 217           WAITd(STATUS(base), DF, DF, 0, 100);
 218           *cmdp++ = inb(DATA(base));
 219       }
 220     restore_flags(flags);
 221     return 0;
 222   fail:
 223     restore_flags(flags);
 224     return 1;
 225 }
 226 
 227 static int makecode(unsigned hosterr, unsigned scsierr)
     /*  */
 228 {
 229     switch (hosterr) {
 230       case 0x0:
 231       case 0xa: /* Linked command complete without error and linked normally */
 232       case 0xb: /* Linked command complete without error, interrupt generated */
 233         hosterr = 0;
 234         break;
 235 
 236       case 0x11: /* Selection time out-The initiator selection or target
 237                     reselection was not complete within the SCSI Time out period */
 238         hosterr = DID_TIME_OUT;
 239         break;
 240 
 241       case 0x12: /* Data overrun/underrun-The target attempted to transfer more data
 242                     than was allocated by the Data Length field or the sum of the
 243                     Scatter / Gather Data Length fields. */
 244 
 245       case 0x13: /* Unexpected bus free-The target dropped the SCSI BSY at an unexpected time. */
 246 
 247       case 0x15: /* MBO command was not 00, 01 or 02-The first byte of the CB was
 248                     invalid. This usually indicates a software failure. */
 249 
 250       case 0x16: /* Invalid CCB Operation Code-The first byte of the CCB was invalid.
 251                     This usually indicates a software failure. */
 252 
 253       case 0x17: /* Linked CCB does not have the same LUN-A subsequent CCB of a set
 254                     of linked CCB's does not specify the same logical unit number as
 255                     the first. */
 256       case 0x18: /* Invalid Target Direction received from Host-The direction of a
 257                     Target Mode CCB was invalid. */
 258 
 259       case 0x19: /* Duplicate CCB Received in Target Mode-More than once CCB was
 260                     received to service data transfer between the same target LUN
 261                     and initiator SCSI ID in the same direction. */
 262 
 263       case 0x1a: /* Invalid CCB or Segment List Parameter-A segment list with a zero
 264                     length segment or invalid segment list boundaries was received.
 265                     A CCB parameter was invalid. */
 266         DEB(printk("Aha1542: %x %x\n", hosterr, scsierr));
 267         hosterr = DID_ERROR; /* Couldn't find any better */
 268         break;
 269 
 270       case 0x14: /* Target bus phase sequence failure-An invalid bus phase or bus
 271                     phase sequence was requested by the target. The host adapter
 272                     will generate a SCSI Reset Condition, notifying the host with
 273                     a SCRD interrupt */
 274         hosterr = DID_RESET;
 275         break;
 276       default:
 277         printk("makecode: unknown hoststatus %x\n", hosterr);
 278         break;
 279     }
 280     return scsierr|(hosterr << 16);
 281 }
 282 
 283 static int aha1542_test_port(int bse, struct Scsi_Host * shpnt)
     /*  */
 284 {
 285     int i;
 286     unchar inquiry_cmd[] = {CMD_INQUIRY };
 287     unchar inquiry_result[4];
 288     unchar *cmdp;
 289     int len;
 290     volatile int debug = 0;
 291     
 292     /* Quick and dirty test for presence of the card. */
 293     if(inb(STATUS(bse)) == 0xff) return 0;
 294 
 295     /* Reset the adapter. I ought to make a hard reset, but it's not really necessary */
 296     
 297     /*  DEB(printk("aha1542_test_port called \n")); */
 298 
 299     /* In case some other card was probing here, reset interrupts */
 300     aha1542_intr_reset(bse);     /* reset interrupts, so they don't block */    
 301 
 302     outb(SRST|IRST/*|SCRST*/, CONTROL(bse));
 303 
 304     i = jiffies + 2;
 305     while (i>jiffies); /* Wait a little bit for things to settle down. */
 306     
 307     debug = 1;
 308     /* Expect INIT and IDLE, any of the others are bad */
 309     WAIT(STATUS(bse), STATMASK, INIT|IDLE, STST|DIAGF|INVDCMD|DF|CDF);
 310     
 311     debug = 2;
 312     /* Shouldn't have generated any interrupts during reset */
 313     if (inb(INTRFLAGS(bse))&INTRMASK) goto fail;
 314 
 315 
 316     /* Perform a host adapter inquiry instead so we do not need to set
 317        up the mailboxes ahead of time */
 318 
 319     aha1542_out(bse, inquiry_cmd, 1);
 320 
 321     debug = 3;
 322     len = 4;
 323     cmdp = &inquiry_result[0];
 324 
 325     while (len--)
 326       {
 327           WAIT(STATUS(bse), DF, DF, 0);
 328           *cmdp++ = inb(DATA(bse));
 329       }
 330     
 331     debug = 8;
 332     /* Reading port should reset DF */
 333     if (inb(STATUS(bse)) & DF) goto fail;
 334     
 335     debug = 9;
 336     /* When HACC, command is completed, and we're though testing */
 337     WAIT(INTRFLAGS(bse), HACC, HACC, 0);
 338     /* now initialize adapter */
 339     
 340     debug = 10;
 341     /* Clear interrupts */
 342     outb(IRST, CONTROL(bse));
 343     
 344     debug = 11;
 345 
 346     return debug;                               /* 1 = ok */
 347   fail:
 348     return 0;                                   /* 0 = not ok */
 349 }
 350 
 351 /* A "high" level interrupt handler */
 352 static void aha1542_intr_handle(int irq, struct pt_regs *regs)
     /*  */
 353 {
 354     void (*my_done)(Scsi_Cmnd *) = NULL;
 355     int errstatus, mbi, mbo, mbistatus;
 356     int number_serviced;
 357     unsigned int flags;
 358     struct Scsi_Host * shost;
 359     Scsi_Cmnd * SCtmp;
 360     int flag;
 361     int needs_restart;
 362     struct mailbox * mb;
 363     struct ccb  *ccb;
 364 
 365     shost = aha_host[irq - 9];
 366     if(!shost) panic("Splunge!");
 367 
 368     mb = HOSTDATA(shost)->mb;
 369     ccb = HOSTDATA(shost)->ccb;
 370 
 371 #ifdef DEBUG
 372     {
 373     flag = inb(INTRFLAGS(shost->io_port));
 374     printk("aha1542_intr_handle: ");
 375     if (!(flag&ANYINTR)) printk("no interrupt?");
 376     if (flag&MBIF) printk("MBIF ");
 377     if (flag&MBOA) printk("MBOF ");
 378     if (flag&HACC) printk("HACC ");
 379     if (flag&SCRD) printk("SCRD ");
 380     printk("status %02x\n", inb(STATUS(shost->io_port)));
 381   };
 382 #endif
 383     number_serviced = 0;
 384     needs_restart = 0;
 385 
 386     while(1==1){
 387       flag = inb(INTRFLAGS(shost->io_port));
 388 
 389       /* Check for unusual interrupts.  If any of these happen, we should
 390          probably do something special, but for now just printing a message
 391          is sufficient.  A SCSI reset detected is something that we really
 392          need to deal with in some way. */
 393       if (flag & ~MBIF) {
 394         if (flag&MBOA) printk("MBOF ");
 395         if (flag&HACC) printk("HACC ");
 396         if (flag&SCRD) {
 397           needs_restart = 1;
 398           printk("SCRD ");
 399         }
 400       }
 401 
 402       aha1542_intr_reset(shost->io_port);
 403 
 404       save_flags(flags);
 405       cli();
 406       mbi = HOSTDATA(shost)->aha1542_last_mbi_used + 1;
 407       if (mbi >= 2*AHA1542_MAILBOXES) mbi = AHA1542_MAILBOXES;
 408       
 409       do{
 410         if(mb[mbi].status != 0) break;
 411         mbi++;
 412         if (mbi >= 2*AHA1542_MAILBOXES) mbi = AHA1542_MAILBOXES;
 413       } while (mbi != HOSTDATA(shost)->aha1542_last_mbi_used);
 414       
 415       if(mb[mbi].status == 0){
 416         restore_flags(flags);
 417         /* Hmm, no mail.  Must have read it the last time around */
 418         if (!number_serviced && !needs_restart)
 419           printk("aha1542.c: interrupt received, but no mail.\n");
 420         /* We detected a reset.  Restart all pending commands for
 421            devices that use the hard reset option */
 422         if(needs_restart) aha1542_restart(shost);
 423         return;
 424       };
 425 
 426       mbo = (scsi2int(mb[mbi].ccbptr) - ((unsigned int) &ccb[0])) / sizeof(struct ccb);
 427       mbistatus = mb[mbi].status;
 428       mb[mbi].status = 0;
 429       HOSTDATA(shost)->aha1542_last_mbi_used = mbi;
 430       restore_flags(flags);
 431       
 432 #ifdef DEBUG
 433       {
 434         if (ccb[mbo].tarstat|ccb[mbo].hastat)
 435           printk("aha1542_command: returning %x (status %d)\n", 
 436                  ccb[mbo].tarstat + ((int) ccb[mbo].hastat << 16), mb[mbi].status);
 437       };
 438 #endif
 439 
 440       if(mbistatus == 3) continue; /* Aborted command not found */
 441 
 442 #ifdef DEBUG
 443       printk("...done %d %d\n",mbo, mbi);
 444 #endif
 445       
 446       SCtmp = HOSTDATA(shost)->SCint[mbo];
 447 
 448       if (!SCtmp || !SCtmp->scsi_done) {
 449         printk("aha1542_intr_handle: Unexpected interrupt\n");
 450         printk("tarstat=%x, hastat=%x idlun=%x ccb#=%d \n", ccb[mbo].tarstat, 
 451                ccb[mbo].hastat, ccb[mbo].idlun, mbo);
 452         return;
 453       }
 454       
 455       my_done = SCtmp->scsi_done;
 456       if (SCtmp->host_scribble) scsi_free(SCtmp->host_scribble, 512);
 457       
 458       /* Fetch the sense data, and tuck it away, in the required slot.  The
 459          Adaptec automatically fetches it, and there is no guarantee that
 460          we will still have it in the cdb when we come back */
 461       if (ccb[mbo].tarstat == 2)
 462         memcpy(SCtmp->sense_buffer, &ccb[mbo].cdb[ccb[mbo].cdblen], 
 463                sizeof(SCtmp->sense_buffer));
 464       
 465       
 466       /* is there mail :-) */
 467       
 468       /* more error checking left out here */
 469       if (mbistatus != 1)
 470         /* This is surely wrong, but I don't know what's right */
 471         errstatus = makecode(ccb[mbo].hastat, ccb[mbo].tarstat);
 472       else
 473         errstatus = 0;
 474       
 475 #ifdef DEBUG
 476       if(errstatus) printk("(aha1542 error:%x %x %x) ",errstatus, 
 477                            ccb[mbo].hastat, ccb[mbo].tarstat);
 478 #endif
 479 
 480       if (ccb[mbo].tarstat == 2) {
 481 #ifdef DEBUG
 482         int i;
 483 #endif
 484         DEB(printk("aha1542_intr_handle: sense:"));
 485 #ifdef DEBUG
 486         for (i = 0; i < 12; i++)
 487           printk("%02x ", ccb[mbo].cdb[ccb[mbo].cdblen+i]);
 488         printk("\n");
 489 #endif
 490         /*
 491           DEB(printk("aha1542_intr_handle: buf:"));
 492           for (i = 0; i < bufflen; i++)
 493           printk("%02x ", ((unchar *)buff)[i]);
 494           printk("\n");
 495           */
 496       }
 497       DEB(if (errstatus) printk("aha1542_intr_handle: returning %6x\n", errstatus));
 498       SCtmp->result = errstatus;
 499       HOSTDATA(shost)->SCint[mbo] = NULL;  /* This effectively frees up the mailbox slot, as
 500                              far as queuecommand is concerned */
 501       my_done(SCtmp);
 502       number_serviced++;
 503     };
 504 }
 505 
 506 int aha1542_queuecommand(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
     /*  */
 507 {
 508     unchar ahacmd = CMD_START_SCSI;
 509     unchar direction;
 510     unchar *cmd = (unchar *) SCpnt->cmnd;
 511     unchar target = SCpnt->target;
 512     unchar lun = SCpnt->lun;
 513     unsigned long flags;
 514     void *buff = SCpnt->request_buffer;
 515     int bufflen = SCpnt->request_bufflen;
 516     int mbo;
 517     struct mailbox * mb;
 518     struct ccb  *ccb;
 519 
 520     DEB(int i);
 521 
 522     mb = HOSTDATA(SCpnt->host)->mb;
 523     ccb = HOSTDATA(SCpnt->host)->ccb;
 524 
 525     DEB(if (target > 1) {
 526       SCpnt->result = DID_TIME_OUT << 16;
 527       done(SCpnt); return 0;});
 528     
 529     if(*cmd == REQUEST_SENSE){
 530 #ifndef DEBUG
 531       if (bufflen != sizeof(SCpnt->sense_buffer)) {
 532         printk("Wrong buffer length supplied for request sense (%d)\n",bufflen);
 533       };
 534 #endif
 535       SCpnt->result = 0;
 536       done(SCpnt); 
 537       return 0;
 538     };
 539 
 540 #ifdef DEBUG
 541     if (*cmd == READ_10 || *cmd == WRITE_10)
 542       i = xscsi2int(cmd+2);
 543     else if (*cmd == READ_6 || *cmd == WRITE_6)
 544       i = scsi2int(cmd+2);
 545     else
 546       i = -1;
 547     if (done)
 548       printk("aha1542_queuecommand: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
 549     else
 550       printk("aha1542_command: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
 551     aha1542_stat();
 552     printk("aha1542_queuecommand: dumping scsi cmd:");
 553     for (i = 0; i < SCpnt->cmd_len; i++) printk("%02x ", cmd[i]);
 554     printk("\n");
 555     if (*cmd == WRITE_10 || *cmd == WRITE_6)
 556       return 0; /* we are still testing, so *don't* write */
 557 #endif
 558 /* Use the outgoing mailboxes in a round-robin fashion, because this
 559    is how the host adapter will scan for them */
 560 
 561     save_flags(flags);
 562     cli();
 563     mbo = HOSTDATA(SCpnt->host)->aha1542_last_mbo_used + 1;
 564     if (mbo >= AHA1542_MAILBOXES) mbo = 0;
 565 
 566     do{
 567       if(mb[mbo].status == 0 && HOSTDATA(SCpnt->host)->SCint[mbo] == NULL)
 568         break;
 569       mbo++;
 570       if (mbo >= AHA1542_MAILBOXES) mbo = 0;
 571     } while (mbo != HOSTDATA(SCpnt->host)->aha1542_last_mbo_used);
 572 
 573     if(mb[mbo].status || HOSTDATA(SCpnt->host)->SCint[mbo])
 574       panic("Unable to find empty mailbox for aha1542.\n");
 575 
 576     HOSTDATA(SCpnt->host)->SCint[mbo] = SCpnt;  /* This will effectively prevent someone else from
 577                             screwing with this cdb. */
 578 
 579     HOSTDATA(SCpnt->host)->aha1542_last_mbo_used = mbo;    
 580     restore_flags(flags);
 581 
 582 #ifdef DEBUG
 583     printk("Sending command (%d %x)...",mbo, done);
 584 #endif
 585 
 586     any2scsi(mb[mbo].ccbptr, &ccb[mbo]); /* This gets trashed for some reason*/
 587 
 588     memset(&ccb[mbo], 0, sizeof(struct ccb));
 589 
 590     ccb[mbo].cdblen = SCpnt->cmd_len;
 591 
 592     direction = 0;
 593     if (*cmd == READ_10 || *cmd == READ_6)
 594         direction = 8;
 595     else if (*cmd == WRITE_10 || *cmd == WRITE_6)
 596         direction = 16;
 597 
 598     memcpy(ccb[mbo].cdb, cmd, ccb[mbo].cdblen);
 599 
 600     if (SCpnt->use_sg) {
 601       struct scatterlist * sgpnt;
 602       struct chain * cptr;
 603 #ifdef DEBUG
 604       unsigned char * ptr;
 605 #endif
 606       int i;
 607       ccb[mbo].op = 2;        /* SCSI Initiator Command  w/scatter-gather*/
 608       SCpnt->host_scribble = (unsigned char *) scsi_malloc(512);
 609       sgpnt = (struct scatterlist *) SCpnt->request_buffer;
 610       cptr = (struct chain *) SCpnt->host_scribble; 
 611       if (cptr == NULL) panic("aha1542.c: unable to allocate DMA memory\n");
 612       for(i=0; i<SCpnt->use_sg; i++) {
 613         if(sgpnt[i].length == 0 || SCpnt->use_sg > 16 || 
 614            (((int)sgpnt[i].address) & 1) || (sgpnt[i].length & 1)){
 615           unsigned char * ptr;
 616           printk("Bad segment list supplied to aha1542.c (%d, %d)\n",SCpnt->use_sg,i);
 617           for(i=0;i<SCpnt->use_sg;i++){
 618             printk("%d: %x %x %d\n",i,(unsigned int) sgpnt[i].address, (unsigned int) sgpnt[i].alt_address,
 619                    sgpnt[i].length);
 620           };
 621           printk("cptr %x: ",(unsigned int) cptr);
 622           ptr = (unsigned char *) &cptr[i];
 623           for(i=0;i<18;i++) printk("%02x ", ptr[i]);
 624           panic("Foooooooood fight!");
 625         };
 626         any2scsi(cptr[i].dataptr, sgpnt[i].address);
 627         if(((unsigned  int) sgpnt[i].address) & 0xff000000) goto baddma;
 628         any2scsi(cptr[i].datalen, sgpnt[i].length);
 629       };
 630       any2scsi(ccb[mbo].datalen, SCpnt->use_sg * sizeof(struct chain));
 631       any2scsi(ccb[mbo].dataptr, cptr);
 632 #ifdef DEBUG
 633       printk("cptr %x: ",cptr);
 634       ptr = (unsigned char *) cptr;
 635       for(i=0;i<18;i++) printk("%02x ", ptr[i]);
 636 #endif
 637     } else {
 638       ccb[mbo].op = 0;        /* SCSI Initiator Command */
 639       SCpnt->host_scribble = NULL;
 640       any2scsi(ccb[mbo].datalen, bufflen);
 641       if(((unsigned int) buff & 0xff000000)) goto baddma;
 642       any2scsi(ccb[mbo].dataptr, buff);
 643     };
 644     ccb[mbo].idlun = (target&7)<<5 | direction | (lun & 7); /*SCSI Target Id*/
 645     ccb[mbo].rsalen = 12;
 646     ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
 647     ccb[mbo].commlinkid = 0;
 648 
 649 #ifdef DEBUG
 650     { int i;
 651     printk("aha1542_command: sending.. ");
 652     for (i = 0; i < sizeof(ccb[mbo])-10; i++)
 653       printk("%02x ", ((unchar *)&ccb[mbo])[i]);
 654     };
 655 #endif
 656     
 657     if (done) {
 658         DEB(printk("aha1542_queuecommand: now waiting for interrupt "); aha1542_stat());
 659         SCpnt->scsi_done = done;
 660         mb[mbo].status = 1;
 661         aha1542_out(SCpnt->host->io_port, &ahacmd, 1);          /* start scsi command */
 662         DEB(aha1542_stat());
 663     }
 664     else
 665       printk("aha1542_queuecommand: done can't be NULL\n");
 666     
 667     return 0;
 668  baddma:
 669     panic("Buffer at address  > 16Mb used for 1542B");
 670 }
 671 
 672 static void internal_done(Scsi_Cmnd * SCpnt)
     /*  */
 673 {
 674         SCpnt->SCp.Status++;
 675 }
 676 
 677 int aha1542_command(Scsi_Cmnd * SCpnt)
     /*  */
 678 {
 679     DEB(printk("aha1542_command: ..calling aha1542_queuecommand\n"));
 680 
 681     aha1542_queuecommand(SCpnt, internal_done);
 682 
 683     SCpnt->SCp.Status = 0;
 684     while (!SCpnt->SCp.Status);
 685     return SCpnt->result;
 686 }
 687 
 688 /* Initialize mailboxes */
 689 static void setup_mailboxes(int bse, struct Scsi_Host * shpnt)
     /*  */
 690 {
 691     int i;
 692     struct mailbox * mb;
 693     struct ccb  *ccb;
 694 
 695     unchar cmd[5] = {CMD_MBINIT, AHA1542_MAILBOXES, 0, 0, 0};
 696 
 697     mb = HOSTDATA(shpnt)->mb;
 698     ccb = HOSTDATA(shpnt)->ccb;
 699 
 700     for(i=0; i<AHA1542_MAILBOXES; i++){
 701       mb[i].status = mb[AHA1542_MAILBOXES+i].status = 0;
 702       any2scsi(mb[i].ccbptr, &ccb[i]);
 703     };
 704     aha1542_intr_reset(bse);     /* reset interrupts, so they don't block */    
 705     any2scsi((cmd+2), mb);
 706     aha1542_out(bse, cmd, 5);
 707     WAIT(INTRFLAGS(bse), INTRMASK, HACC, 0);
 708     while (0) {
 709       fail:
 710         printk("aha1542_detect: failed setting up mailboxes\n");
 711     }
 712     aha1542_intr_reset(bse);
 713 }
 714 
 715 static int aha1542_getconfig(int base_io, unsigned char * irq_level, unsigned char * dma_chan)
     /*  */
 716 {
 717   unchar inquiry_cmd[] = {CMD_RETCONF };
 718   unchar inquiry_result[3];
 719   int i;
 720   i = inb(STATUS(base_io));
 721   if (i & DF) {
 722     i = inb(DATA(base_io));
 723   };
 724   aha1542_out(base_io, inquiry_cmd, 1);
 725   aha1542_in(base_io, inquiry_result, 3);
 726   WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
 727   while (0) {
 728   fail:
 729     printk("aha1542_detect: query board settings\n");
 730   }
 731   aha1542_intr_reset(base_io);
 732   switch(inquiry_result[0]){
 733   case 0x80:
 734     *dma_chan = 7;
 735     break;
 736   case 0x40:
 737     *dma_chan = 6;
 738     break;
 739   case 0x20:
 740     *dma_chan = 5;
 741     break;
 742   case 0x01:
 743     printk("DMA priority 0 not available for Adaptec driver\n");
 744     return -1;
 745   case 0:
 746     /* This means that the adapter, although Adaptec 1542 compatible, doesn't use a DMA channel.
 747        Currently only aware of the BusLogic BT-445S VL-Bus adapter which needs this. */
 748     *dma_chan = 0xFF;
 749     break;
 750   default:
 751     printk("Unable to determine Adaptec DMA priority.  Disabling board\n");
 752     return -1;
 753   };
 754   switch(inquiry_result[1]){
 755   case 0x40:
 756     *irq_level = 15;
 757     break;
 758   case 0x20:
 759     *irq_level = 14;
 760     break;
 761   case 0x8:
 762     *irq_level = 12;
 763     break;
 764   case 0x4:
 765     *irq_level = 11;
 766     break;
 767   case 0x2:
 768     *irq_level = 10;
 769     break;
 770   case 0x1:
 771     *irq_level = 9;
 772     break;
 773   default:
 774     printk("Unable to determine Adaptec IRQ level.  Disabling board\n");
 775     return -1;
 776   };
 777   return 0;
 778 }
 779 
 780 /* This function should only be called for 1542C boards - we can detect
 781    the special firmware settings and unlock the board */
 782 
 783 static int aha1542_mbenable(int base)
     /*  */
 784 {
 785   static unchar mbenable_cmd[3];
 786   static unchar mbenable_result[2];
 787   int retval;
 788   
 789   retval = BIOS_TRANSLATION_6432;
 790 
 791   mbenable_cmd[0]=CMD_EXTBIOS;
 792   aha1542_out(base,mbenable_cmd,1);
 793   if(aha1542_in1(base,mbenable_result,2))
 794     return retval;
 795   WAITd(INTRFLAGS(base),INTRMASK,HACC,0,100);
 796   aha1542_intr_reset(base);
 797   
 798   if ((mbenable_result[0] & 0x08) || mbenable_result[1]) {
 799      mbenable_cmd[0]=CMD_MBENABLE;
 800      mbenable_cmd[1]=0;
 801      mbenable_cmd[2]=mbenable_result[1];
 802      if(mbenable_result[1] & 1) retval = BIOS_TRANSLATION_25563;
 803      aha1542_out(base,mbenable_cmd,3);
 804      WAIT(INTRFLAGS(base),INTRMASK,HACC,0);
 805   };
 806   while(0) {
 807 fail:
 808     printk("aha1542_mbenable: Mailbox init failed\n");
 809   }
 810 aha1542_intr_reset(base);
 811 return retval;
 812 }
 813 
 814 /* Query the board to find out if it is a 1542 or a 1740, or whatever. */
 815 static int aha1542_query(int base_io, int * transl)
     /*  */
 816 {
 817   unchar inquiry_cmd[] = {CMD_INQUIRY };
 818   unchar inquiry_result[4];
 819   int i;
 820   i = inb(STATUS(base_io));
 821   if (i & DF) {
 822     i = inb(DATA(base_io));
 823   };
 824   aha1542_out(base_io, inquiry_cmd, 1);
 825   aha1542_in(base_io, inquiry_result, 4);
 826   WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
 827   while (0) {
 828   fail:
 829     printk("aha1542_detect: query card type\n");
 830   }
 831   aha1542_intr_reset(base_io);
 832 
 833   *transl = BIOS_TRANSLATION_6432; /* Default case */
 834 
 835 /* For an AHA1740 series board, we ignore the board since there is a
 836    hardware bug which can lead to wrong blocks being returned if the board
 837    is operating in the 1542 emulation mode.  Since there is an extended mode
 838    driver, we simply ignore the board and let the 1740 driver pick it up.
 839 */
 840 
 841   if (inquiry_result[0] == 0x43) {
 842     printk("aha1542.c: Emulation mode not supported for AHA 174N hardware.\n");
 843     return 1;
 844   };
 845 
 846   /* Always call this - boards that do not support extended bios translation
 847      will ignore the command, and we will set the proper default */
 848 
 849   *transl = aha1542_mbenable(base_io);
 850 
 851   return 0;
 852 }
 853 
 854 /* called from init/main.c */
 855 void aha1542_setup( char *str, int *ints)
     /*  */
 856 {
 857     char *ahausage = "aha1542: usage: aha1542=<PORTBASE>[,<BUSON>,<BUSOFF>[,<DMASPEED>]]\n";
 858     static int setup_idx = 0;
 859     int setup_portbase;
 860 
 861     if(setup_idx >= MAXBOARDS)
 862       {
 863         printk("aha1542: aha1542_setup called too many times! Bad LILO params ?\n");
 864         printk("   Entryline 1: %s\n",setup_str[0]);
 865         printk("   Entryline 2: %s\n",setup_str[1]);
 866         printk("   This line:   %s\n",str);
 867         return;
 868       }
 869     if (ints[0] < 1 || ints[0] > 4)
 870       {
 871         printk("aha1542: %s\n", str );
 872         printk(ahausage);
 873         printk("aha1542: Wrong parameters may cause system malfunction.. We try anyway..\n");
 874       }
 875 
 876     setup_called[setup_idx]=ints[0];
 877     setup_str[setup_idx]=str;
 878 
 879     setup_portbase             = ints[0] >= 1 ? ints[1] : 0; /* Preserve the default value.. */
 880     setup_buson   [setup_idx]  = ints[0] >= 2 ? ints[2] : 7;
 881     setup_busoff  [setup_idx]  = ints[0] >= 3 ? ints[3] : 5;
 882     if (ints[0] >= 4) {
 883       int atbt = -1;
 884       switch (ints[4]) {
 885         case 5:
 886             atbt = 0x00;
 887             break;
 888         case 6:
 889             atbt = 0x04;
 890             break;
 891         case 7:
 892             atbt = 0x01;
 893             break;
 894         case 8:
 895             atbt = 0x02;
 896             break;
 897         case 10:
 898             atbt = 0x03;
 899             break;
 900         default:
 901             printk("aha1542: %s\n", str );
 902             printk(ahausage);
 903             printk("aha1542: Valid values for DMASPEED are 5-8, 10 MB/s.  Using jumper defaults.\n");
 904             break;
 905       }
 906       setup_dmaspeed[setup_idx]  = atbt;
 907     }
 908 
 909     if (setup_portbase != 0)
 910       bases[setup_idx] = setup_portbase;
 911 
 912     ++setup_idx;
 913 }
 914 
 915 /* return non-zero on detection */
 916 int aha1542_detect(Scsi_Host_Template * tpnt)
     /*  */
 917 {
 918     unsigned char dma_chan;
 919     unsigned char irq_level;
 920     unsigned long flags;
 921     unsigned int base_io;
 922     int trans;
 923     struct Scsi_Host * shpnt = NULL;
 924     int count = 0;
 925     int indx;
 926 
 927     DEB(printk("aha1542_detect: \n"));
 928 
 929     for(indx = 0; indx < sizeof(bases)/sizeof(bases[0]); indx++)
 930             if(bases[indx] != 0 && !check_region(bases[indx], 4)) { 
 931                     shpnt = scsi_register(tpnt,
 932                                           sizeof(struct aha1542_hostdata));
 933 
 934                     /* For now we do this - until kmalloc is more intelligent
 935                        we are resigned to stupid hacks like this */
 936                     if ((unsigned int) shpnt > 0xffffff) {
 937                       printk("Invalid address for shpnt with 1542.\n");
 938                       goto unregister;
 939                     }
 940 
 941                     if(!aha1542_test_port(bases[indx], shpnt)) goto unregister;
 942 
 943 
 944                     base_io = bases[indx];
 945                     
 946                     /* Set the Bus on/off-times as not to ruin floppy performance */
 947             {
 948                     unchar oncmd[] = {CMD_BUSON_TIME, 7};
 949                     unchar offcmd[] = {CMD_BUSOFF_TIME, 5};
 950 
 951                     if(setup_called[indx])
 952                       {
 953                         oncmd[1]  = setup_buson[indx];
 954                         offcmd[1] = setup_busoff[indx];
 955                       }
 956                     
 957                     aha1542_intr_reset(base_io);
 958                     aha1542_out(base_io, oncmd, 2);
 959                     WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
 960                     aha1542_intr_reset(base_io);
 961                     aha1542_out(base_io, offcmd, 2);
 962                     WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
 963                     if (setup_dmaspeed[indx] >= 0)
 964                       {
 965                         unchar dmacmd[] = {CMD_DMASPEED, 0};
 966                         dmacmd[1] = setup_dmaspeed[indx];
 967                         aha1542_intr_reset(base_io);
 968                         aha1542_out(base_io, dmacmd, 2);
 969                         WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
 970                       }
 971                     while (0) {
 972                     fail:
 973                             printk("aha1542_detect: setting bus on/off-time failed\n");
 974                     }
 975                     aha1542_intr_reset(base_io);
 976             }
 977                     if(aha1542_query(base_io, &trans))  goto unregister;
 978                     
 979                     if (aha1542_getconfig(base_io, &irq_level, &dma_chan) == -1)  goto unregister;
 980                     
 981                     printk("Configuring Adaptec at IO:%x, IRQ %d",base_io, irq_level);
 982                     if (dma_chan != 0xFF)
 983                             printk(", DMA priority %d", dma_chan);
 984                     printk("\n");
 985                     
 986                     DEB(aha1542_stat());
 987                     setup_mailboxes(base_io, shpnt);
 988                     
 989                     DEB(aha1542_stat());
 990                     
 991                     DEB(printk("aha1542_detect: enable interrupt channel %d\n", irq_level));
 992                     save_flags(flags);
 993                     cli();
 994                     if (request_irq(irq_level,aha1542_intr_handle, 0, "aha1542")) {
 995                             printk("Unable to allocate IRQ for adaptec controller.\n");
 996                             goto unregister;
 997                     }
 998                     
 999                     if (dma_chan != 0xFF) {
1000                             if (request_dma(dma_chan,"aha1542")) {
1001                                     printk("Unable to allocate DMA channel for Adaptec.\n");
1002                                     free_irq(irq_level);
1003                                     goto unregister;
1004                             }
1005                             
1006                             if (dma_chan >= 5) {
1007                                     outb((dma_chan - 4) | CASCADE, DMA_MODE_REG);
1008                                     outb(dma_chan - 4, DMA_MASK_REG);
1009                             }
1010                     }
1011                     aha_host[irq_level - 9] = shpnt;
1012                     shpnt->io_port = base_io;
1013                     shpnt->n_io_port = 4;  /* Number of bytes of I/O space used */
1014                     shpnt->dma_channel = dma_chan;
1015                     shpnt->irq = irq_level;
1016                     HOSTDATA(shpnt)->bios_translation  = trans;
1017                     if(trans == 2) 
1018                       printk("aha1542.c: Using extended bios translation\n");
1019                     HOSTDATA(shpnt)->aha1542_last_mbi_used  = (2*AHA1542_MAILBOXES - 1);
1020                     HOSTDATA(shpnt)->aha1542_last_mbo_used  = (AHA1542_MAILBOXES - 1);
1021                     memset(HOSTDATA(shpnt)->SCint, 0, sizeof(HOSTDATA(shpnt)->SCint));
1022                     restore_flags(flags);
1023 #if 0
1024                     DEB(printk(" *** READ CAPACITY ***\n"));
1025                     
1026             {
1027                     unchar buf[8];
1028                     static unchar cmd[] = {     READ_CAPACITY, 0, 0, 0, 0, 0, 0, 0, 0, 0};
1029                     int i;
1030                     
1031                     for (i = 0; i < sizeof(buf); ++i) buf[i] = 0x87;
1032                     for (i = 0; i < 2; ++i)
1033                             if (!aha1542_command(i, cmd, buf, sizeof(buf))) {
1034                                     printk("aha_detect: LU %d sector_size %d device_size %d\n",
1035                                            i, xscsi2int(buf+4), xscsi2int(buf));
1036                             }
1037             }
1038                     
1039                     DEB(printk(" *** NOW RUNNING MY OWN TEST *** \n"));
1040                     
1041                     for (i = 0; i < 4; ++i)
1042                     {
1043                             unsigned char cmd[10];
1044                             static buffer[512];
1045                             
1046                             cmd[0] = READ_10;
1047                             cmd[1] = 0;
1048                             xany2scsi(cmd+2, i);
1049                             cmd[6] = 0;
1050                             cmd[7] = 0;
1051                             cmd[8] = 1;
1052                             cmd[9] = 0;
1053                             aha1542_command(0, cmd, buffer, 512);
1054                     }
1055 #endif    
1056                     request_region(bases[indx], 4,"aha1542");  /* Register the IO ports that we use */
1057                     count++;
1058                     continue;
1059             unregister:
1060                     scsi_unregister(shpnt);
1061                     continue;
1062                     
1063             };
1064     return count;
1065 }
1066 
1067 static int aha1542_restart(struct Scsi_Host * shost)
     /*  */
1068 {
1069   int i;
1070   int count = 0;
1071 #if 0
1072   unchar ahacmd = CMD_START_SCSI;
1073 #endif
1074 
1075   for(i=0; i< AHA1542_MAILBOXES; i++)
1076    if(HOSTDATA(shost)->SCint[i] && 
1077       !(HOSTDATA(shost)->SCint[i]->device->soft_reset))
1078      {
1079 #if 0
1080         HOSTDATA(shost)->mb[i].status = 1; /* Indicate ready to restart... */
1081 #endif
1082         count++;
1083      }     
1084 
1085   printk("Potential to restart %d stalled commands...\n", count);
1086 #if 0
1087   /* start scsi command */
1088   if (count) aha1542_out(shost->io_port, &ahacmd, 1);
1089 #endif
1090   return 0;
1091 }
1092 
1093 /* The abort command does not leave the device in a clean state where
1094    it is available to be used again.  Until this gets worked out, we will
1095    leave it commented out.  */
1096 
1097 int aha1542_abort(Scsi_Cmnd * SCpnt)
     /*  */
1098 {
1099 #if 0
1100   unchar ahacmd = CMD_START_SCSI;
1101   unsigned long flags;
1102   struct mailbox * mb;
1103   int mbi, mbo, i;
1104 
1105   printk("In aha1542_abort: %x %x\n",
1106          inb(STATUS(SCpnt->host->io_port)),
1107          inb(INTRFLAGS(SCpnt->host->io_port)));
1108 
1109   save_flags(flags);
1110   cli();
1111   mb = HOSTDATA(SCpnt->host)->mb;
1112   mbi = HOSTDATA(SCpnt->host)->aha1542_last_mbi_used + 1;
1113   if (mbi >= 2*AHA1542_MAILBOXES) mbi = AHA1542_MAILBOXES;
1114   
1115   do{
1116     if(mb[mbi].status != 0) break;
1117     mbi++;
1118     if (mbi >= 2*AHA1542_MAILBOXES) mbi = AHA1542_MAILBOXES;
1119   } while (mbi != HOSTDATA(SCpnt->host)->aha1542_last_mbi_used);
1120   restore_flags(flags);
1121 
1122   if(mb[mbi].status) {
1123     printk("Lost interrupt discovered on irq %d - attempting to recover\n", 
1124            SCpnt->host->irq);
1125     aha1542_intr_handle(SCpnt->host->irq, NULL);
1126     return 0;
1127   }
1128 
1129   /* OK, no lost interrupt.  Try looking to see how many pending commands
1130      we think we have. */
1131 
1132   for(i=0; i< AHA1542_MAILBOXES; i++)
1133    if(HOSTDATA(SCpnt->host)->SCint[i])
1134      {
1135        if(HOSTDATA(SCpnt->host)->SCint[i] == SCpnt) {
1136          printk("Timed out command pending for %4.4x\n", SCpnt->request.dev);
1137          if (HOSTDATA(SCpnt->host)->mb[i].status) {
1138            printk("OGMB still full - restarting\n");
1139            aha1542_out(SCpnt->host->io_port, &ahacmd, 1);
1140          };
1141        } else
1142          printk("Other pending command %4.4x\n", SCpnt->request.dev);
1143      }
1144 
1145 #endif
1146 
1147     DEB(printk("aha1542_abort\n"));
1148 #if 0
1149     save_flags(flags);
1150     cli();
1151     for(mbo = 0; mbo < AHA1542_MAILBOXES; mbo++)
1152       if (SCpnt == HOSTDATA(SCpnt->host)->SCint[mbo]){
1153         mb[mbo].status = 2;  /* Abort command */
1154         aha1542_out(SCpnt->host->io_port, &ahacmd, 1); /* start scsi command */
1155         restore_flags(flags);
1156         break;
1157       };
1158 #endif
1159     return SCSI_ABORT_SNOOZE;
1160 }
1161 
1162 /* We do not implement a reset function here, but the upper level code
1163    assumes that it will get some kind of response for the command in
1164    SCpnt.  We must oblige, or the command will hang the scsi system.
1165    For a first go, we assume that the 1542 notifies us with all of the
1166    pending commands (it does implement soft reset, after all). */
1167 
1168 int aha1542_reset(Scsi_Cmnd * SCpnt)
     /*  */
1169 {
1170     unchar ahacmd = CMD_START_SCSI;
1171     int i;
1172 
1173     DEB(printk("aha1542_reset called\n"));
1174 #if 0
1175     /* This does a scsi reset for all devices on the bus */
1176     outb(SCRST, CONTROL(SCpnt->host->io_port));
1177 #else
1178     /* This does a selective reset of just the one device */
1179     /* First locate the ccb for this command */
1180     for(i=0; i< AHA1542_MAILBOXES; i++)
1181       if(HOSTDATA(SCpnt->host)->SCint[i] == SCpnt)
1182         {
1183           HOSTDATA(SCpnt->host)->ccb[i].op = 0x81;  /* BUS DEVICE RESET */
1184           /* Now tell the 1542 to flush all pending commands for this target */
1185           aha1542_out(SCpnt->host->io_port, &ahacmd, 1);
1186 
1187           /* Here is the tricky part.  What to do next.  Do we get an interrupt
1188              for the commands that we aborted with the specified target, or
1189              do we generate this on our own?  Try it without first and see
1190              what happens */
1191           printk("Sent BUS DEVICE RESET to target %d\n", SCpnt->target);
1192 
1193           /* If the first does not work, then try the second.  I think the
1194              first option is more likely to be correct. Free the command
1195              block for all commands running on this target... */
1196 #if 1
1197           for(i=0; i< AHA1542_MAILBOXES; i++)
1198             if(HOSTDATA(SCpnt->host)->SCint[i] &&
1199                HOSTDATA(SCpnt->host)->SCint[i]->target == SCpnt->target)
1200             {
1201               Scsi_Cmnd * SCtmp;
1202               SCtmp = HOSTDATA(SCpnt->host)->SCint[i];
1203               SCtmp->result = DID_RESET << 16;
1204               if (SCtmp->host_scribble) scsi_free(SCtmp->host_scribble, 512);
1205               printk("Sending DID_RESET for target %d\n", SCpnt->target);
1206               SCtmp->scsi_done(SCpnt);
1207               
1208               HOSTDATA(SCpnt->host)->SCint[i] = NULL;
1209               HOSTDATA(SCpnt->host)->mb[i].status = 0;
1210             }
1211           return SCSI_RESET_SUCCESS;
1212 #else
1213           return SCSI_RESET_PENDING;
1214 #endif
1215         }
1216 
1217 #endif
1218     /* No active command at this time, so this means that each time we got
1219        some kind of response the last time through.  Tell the mid-level code
1220        to request sense information in order to decide what to do next. */
1221     return SCSI_RESET_PUNT;
1222 }
1223 
1224 #include "sd.h"
1225 
1226 int aha1542_biosparam(Scsi_Disk * disk, int dev, int * ip)
     /*  */
1227 {
1228   int translation_algorithm;
1229   int size = disk->capacity;
1230 
1231   translation_algorithm = HOSTDATA(disk->device->host)->bios_translation;
1232   /* Should this be > 1024, or >= 1024?  Enquiring minds want to know. */
1233   if((size>>11) > 1024 && translation_algorithm == 2) {
1234     /* Please verify that this is the same as what DOS returns */
1235     ip[0] = 255;
1236     ip[1] = 63;
1237     ip[2] = size /255/63;
1238   } else {
1239     ip[0] = 64;
1240     ip[1] = 32;
1241     ip[2] = size >> 11;
1242   };
1243 /*  if (ip[2] >= 1024) ip[2] = 1024; */
1244   return 0;
1245 }
1246 
1247 
1248 #ifdef MODULE
1249 /* Eventually this will go into an include file, but this will be later */
1250 Scsi_Host_Template driver_template = AHA1542;
1251 
1252 #include "scsi_module.c"
1253 #endif
1254
/* */
root/drivers/scsi/aha1542.c

DEFINITIONS
