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

DEFINITIONS
