home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / KERNEL-S / V1.2 / LINUX-1.2 / LINUX-1 / linux / drivers / scsi / aha274x.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-16  |  39.5 KB  |  1,491 lines
  1. /*
  2.  *  @(#)aha274x.c 1.29 94/10/29 jda
  3.  *
  4.  *  Adaptec 274x device driver for Linux.
  5.  *  Copyright (c) 1994 The University of Calgary Department of Computer Science.
  6.  *  
  7.  *  This program is free software; you can redistribute it and/or modify
  8.  *  it under the terms of the GNU General Public License as published by
  9.  *  the Free Software Foundation; either version 2 of the License, or
  10.  *  (at your option) any later version.
  11.  *  
  12.  *  This program is distributed in the hope that it will be useful,
  13.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.  *  GNU General Public License for more details.
  16.  *  
  17.  *  You should have received a copy of the GNU General Public License
  18.  *  along with this program; if not, write to the Free Software
  19.  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20.  *
  21.  *  Sources include the Adaptec 1740 driver (aha1740.c), the
  22.  *  Ultrastor 24F driver (ultrastor.c), various Linux kernel
  23.  *  source, the Adaptec EISA config file (!adp7771.cfg), the
  24.  *  Adaptec AHA-2740A Series User's Guide, the Linux Kernel
  25.  *  Hacker's Guide, Writing a SCSI Device Driver for Linux,
  26.  *  the Adaptec 1542 driver (aha1542.c), the Adaptec EISA
  27.  *  overlay file (adp7770.ovl), the Adaptec AHA-2740 Series
  28.  *  Technical Reference Manual, the Adaptec AIC-7770 Data
  29.  *  Book, the ANSI SCSI specification, the ANSI SCSI-2
  30.  *  specification (draft 10c), ...
  31.  *
  32.  *  On a twin-bus adapter card, channel B is ignored.  Rationale:
  33.  *  it would greatly complicate the sequencer and host driver code,
  34.  *  and both busses are multiplexed on to the EISA bus anyway.  So
  35.  *  I don't really see any technical advantage to supporting both.
  36.  *
  37.  *  As well, multiple adapter card using the same IRQ level are
  38.  *  not supported.  It doesn't make sense to configure the cards
  39.  *  this way from a performance standpoint.  Not to mention that
  40.  *  the kernel would have to support two devices per registered IRQ.
  41.  */
  42.  
  43. #include <stdarg.h>
  44. #include <asm/io.h>
  45. #include <linux/string.h>
  46. #include <linux/kernel.h>
  47. #include <linux/ioport.h>
  48. #include <linux/delay.h>
  49.  
  50. #include "../block/blk.h"
  51. #include "sd.h"
  52. #include "scsi.h"
  53. #include "hosts.h"
  54. #include "aha274x.h"
  55.  
  56. /*
  57.  *  There should be a specific return value for this in scsi.h, but
  58.  *  it seems that most drivers ignore it.
  59.  */
  60. #define DID_UNDERFLOW    DID_ERROR
  61.  
  62. /* EISA stuff */
  63.  
  64. #define MINEISA        1
  65. #define MAXEISA        15
  66. #define SLOTBASE(x)    ((x) << 12)
  67.  
  68. #define MAXIRQ        15
  69.  
  70. /* AIC-7770 offset definitions */
  71.  
  72. #define O_MINREG(x)    ((x) + 0xc00)        /* i/o range to reserve */
  73. #define O_MAXREG(x)    ((x) + 0xcbf)
  74.  
  75. #define O_SCSISEQ(x)    ((x) + 0xc00)        /* scsi sequence control */
  76. #define O_SCSISIGI(x)    ((x) + 0xc03)        /* scsi control signal read */
  77. #define O_SCSISIGO(x)    ((x) + 0xc03)        /* scsi control signal write */
  78. #define O_SCSIID(x)    ((x) + 0xc05)        /* scsi id */
  79. #define O_SSTAT0(x)    ((x) + 0xc0b)        /* scsi status register 0 */
  80. #define O_CLRSINT1(x)    ((x) + 0xc0c)        /* clear scsi interrupt 1 */
  81. #define O_SSTAT1(x)    ((x) + 0xc0c)        /* scsi status register 1 */
  82. #define O_SELID(x)    ((x) + 0xc19)        /* [re]selection id */
  83. #define O_SBLKCTL(x)    ((x) + 0xc1f)        /* scsi block control */
  84. #define O_SEQCTL(x)    ((x) + 0xc60)        /* sequencer control */
  85. #define O_SEQRAM(x)    ((x) + 0xc61)        /* sequencer ram data */
  86. #define O_SEQADDR(x)    ((x) + 0xc62)        /* sequencer address (W) */
  87. #define O_BIDx(x)    ((x) + 0xc80)        /* board id */
  88. #define O_BCTL(x)    ((x) + 0xc84)        /* board control */
  89. #define O_HCNTRL(x)    ((x) + 0xc87)        /* host control */
  90. #define O_SCBPTR(x)    ((x) + 0xc90)        /* scb pointer */
  91. #define O_INTSTAT(x)    ((x) + 0xc91)        /* interrupt status */
  92. #define O_ERROR(x)    ((x) + 0xc92)        /* hard error */
  93. #define O_CLRINT(x)    ((x) + 0xc92)        /* clear interrupt status */
  94. #define O_SCBCNT(x)    ((x) + 0xc9a)        /* scb auto increment */
  95. #define O_QINFIFO(x)    ((x) + 0xc9b)        /* queue in fifo */
  96. #define O_QINCNT(x)    ((x) + 0xc9c)        /* queue in count */
  97. #define O_QOUTFIFO(x)    ((x) + 0xc9d)        /* queue out fifo */
  98. #define O_QOUTCNT(x)    ((x) + 0xc9e)        /* queue out count */
  99. #define O_SCBARRAY(x)    ((x) + 0xca0)        /* scb array start */
  100.  
  101. /* host adapter offset definitions */
  102.  
  103. #define HA_REJBYTE(x)    ((x) + 0xc31)        /* 1st message in byte */
  104. #define HA_MSG_FLAGS(x)    ((x) + 0xc35)        /* outgoing message flag */
  105. #define HA_MSG_LEN(x)    ((x) + 0xc36)        /* outgoing message length */
  106. #define HA_MSG_START(x)    ((x) + 0xc37)        /* outgoing message body */
  107. #define HA_ARG_1(x)    ((x) + 0xc4c)        /* sdtr <-> rate parameters */
  108. #define HA_ARG_2(x)    ((x) + 0xc4d)
  109. #define HA_RETURN_1(x)    ((x) + 0xc4c)
  110. #define HA_RETURN_2(x)    ((x) + 0xc4d)
  111. #define HA_SIGSTATE(x)    ((x) + 0xc4e)        /* value in SCSISIGO */
  112. #define HA_NEEDSDTR(x)    ((x) + 0xc4f)        /* synchronous negotiation? */
  113.  
  114. #define HA_SCSICONF(x)    ((x) + 0xc5a)        /* SCSI config register */
  115. #define HA_INTDEF(x)    ((x) + 0xc5c)        /* interrupt def'n register */
  116. #define HA_HOSTCONF(x)    ((x) + 0xc5d)        /* host config def'n register */
  117.  
  118. /* debugging code */
  119.  
  120. #define AHA274X_DEBUG
  121.  
  122. /*
  123.  *  If a parity error occurs during a data transfer phase, run the
  124.  *  command to completion - it's easier that way - making a note
  125.  *  of the error condition in this location.  This then will modify
  126.  *  a DID_OK status into a DID_PARITY one for the higher-level SCSI
  127.  *  code.
  128.  */
  129. #define aha274x_parity(cmd)    ((cmd)->SCp.Status)
  130.  
  131. /*
  132.  *  Since the sequencer code DMAs the scatter-gather structures
  133.  *  directly from memory, we use this macro to assert that the
  134.  *  kernel structure hasn't changed.
  135.  */
  136. #define SG_STRUCT_CHECK(sg) \
  137.     ((char *)&(sg).address - (char *)&(sg) != 0 ||    \
  138.      (char *)&(sg).length  - (char *)&(sg) != 8 ||    \
  139.      sizeof((sg).address) != 4 ||            \
  140.      sizeof((sg).length)  != 4 ||            \
  141.      sizeof(sg)          != 12)
  142.  
  143. /*
  144.  *  "Static" structures.  Note that these are NOT initialized
  145.  *  to zero inside the kernel - we have to initialize them all
  146.  *  explicitly.
  147.  *
  148.  *  We support a maximum of one adapter card per IRQ level (see the
  149.  *  rationale for this above).  On an interrupt, use the IRQ as an
  150.  *  index into aha274x_boards[] to locate the card information.
  151.  */
  152. static struct Scsi_Host *aha274x_boards[MAXIRQ + 1];
  153.  
  154. struct aha274x_host {
  155.     int base;                    /* card base address */
  156.     int startup;                    /* intr type check */
  157.     volatile int unpause;                /* value for HCNTRL */
  158.     volatile Scsi_Cmnd *SCB_array[AHA274X_MAXSCB];    /* active commands */
  159. };
  160.  
  161. struct aha274x_scb {
  162.     unsigned char control;
  163.     unsigned char target_channel_lun;        /* 4/1/3 bits */
  164.     unsigned char SG_segment_count;
  165.     unsigned char SG_list_pointer[4];
  166.     unsigned char SCSI_cmd_pointer[4];
  167.     unsigned char SCSI_cmd_length;
  168.     unsigned char RESERVED[2];            /* must be zero */
  169.     unsigned char target_status;
  170.     unsigned char residual_data_count[3];
  171.     unsigned char residual_SG_segment_count;
  172.     unsigned char data_pointer[4];
  173.     unsigned char data_count[3];
  174. #if 0
  175.     /*
  176.      *  No real point in transferring this to the
  177.      *  SCB registers.
  178.      */
  179.     unsigned char RESERVED[6];
  180. #endif
  181. };
  182.  
  183. /*
  184.  *  NB.  This table MUST be ordered shortest period first.
  185.  */
  186. static struct {
  187.     short period;
  188.     short rate;
  189.     char *english;
  190. } aha274x_synctab[] = {
  191.     {100,    0,    "10.0"},
  192.     {125,    1,    "8.0"},
  193.     {150,    2,    "6.67"},
  194.     {175,    3,    "5.7"},
  195.     {200,    4,    "5.0"},
  196.     {225,    5,    "4.4"},
  197.     {250,    6,    "4.0"},
  198.     {275,    7,    "3.6"}
  199. };
  200.  
  201. static int aha274x_synctab_max =
  202.     sizeof(aha274x_synctab) / sizeof(aha274x_synctab[0]);
  203.  
  204. enum aha_type {
  205.     T_NONE,
  206.     T_274X,
  207.     T_284X,
  208.     T_MAX
  209. };
  210.  
  211. #ifdef AHA274X_DEBUG
  212.  
  213.     extern int vsprintf(char *, const char *, va_list);
  214.  
  215.     static
  216.     void debug(const char *fmt, ...)
  217.     {
  218.         va_list ap;
  219.         char buf[256];
  220.  
  221.         va_start(ap, fmt);
  222.           vsprintf(buf, fmt, ap);
  223.           printk(buf);
  224.         va_end(ap);
  225.     }
  226.  
  227.     static
  228.     void debug_config(enum aha_type type, int base)
  229.     {
  230.         int ioport2, ioport3, ioport4;
  231.  
  232.         static char *BRT[T_MAX][16] = {
  233.             { },                    /* T_NONE */
  234.             {
  235.                 "2",   "???", "???", "12",    /* T_274X */
  236.                 "???", "???", "???", "28",
  237.                 "???", "???", "???", "44",
  238.                 "???", "???", "???", "60"
  239.             },
  240.             {
  241.                 "2",  "4",  "8",  "12",        /* T_284X */
  242.                 "16", "20", "24", "28",
  243.                 "32", "36", "40", "44",
  244.                 "48", "52", "56", "60"
  245.             }
  246.         };
  247.         static int DFT[4] = {
  248.             0, 50, 75, 100
  249.         };
  250.         static int SST[4] = {
  251.             256, 128, 64, 32
  252.         };
  253.  
  254.         ioport2 = inb(HA_HOSTCONF(base));
  255.         ioport3 = inb(HA_SCSICONF(base));
  256.         ioport4 = inb(HA_INTDEF(base));
  257.  
  258.         if (type == T_284X)
  259.             printk("AHA284X AT SLOT %d:\n", base >> 12);
  260.         else
  261.             printk("AHA274X AT EISA SLOT %d:\n", base >> 12);
  262.  
  263.         printk("    irq %d\n"
  264.                "    bus release time %s bclks\n"
  265.                "    data fifo threshold %d%%\n",
  266.                ioport4 & 0xf,
  267.                BRT[type][(ioport2 >> 2) & 0xf],
  268.                DFT[(ioport2 >> 6) & 0x3]);
  269.  
  270.         printk("    SCSI CHANNEL A:\n"
  271.                "        scsi id %d\n"
  272.                "        scsi bus parity check %sabled\n"
  273.                "        scsi selection timeout %d ms\n"
  274.                "        scsi bus reset at power-on %sabled\n",
  275.                ioport3 & 0x7,
  276.                (ioport3 & 0x20) ? "en" : "dis",
  277.                SST[(ioport3 >> 3) & 0x3],
  278.                (ioport3 & 0x40) ? "en" : "dis");
  279.  
  280.         if (type == T_274X) {
  281.             printk("        scsi bus termination %sabled\n",
  282.                    (ioport3 & 0x80) ? "en" : "dis");
  283.         }
  284.     }
  285.  
  286.     static
  287.     void debug_rate(int base, int rate)
  288.     {
  289.         int target = inb(O_SCSIID(base)) >> 4;
  290.  
  291.         if (rate) {
  292.             printk("aha274x: target %d now synchronous at %sMb/s\n",
  293.                    target,
  294.                    aha274x_synctab[(rate >> 4) & 0x7].english);
  295.         } else {
  296.             printk("aha274x: target %d using asynchronous mode\n",
  297.                    target);
  298.         }
  299.     }
  300.  
  301. #else
  302.  
  303. #    define debug(fmt, args...)
  304. #    define debug_config(x)
  305. #    define debug_rate(x,y)
  306.  
  307. #endif AHA274X_DEBUG
  308.  
  309. /*
  310.  *  XXX - these options apply unilaterally to _all_ 274x/284x
  311.  *      cards in the system.  This should be fixed, but then,
  312.  *      does anyone really have more than one in a machine?
  313.  */
  314. static int aha274x_extended = 0;        /* extended translation on? */
  315.  
  316. void aha274x_setup(char *s, int *dummy)
  317. {
  318.     int i;
  319.     char *p;
  320.  
  321.     static struct {
  322.         char *name;
  323.         int *flag;
  324.     } options[] = {
  325.         {"extended",    &aha274x_extended},
  326.         {NULL, NULL }
  327.     };
  328.  
  329.     for (p = strtok(s, ","); p; p = strtok(NULL, ",")) {
  330.         for (i = 0; options[i].name; i++)
  331.             if (!strcmp(options[i].name, p))
  332.                 *(options[i].flag) = !0;
  333.     }
  334. }
  335.  
  336. static
  337. void aha274x_getscb(int base, struct aha274x_scb *scb)
  338. {
  339.     /*
  340.      *  This is almost identical to aha274x_putscb().
  341.      */
  342.     outb(0x80, O_SCBCNT(base));    /* SCBAUTO */
  343.  
  344.     asm volatile("cld\n\t"
  345.              "rep\n\t"
  346.              "insb"
  347.              : /* no output */
  348.              :"D" (scb), "c" (sizeof(*scb)), "d" (O_SCBARRAY(base))
  349.              :"di", "cx", "dx");
  350.  
  351.     outb(0, O_SCBCNT(base));
  352. }
  353.  
  354. /*
  355.  *  How much data should be transferred for this SCSI command?  Stop
  356.  *  at segment sg_last if it's a scatter-gather command so we can
  357.  *  compute underflow easily.
  358.  */
  359. static
  360. unsigned aha274x_length(Scsi_Cmnd *cmd, int sg_last)
  361. {
  362.     int i, segments;
  363.     unsigned length;
  364.     struct scatterlist *sg;
  365.  
  366.     segments = cmd->use_sg - sg_last;
  367.     sg = (struct scatterlist *)cmd->buffer;
  368.  
  369.     if (cmd->use_sg) {
  370.         for (i = length = 0;
  371.              i < cmd->use_sg && i < segments;
  372.              i++)
  373.         {
  374.             length += sg[i].length;
  375.         }
  376.     } else
  377.         length = cmd->request_bufflen;
  378.  
  379.     return(length);
  380. }
  381.  
  382. static
  383. void aha274x_sg_check(Scsi_Cmnd *cmd)
  384. {
  385.     int i;
  386.     struct scatterlist *sg = (struct scatterlist *)cmd->buffer;
  387.  
  388.     if (cmd->use_sg) {
  389.         for (i = 0; i < cmd->use_sg; i++)
  390.             if ((unsigned)sg[i].length > 0xffff)
  391.                 panic("aha274x_sg_check: s/g segment > 64k\n");
  392.     }
  393. }
  394.  
  395. static
  396. void aha274x_to_scsirate(unsigned char *rate,
  397.              unsigned char transfer,
  398.              unsigned char offset)
  399. {
  400.     int i;
  401.  
  402.     transfer *= 4;
  403.  
  404.     for (i = 0; i < aha274x_synctab_max-1; i++) {
  405.  
  406.         if (transfer == aha274x_synctab[i].period) {
  407.             *rate = (aha274x_synctab[i].rate << 4) | (offset & 0xf);
  408.             return;
  409.         }
  410.  
  411.         if (transfer > aha274x_synctab[i].period &&
  412.             transfer < aha274x_synctab[i+1].period)
  413.         {
  414.             *rate = (aha274x_synctab[i+1].rate << 4) |
  415.                 (offset & 0xf);
  416.             return;
  417.         }
  418.     }
  419.     *rate = 0;
  420. }
  421.  
  422. /*
  423.  *  Pause the sequencer and wait for it to actually stop - this
  424.  *  is important since the sequencer can disable pausing for critical
  425.  *  sections.
  426.  */
  427. #define PAUSE_SEQUENCER(p)    \
  428.     do {                                \
  429.         outb(0xe, O_HCNTRL(p->base));    /* IRQMS|PAUSE|INTEN */    \
  430.                                     \
  431.         while ((inb(O_HCNTRL(p->base)) & 0x4) == 0)        \
  432.             ;                        \
  433.     } while (0)
  434.  
  435. /*
  436.  *  Unpause the sequencer.  Unremarkable, yet done often enough to
  437.  *  warrant an easy way to do it.
  438.  */
  439. #define UNPAUSE_SEQUENCER(p)    \
  440.     outb(p->unpause, O_HCNTRL(p->base))    /* IRQMS|INTEN */
  441.  
  442. /*
  443.  *  See comments in aha274x_loadram() wrt this.
  444.  */
  445. #define RESTART_SEQUENCER(p)    \
  446.     do {                        \
  447.         do {                    \
  448.             outb(0x2, O_SEQCTL(p->base));    \
  449.         } while (inw(O_SEQADDR(p->base)) != 0);    \
  450.                             \
  451.         UNPAUSE_SEQUENCER(p);            \
  452.     } while (0)
  453.  
  454. /*
  455.  *  Since we declared this using SA_INTERRUPT, interrupts should
  456.  *  be disabled all through this function unless we say otherwise.
  457.  */
  458. static
  459. void aha274x_isr(int irq, struct pt_regs * regs)
  460. {
  461.     int base, intstat;
  462.     struct aha274x_host *p;
  463.     
  464.     p = (struct aha274x_host *)aha274x_boards[irq]->hostdata;
  465.     base = p->base;
  466.  
  467.     /*
  468.      *  Check the startup flag - if no commands have been queued,
  469.      *  we probably have the interrupt type set wrong.  Reverse
  470.      *  the stored value and the active one in the host control
  471.      *  register.
  472.      */
  473.     if (p->startup) {
  474.         p->unpause ^= 0x8;
  475.         outb(inb(O_HCNTRL(p->base)) ^ 0x8, O_HCNTRL(p->base));
  476.         return;
  477.     }
  478.  
  479.     /*
  480.      *  Handle all the interrupt sources - especially for SCSI
  481.      *  interrupts, we won't get a second chance at them.
  482.      */
  483.     intstat = inb(O_INTSTAT(base));
  484.  
  485.     if (intstat & 0x8) {                /* BRKADRINT */
  486.  
  487.         panic("aha274x_isr: brkadrint, error = 0x%x, seqaddr = 0x%x\n",
  488.               inb(O_ERROR(base)), inw(O_SEQADDR(base)));
  489.     }
  490.  
  491.     if (intstat & 0x4) {                /* SCSIINT */
  492.  
  493.         int scbptr = inb(O_SCBPTR(base));
  494.         int status = inb(O_SSTAT1(base));
  495.         Scsi_Cmnd *cmd;
  496.  
  497.         cmd = (Scsi_Cmnd *)p->SCB_array[scbptr];
  498.         if (!cmd) {
  499.             printk("aha274x_isr: no command for scb (scsiint)\n");
  500.             /*
  501.              *  Turn off the interrupt and set status
  502.              *  to zero, so that it falls through the
  503.              *  reset of the SCSIINT code.
  504.              */
  505.             outb(status, O_CLRSINT1(base));
  506.             UNPAUSE_SEQUENCER(p);
  507.             outb(0x4, O_CLRINT(base));    /* undocumented */
  508.             status = 0;
  509.         }
  510.         p->SCB_array[scbptr] = NULL;
  511.  
  512.         /*
  513.          *  Only the SCSI Status 1 register has information
  514.          *  about exceptional conditions that we'd have a
  515.          *  SCSIINT about; anything in SSTAT0 will be handled
  516.          *  by the sequencer.  Note that there can be multiple
  517.          *  bits set.
  518.          */
  519.         if (status & 0x80) {            /* SELTO */
  520.             /*
  521.              *  Hardware selection timer has expired.  Turn
  522.              *  off SCSI selection sequence.
  523.              */
  524.             outb(0, O_SCSISEQ(base));
  525.             cmd->result = DID_TIME_OUT << 16;
  526.  
  527.             /*
  528.              *  If there's an active message, it belongs to the
  529.              *  command that is getting punted - remove it.
  530.              */
  531.             outb(0, HA_MSG_FLAGS(base));
  532.  
  533.             /*
  534.              *  Shut off the offending interrupt sources, reset
  535.              *  the sequencer address to zero and unpause it,
  536.              *  then call the high-level SCSI completion routine.
  537.              *
  538.              *  WARNING!  This is a magic sequence!  After many
  539.              *  hours of guesswork, turning off the SCSI interrupts
  540.              *  in CLRSINT? does NOT clear the SCSIINT bit in
  541.              *  INTSTAT.  By writing to the (undocumented, unused
  542.              *  according to the AIC-7770 manual) third bit of
  543.              *  CLRINT, you can clear INTSTAT.  But, if you do it
  544.              *  while the sequencer is paused, you get a BRKADRINT
  545.              *  with an Illegal Host Address status, so the
  546.              *  sequencer has to be restarted first.
  547.              */
  548.             outb(0x80, O_CLRSINT1(base));    /* CLRSELTIMO */
  549.             RESTART_SEQUENCER(p);
  550.  
  551.             outb(0x4, O_CLRINT(base));    /* undocumented */
  552.             cmd->scsi_done(cmd);
  553.         }
  554.  
  555.         if (status & 0x4) {            /* SCSIPERR */
  556.             /*
  557.              *  A parity error has occurred during a data
  558.              *  transfer phase.  Flag it and continue.
  559.              */
  560.             printk("aha274x: parity error on target %d, lun %d\n",
  561.                    cmd->target,
  562.                    cmd->lun);
  563.             aha274x_parity(cmd) = DID_PARITY;
  564.  
  565.             /*
  566.              *  Clear interrupt and resume as above.
  567.              */
  568.             outb(0x4, O_CLRSINT1(base));    /* CLRSCSIPERR */
  569.             UNPAUSE_SEQUENCER(p);
  570.  
  571.             outb(0x4, O_CLRINT(base));    /* undocumented */
  572.         }
  573.  
  574.         if ((status & (0x8|0x4)) == 0 && status) {
  575.             /*
  576.              *  We don't know what's going on.  Turn off the
  577.              *  interrupt source and try to continue.
  578.              */
  579.             printk("aha274x_isr: sstat1 = 0x%x\n", status);
  580.             outb(status, O_CLRSINT1(base));
  581.             UNPAUSE_SEQUENCER(p);
  582.             outb(0x4, O_CLRINT(base));    /* undocumented */
  583.         }
  584.     }
  585.  
  586.     if (intstat & 0x2) {                /* CMDCMPLT */
  587.  
  588.         int complete, old_scbptr;
  589.         struct aha274x_scb scb;
  590.         unsigned actual;
  591.         Scsi_Cmnd *cmd;
  592.  
  593.         /*
  594.          *  The sequencer will continue running when it
  595.          *  issues this interrupt.  There may be >1 commands
  596.          *  finished, so loop until we've processed them all.
  597.          */
  598.         do {
  599.             complete = inb(O_QOUTFIFO(base));
  600.  
  601.             cmd = (Scsi_Cmnd *)p->SCB_array[complete];
  602.             if (!cmd) {
  603.                 printk("aha274x warning: "
  604.                        "no command for scb (cmdcmplt)\n");
  605.                 continue;
  606.             }
  607.             p->SCB_array[complete] = NULL;
  608.             
  609.             PAUSE_SEQUENCER(p);
  610.  
  611.             /*
  612.              *  After pausing the sequencer (and waiting
  613.              *  for it to stop), save its SCB pointer, then
  614.              *  write in our completed one and read the SCB
  615.              *  registers.  Afterwards, restore the saved
  616.              *  pointer, unpause the sequencer and call the
  617.              *  higher-level completion function - unpause
  618.              *  first since we have no idea how long done()
  619.              *  will take.
  620.              */
  621.             old_scbptr = inb(O_SCBPTR(base));
  622.             outb(complete, O_SCBPTR(base));
  623.  
  624.             aha274x_getscb(base, &scb);
  625.             outb(old_scbptr, O_SCBPTR(base));
  626.  
  627.             UNPAUSE_SEQUENCER(p);
  628.  
  629.             cmd->result = scb.target_status |
  630.                      (aha274x_parity(cmd) << 16);
  631.  
  632.             /*
  633.              *  Did we underflow?  At this time, there's only
  634.              *  one other driver that bothers to check for this,
  635.              *  and cmd->underflow seems to be set rather half-
  636.              *  heartedly in the higher-level SCSI code.
  637.              */
  638.             actual = aha274x_length(cmd,
  639.                         scb.residual_SG_segment_count);
  640.  
  641.             actual -= ((scb.residual_data_count[2] << 16) |
  642.                    (scb.residual_data_count[1] <<  8) |
  643.                    (scb.residual_data_count[0]));
  644.  
  645.             if (actual < cmd->underflow) {
  646.                 printk("aha274x: target %d underflow - "
  647.                        "wanted (at least) %u, got %u\n",
  648.                        cmd->target, cmd->underflow, actual);
  649.  
  650.                 cmd->result = scb.target_status |
  651.                          (DID_UNDERFLOW << 16);
  652.             }
  653.  
  654.             cmd->scsi_done(cmd);
  655.  
  656.             /*
  657.              *  Clear interrupt status before checking
  658.              *  the output queue again.  This eliminates
  659.              *  a race condition whereby a command could
  660.              *  complete between the queue poll and the
  661.              *  interrupt clearing, so notification of the
  662.              *  command being complete never made it back
  663.              *  up to the kernel.
  664.              */
  665.             outb(0x2, O_CLRINT(base));    /* CLRCMDINT */
  666.  
  667.         } while (inb(O_QOUTCNT(base)));
  668.     }
  669.  
  670.     if (intstat & 0x1) {                /* SEQINT */
  671.  
  672.         unsigned char transfer, offset, rate;
  673.  
  674.         /*
  675.          *  Although the sequencer is paused immediately on
  676.          *  a SEQINT, an interrupt for a SCSIINT or a CMDCMPLT
  677.          *  condition will have unpaused the sequencer before
  678.          *  this point.
  679.          */
  680.         PAUSE_SEQUENCER(p);
  681.  
  682.         switch (intstat & 0xf0) {
  683.             case 0x00:
  684.             panic("aha274x_isr: unknown scsi bus phase\n");
  685.             case 0x10:
  686.             debug("aha274x_isr warning: "
  687.                   "issuing message reject, 1st byte 0x%x\n",
  688.                   inb(HA_REJBYTE(base)));
  689.             break;
  690.             case 0x20:
  691.             panic("aha274x_isr: reconnecting target %d "
  692.                   "didn't issue IDENTIFY message\n",
  693.                   (inb(O_SELID(base)) >> 4) & 0xf);
  694.             case 0x30:
  695.             debug("aha274x_isr: sequencer couldn't find match "
  696.                   "for reconnecting target %d - issuing ABORT\n",
  697.                   (inb(O_SELID(base)) >> 4) & 0xf);
  698.             break;
  699.             case 0x40:
  700.             transfer = inb(HA_ARG_1(base));
  701.             offset = inb(HA_ARG_2(base));
  702.             aha274x_to_scsirate(&rate, transfer, offset);
  703.             outb(rate, HA_RETURN_1(base));
  704.             debug_rate(base, rate);
  705.             break;
  706.             default:
  707.             debug("aha274x_isr: seqint, "
  708.                   "intstat = 0x%x, scsisigi = 0x%x\n",
  709.                   intstat, inb(O_SCSISIGI(base)));
  710.             break;
  711.         }
  712.  
  713.         outb(0x1, O_CLRINT(base));        /* CLRSEQINT */
  714.         UNPAUSE_SEQUENCER(p);
  715.     }
  716. }
  717.  
  718. /*
  719.  *  Probing for EISA boards: it looks like the first two bytes
  720.  *  are a manufacturer code - three characters, five bits each:
  721.  *
  722.  *         BYTE 0   BYTE 1   BYTE 2   BYTE 3
  723.  *        ?1111122 22233333 PPPPPPPP RRRRRRRR
  724.  *
  725.  *  The characters are baselined off ASCII '@', so add that value
  726.  *  to each to get the real ASCII code for it.  The next two bytes
  727.  *  appear to be a product and revision number, probably vendor-
  728.  *  specific.  This is what is being searched for at each port,
  729.  *  and what should probably correspond to the ID= field in the
  730.  *  ECU's .cfg file for the card - if your card is not detected,
  731.  *  make sure your signature is listed in the array.
  732.  *
  733.  *  The fourth byte's lowest bit seems to be an enabled/disabled
  734.  *  flag (rest of the bits are reserved?).
  735.  */
  736.  
  737. static
  738. enum aha_type aha274x_probe(int slot, int s_base)
  739. {
  740.     int i;
  741.     unsigned char buf[4];
  742.  
  743.     static struct {
  744.         int n;
  745.         unsigned char signature[sizeof(buf)];
  746.         enum aha_type type;
  747.     } S[] = {
  748.         {4, { 0x04, 0x90, 0x77, 0x71 }, T_274X},    /* host adapter 274x */
  749.         {4, { 0x04, 0x90, 0x77, 0x70 }, T_274X},    /* motherboard 274x  */
  750.         {4, { 0x04, 0x90, 0x77, 0x56 }, T_284X},    /* 284x, BIOS enabled */
  751.     };
  752.  
  753.     for (i = 0; i < sizeof(buf); i++) {
  754.         /*
  755.          *  The VL-bus cards need to be primed by
  756.          *  writing before a signature check.
  757.          */
  758.         outb(0x80 + i, s_base);
  759.         buf[i] = inb(s_base + i);
  760.     }
  761.  
  762.     for (i = 0; i < sizeof(S)/sizeof(S[0]); i++) {
  763.         if (!memcmp(buf, S[i].signature, S[i].n)) {
  764.             /*
  765.              *  Signature match on enabled card?
  766.              */
  767.             if (inb(s_base + 4) & 1)
  768.                 return(S[i].type);
  769.             printk("aha274x disabled at slot %d, ignored\n", slot);
  770.         }
  771.     }
  772.     return(T_NONE);
  773. }
  774.  
  775. /*
  776.  *  Return ' ' for plain 274x, 'T' for twin-channel, 'W' for
  777.  *  wide channel, '?' for anything else.
  778.  */
  779.  
  780. static
  781. char aha274x_type(int base)
  782. {
  783.     /*
  784.      *  The AIC-7770 can be wired so that, on chip reset,
  785.      *  the SCSI Block Control register indicates how many
  786.      *  busses the chip is configured for.
  787.      */
  788.     switch (inb(O_SBLKCTL(base))) {
  789.         case 0:
  790.         return(' ');
  791.         case 2:
  792.         return('W');
  793.         case 8:
  794.         return('T');
  795.         default:
  796.         printk("aha274x has unknown bus configuration\n");
  797.         return('?');
  798.     }
  799. }
  800.  
  801. static
  802. void aha274x_loadram(int base)
  803. {
  804.     static unsigned char seqprog[] = {
  805.         /*
  806.          *  Each sequencer instruction is 29 bits
  807.          *  long (fill in the excess with zeroes)
  808.          *  and has to be loaded from least -> most
  809.          *  significant byte, so this table has the
  810.          *  byte ordering reversed.
  811.          */
  812. #        include "aha274x_seq.h"
  813.     };
  814.  
  815.     /*
  816.      *  When the AIC-7770 is paused (as on chip reset), the
  817.      *  sequencer address can be altered and a sequencer
  818.      *  program can be loaded by writing it, byte by byte, to
  819.      *  the sequencer RAM port - the Adaptec documentation
  820.      *  recommends using REP OUTSB to do this, hence the inline
  821.      *  assembly.  Since the address autoincrements as we load
  822.      *  the program, reset it back to zero afterward.  Disable
  823.      *  sequencer RAM parity error detection while loading, and
  824.      *  make sure the LOADRAM bit is enabled for loading.
  825.      */
  826.     outb(0x83, O_SEQCTL(base));    /* PERRORDIS|SEQRESET|LOADRAM */
  827.  
  828.     asm volatile("cld\n\t"
  829.              "rep\n\t"
  830.              "outsb"
  831.              : /* no output */
  832.              :"S" (seqprog), "c" (sizeof(seqprog)), "d" (O_SEQRAM(base))
  833.              :"si", "cx", "dx");
  834.  
  835.     /*
  836.      *  WARNING!  This is a magic sequence!  After extensive
  837.      *  experimentation, it seems that you MUST turn off the
  838.      *  LOADRAM bit before you play with SEQADDR again, else
  839.      *  you will end up with parity errors being flagged on
  840.      *  your sequencer program.  (You would also think that
  841.      *  turning off LOADRAM and setting SEQRESET to reset the
  842.      *  address to zero would work, but you need to do it twice
  843.      *  for it to take effect on the address.  Timing problem?)
  844.      */
  845.     outb(0, O_SEQCTL(base));
  846.     do {
  847.         /*
  848.          *  Actually, reset it until
  849.          *  the address shows up as
  850.          *  zero just to be safe..
  851.          */
  852.         outb(0x2, O_SEQCTL(base));    /* SEQRESET */
  853.  
  854.     } while (inw(O_SEQADDR(base)) != 0);
  855. }
  856.  
  857. static
  858. int aha274x_register(Scsi_Host_Template *template,
  859.              enum aha_type type,
  860.              int base)
  861. {
  862.     int i, irq, scsi_id;
  863.     struct Scsi_Host *host;
  864.     struct aha274x_host *p;
  865.  
  866.     /*
  867.      *  Give the AIC-7770 a reset - reading the 274x's registers
  868.      *  returns zeroes unless you do.  This forces a pause of the
  869.      *  Sequencer.
  870.      */
  871.     outb(1, O_HCNTRL(base));    /* CHIPRST */
  872.  
  873.     /*
  874.      *  The IRQ level in i/o port 4 maps directly onto the real
  875.      *  IRQ number.  If it's ok, register it with the kernel.
  876.      *
  877.      *  NB. the Adaptec documentation says the IRQ number is only
  878.      *    in the lower four bits; the ECU information shows the
  879.      *    high bit being used as well.  Which is correct?
  880.      */
  881.     irq = inb(HA_INTDEF(base)) & 0xf;
  882.     if (irq < 9 || irq > 15) {
  883.         printk("aha274x uses unsupported IRQ level, ignoring\n");
  884.         return(0);
  885.     }
  886.     
  887.     /*
  888.      *  Lock out other contenders for our i/o space.
  889.      */
  890.     request_region(O_MINREG(base), O_MAXREG(base)-O_MINREG(base), "aha27x");
  891.  
  892.     /*
  893.      *  Any card-type-specific adjustments before we register
  894.      *  the scsi host(s).
  895.      */
  896.  
  897.     scsi_id = inb(HA_SCSICONF(base)) & 0x7;
  898.  
  899.     switch (aha274x_type(base)) {
  900.         case 'T':
  901.         printk("aha274x warning: ignoring channel B of 274x-twin\n");
  902.         break;
  903.         case ' ':
  904.         break;
  905.         default:
  906.         printk("aha274x is an unsupported type, ignoring\n");
  907.         return(0);
  908.     }
  909.  
  910.     /*
  911.      *  Before registry, make sure that the offsets of the
  912.      *  struct scatterlist are what the sequencer will expect,
  913.      *  otherwise disable scatter-gather altogether until someone
  914.      *  can fix it.  This is important since the sequencer will
  915.      *  DMA elements of the SG array in while executing commands.
  916.      */
  917.     if (template->sg_tablesize != SG_NONE) {
  918.         struct scatterlist sg;
  919.  
  920.         if (SG_STRUCT_CHECK(sg)) {
  921.             printk("aha274x warning: kernel scatter-gather "
  922.                    "structures changed, disabling it\n");
  923.             template->sg_tablesize = SG_NONE;
  924.         }
  925.     }
  926.     
  927.     /*
  928.      *  Register each "host" and fill in the returned Scsi_Host
  929.      *  structure as best we can.  Some of the parameters aren't
  930.      *  really relevant for EISA, and none of the high-level SCSI
  931.      *  code looks at it anyway.. why are the fields there?  Also
  932.      *  save the pointer so that we can find the information when
  933.      *  an IRQ is triggered.
  934.      */
  935.     host = scsi_register(template, sizeof(struct aha274x_host));
  936.     host->this_id = scsi_id;
  937.     host->irq = irq;
  938.  
  939.     aha274x_boards[irq] = host;
  940.     
  941.     p = (struct aha274x_host *)host->hostdata;
  942.     for (i = 0; i < AHA274X_MAXSCB; i++)
  943.         p->SCB_array[i] = NULL;
  944.     p->base = base;
  945.  
  946.     /*
  947.      *  The interrupt trigger is different depending
  948.      *  on whether the card is EISA or VL-bus - sometimes.
  949.      *  The startup variable will be cleared once the first
  950.      *  command is queued, and is checked in the isr to
  951.      *  try and detect when the interrupt type is set
  952.      *  incorrectly, triggering an interrupt immediately.
  953.      */
  954.     p->unpause = (type != T_274X ? 0x2 : 0xa);
  955.     p->startup = !0;
  956.  
  957.     /*
  958.      *  Register IRQ with the kernel _after_ the host information
  959.      *  is set up, in case we take an interrupt right away, due to
  960.      *  the interrupt type being set wrong.
  961.      */
  962.     if (request_irq(irq, aha274x_isr, SA_INTERRUPT, "AHA274x/284x")) {
  963.         printk("aha274x couldn't register irq %d, ignoring\n", irq);
  964.         return(0);
  965.     }
  966.  
  967.     /*
  968.      *  A reminder until this can be detected automatically.
  969.      */
  970.     printk("aha274x: extended translation %sabled\n",
  971.            aha274x_extended ? "en" : "dis");
  972.  
  973.     /*
  974.      *  Print out debugging information before re-enabling
  975.      *  the card - a lot of registers on it can't be read
  976.      *  when the sequencer is active.
  977.      */
  978.     debug_config(type, base);
  979.  
  980.     /*
  981.      *  Load the sequencer program, then re-enable the board -
  982.      *  resetting the AIC-7770 disables it, leaving the lights
  983.      *  on with nobody home.
  984.      */
  985.     aha274x_loadram(base);
  986.     outb(1, O_BCTL(base));        /* ENABLE */
  987.  
  988.     /*
  989.      *  Set the host adapter registers to indicate that synchronous
  990.      *  negotiation should be attempted the first time the targets
  991.      *  are communicated with.  Also initialize the active message
  992.      *  flag to indicate that there is no message.
  993.      */
  994.     outb(0xff, HA_NEEDSDTR(base));
  995.     outb(0, HA_MSG_FLAGS(base));
  996.  
  997.     /*
  998.      *  Unpause the sequencer before returning and enable
  999.      *  interrupts - we shouldn't get any until the first
  1000.      *  command is sent to us by the high-level SCSI code.
  1001.      */
  1002.     UNPAUSE_SEQUENCER(p);
  1003.     return(1);
  1004. }
  1005.  
  1006. int aha274x_detect(Scsi_Host_Template *template)
  1007. {
  1008.     enum aha_type type;
  1009.     int found = 0, slot, base;
  1010.  
  1011.     for (slot = MINEISA; slot <= MAXEISA; slot++) {
  1012.  
  1013.         base = SLOTBASE(slot);
  1014.         
  1015.         if (check_region(O_MINREG(base),
  1016.                  O_MAXREG(base)-O_MINREG(base)))
  1017.         {
  1018.             /*
  1019.              *  Some other driver has staked a
  1020.              *  claim to this i/o region already.
  1021.              */
  1022.             continue;
  1023.         }
  1024.  
  1025.         type = aha274x_probe(slot, O_BIDx(base));
  1026.  
  1027.         if (type != T_NONE) {
  1028.             /*
  1029.              *  We "find" a 274x if we locate the card
  1030.              *  signature and we can set it up and register
  1031.              *  it with the kernel without incident.
  1032.              */
  1033.             found += aha274x_register(template, type, base);
  1034.         }
  1035.     }
  1036.     template->name = (char *)aha274x_info(NULL);
  1037.     return(found);
  1038. }
  1039.  
  1040. const char *aha274x_info(struct Scsi_Host * shost)
  1041. {
  1042.     return("Adaptec AHA274x/284x (EISA/VL-bus -> Fast SCSI) "
  1043.            AHA274X_SEQ_VERSION "/"
  1044.            AHA274X_H_VERSION "/"
  1045.            "1.29");
  1046. }
  1047.  
  1048. int aha274x_command(Scsi_Cmnd *cmd)
  1049. {
  1050.     /*
  1051.      *  This is a relic of non-interrupt-driven SCSI
  1052.      *  drivers.  With the can_queue variable set, this
  1053.      *  should never be called.
  1054.      */
  1055.     panic("aha274x_command was called\n");
  1056. }
  1057.  
  1058. static
  1059. void aha274x_buildscb(struct aha274x_host *p,
  1060.               Scsi_Cmnd *cmd,
  1061.               struct aha274x_scb *scb)
  1062. {
  1063.     void *addr;
  1064.     unsigned length;
  1065.  
  1066.     memset(scb, 0, sizeof(*scb));
  1067.  
  1068.     /*
  1069.      *  NB. channel selection (bit 3) is always zero.
  1070.      */
  1071.     scb->target_channel_lun = ((cmd->target << 4) & 0xf0) |
  1072.                    (cmd->lun & 0x7);
  1073.  
  1074.     /*
  1075.      *  The interpretation of request_buffer and request_bufflen
  1076.      *  changes depending on whether or not use_sg is zero; a
  1077.      *  non-zero use_sg indicates the number of elements in the
  1078.      *  scatter-gather array.
  1079.      *
  1080.      *  The AIC-7770 can't support transfers of any sort larger
  1081.      *  than 2^24 (three-byte count) without backflips.  For what
  1082.      *  the kernel is doing, this shouldn't occur.  I hope.
  1083.      */
  1084.     length = aha274x_length(cmd, 0);
  1085.  
  1086.     /*
  1087.      *  The sequencer code cannot yet handle scatter-gather segments
  1088.      *  larger than 64k (two-byte length).  The 1.1.x kernels, however,
  1089.      *  have a four-byte length field in the struct scatterlist, so
  1090.      *  make sure we don't exceed 64k on these kernels for now.
  1091.      */
  1092.     aha274x_sg_check(cmd);
  1093.  
  1094.     if (length > 0xffffff) {
  1095.         panic("aha274x_buildscb: can't transfer > 2^24 - 1 bytes\n");
  1096.     }
  1097.  
  1098.     /*
  1099.      *  XXX - this relies on the host data being stored in a
  1100.      *      little-endian format.
  1101.      */
  1102.     addr = cmd->cmnd;
  1103.     scb->SCSI_cmd_length = cmd->cmd_len;
  1104.     memcpy(scb->SCSI_cmd_pointer, &addr, sizeof(scb->SCSI_cmd_pointer));
  1105.  
  1106.     if (cmd->use_sg) {
  1107. #if 0
  1108.         debug("aha274x_buildscb: SG used, %d segments, length %u\n",
  1109.               cmd->use_sg,
  1110.               length);
  1111. #endif
  1112.         scb->SG_segment_count = cmd->use_sg;
  1113.         memcpy(scb->SG_list_pointer,
  1114.                &cmd->request_buffer,
  1115.                sizeof(scb->SG_list_pointer));
  1116.     } else {
  1117.         scb->SG_segment_count = 0;
  1118.         memcpy(scb->data_pointer,
  1119.                &cmd->request_buffer,
  1120.                sizeof(scb->data_pointer));
  1121.         memcpy(scb->data_count,
  1122.                &cmd->request_bufflen,
  1123.                sizeof(scb->data_count));
  1124.     }
  1125. }
  1126.  
  1127. static
  1128. void aha274x_putscb(int base, struct aha274x_scb *scb)
  1129. {
  1130.     /*
  1131.      *  By turning on the SCB auto increment, any reference
  1132.      *  to the SCB I/O space postincrements the SCB address
  1133.      *  we're looking at.  So turn this on and dump the relevant
  1134.      *  portion of the SCB to the card.
  1135.      */
  1136.     outb(0x80, O_SCBCNT(base));    /* SCBAUTO */
  1137.  
  1138.     asm volatile("cld\n\t"
  1139.              "rep\n\t"
  1140.              "outsb"
  1141.              : /* no output */
  1142.              :"S" (scb), "c" (sizeof(*scb)), "d" (O_SCBARRAY(base))
  1143.              :"si", "cx", "dx");
  1144.  
  1145.     outb(0, O_SCBCNT(base));
  1146. }
  1147.  
  1148. int aha274x_queue(Scsi_Cmnd *cmd, void (*fn)(Scsi_Cmnd *))
  1149. {
  1150.     long flags;
  1151.     int empty, old_scbptr;
  1152.     struct aha274x_host *p;
  1153.     struct aha274x_scb scb;
  1154.  
  1155. #if 0
  1156.     debug("aha274x_queue: cmd 0x%x (size %u), target %d, lun %d\n",
  1157.           cmd->cmnd[0],
  1158.           cmd->cmd_len,
  1159.           cmd->target,
  1160.           cmd->lun);
  1161. #endif
  1162.  
  1163.     p = (struct aha274x_host *)cmd->host->hostdata;
  1164.  
  1165.     /*
  1166.      *  Construct the SCB beforehand, so the sequencer is
  1167.      *  paused a minimal amount of time.
  1168.      */
  1169.     aha274x_buildscb(p, cmd, &scb);
  1170.  
  1171.     /*
  1172.      *  Clear the startup flag - we can now legitimately
  1173.      *  expect interrupts.
  1174.      */
  1175.     p->startup = 0;
  1176.  
  1177.     /*
  1178.      *  This is a critical section, since we don't want the
  1179.      *  interrupt routine mucking with the host data or the
  1180.      *  card.  Since the kernel documentation is vague on
  1181.      *  whether or not we are in a cli/sti pair already, save
  1182.      *  the flags to be on the safe side.
  1183.      */
  1184.     save_flags(flags);
  1185.     cli();
  1186.  
  1187.     /*
  1188.      *  Find a free slot in the SCB array to load this command
  1189.      *  into.  Since can_queue is set to AHA274X_MAXSCB, we
  1190.      *  should always find one.
  1191.      */
  1192.     for (empty = 0; empty < AHA274X_MAXSCB; empty++)
  1193.         if (!p->SCB_array[empty])
  1194.             break;
  1195.     if (empty == AHA274X_MAXSCB)
  1196.         panic("aha274x_queue: couldn't find a free scb\n");
  1197.  
  1198.     /*
  1199.      *  Pause the sequencer so we can play with its registers -
  1200.      *  wait for it to acknowledge the pause.
  1201.      *
  1202.      *  XXX - should the interrupts be left on while doing this?
  1203.      */
  1204.     PAUSE_SEQUENCER(p);
  1205.  
  1206.     /*
  1207.      *  Save the SCB pointer and put our own pointer in - this
  1208.      *  selects one of the four banks of SCB registers.  Load
  1209.      *  the SCB, then write its pointer into the queue in FIFO
  1210.      *  and restore the saved SCB pointer.
  1211.      */
  1212.     old_scbptr = inb(O_SCBPTR(p->base));
  1213.     outb(empty, O_SCBPTR(p->base));
  1214.     
  1215.     aha274x_putscb(p->base, &scb);
  1216.  
  1217.     outb(empty, O_QINFIFO(p->base));
  1218.     outb(old_scbptr, O_SCBPTR(p->base));
  1219.  
  1220.     /*
  1221.      *  Make sure the Scsi_Cmnd pointer is saved, the struct it
  1222.      *  points to is set up properly, and the parity error flag
  1223.      *  is reset, then unpause the sequencer and watch the fun
  1224.      *  begin.
  1225.      */
  1226.     cmd->scsi_done = fn;
  1227.     p->SCB_array[empty] = cmd;
  1228.     aha274x_parity(cmd) = DID_OK;
  1229.  
  1230.     UNPAUSE_SEQUENCER(p);
  1231.  
  1232.     restore_flags(flags);
  1233.     return(0);
  1234. }
  1235.  
  1236. /* return values from aha274x_kill */
  1237.  
  1238. enum k_state {
  1239.     k_ok,                /* scb found and message sent */
  1240.     k_busy,                /* message already present */
  1241.     k_absent,            /* couldn't locate scb */
  1242.     k_disconnect,            /* scb found, but disconnected */
  1243. };
  1244.  
  1245. /*
  1246.  *  This must be called with interrupts disabled - it's going to
  1247.  *  be messing around with the host data, and an interrupt being
  1248.  *  fielded in the middle could get ugly.
  1249.  *
  1250.  *  Since so much of the abort and reset code is shared, this
  1251.  *  function performs more magic than it really should.  If the
  1252.  *  command completes ok, then it will call scsi_done with the
  1253.  *  result code passed in.  The unpause parameter controls whether
  1254.  *  or not the sequencer gets unpaused - the reset function, for
  1255.  *  instance, may want to do something more aggressive.
  1256.  *
  1257.  *  Note that the command is checked for in our SCB_array first
  1258.  *  before the sequencer is paused, so if k_absent is returned,
  1259.  *  then the sequencer is NOT paused.
  1260.  */
  1261.  
  1262. static
  1263. enum k_state aha274x_kill(Scsi_Cmnd *cmd, unsigned char message,
  1264.               unsigned int result, int unpause)
  1265. {
  1266.     struct aha274x_host *p;
  1267.     int i, scb, found, queued;
  1268.     unsigned char scbsave[AHA274X_MAXSCB];
  1269.  
  1270.     p = (struct aha274x_host *)cmd->host->hostdata;
  1271.  
  1272.     /*
  1273.      *  If we can't find the command, assume it just completed
  1274.      *  and shrug it away.
  1275.      */
  1276.     for (scb = 0; scb < AHA274X_MAXSCB; scb++)
  1277.         if (p->SCB_array[scb] == cmd)
  1278.             break;
  1279.  
  1280.     if (scb == AHA274X_MAXSCB)
  1281.         return(k_absent);
  1282.  
  1283.     PAUSE_SEQUENCER(p);
  1284.  
  1285.     /*
  1286.      *  This is the best case, really.  Check to see if the
  1287.      *  command is still in the sequencer's input queue.  If
  1288.      *  so, simply remove it.  Reload the queue afterward.
  1289.      */
  1290.     queued = inb(O_QINCNT(p->base));
  1291.     
  1292.     for (i = found = 0; i < queued; i++) {
  1293.         scbsave[i] = inb(O_QINFIFO(p->base));
  1294.  
  1295.         if (scbsave[i] == scb) {
  1296.             found = 1;
  1297.             i -= 1;
  1298.         }
  1299.     }
  1300.  
  1301.     queued -= found;
  1302.     for (i = 0; i < queued; i++)
  1303.         outb(scbsave[i], O_QINFIFO(p->base));
  1304.  
  1305.     if (found)
  1306.         goto complete;
  1307.  
  1308.     /*
  1309.      *  Check the current SCB bank.  If it's not the one belonging
  1310.      *  to the command we want to kill, assume that the command
  1311.      *  is disconnected.  It's rather a pain to force a reconnect
  1312.      *  and send a message to the target, so we abdicate responsibility
  1313.      *  in this case.
  1314.      */
  1315.     if (inb(O_SCBPTR(p->base)) != scb) {
  1316.         if (unpause)
  1317.             UNPAUSE_SEQUENCER(p);
  1318.         return(k_disconnect);
  1319.     }
  1320.  
  1321.     /*
  1322.      *  Presumably at this point our target command is active.  Check
  1323.      *  to see if there's a message already in effect.  If not, place
  1324.      *  our message in and assert ATN so the target goes into MESSAGE
  1325.      *  OUT phase.
  1326.      */
  1327.     if (inb(HA_MSG_FLAGS(p->base)) & 0x80) {
  1328.         if (unpause)
  1329.             UNPAUSE_SEQUENCER(p);
  1330.         return(k_busy);
  1331.     }
  1332.  
  1333.     outb(0x80, HA_MSG_FLAGS(p->base));        /* active message */
  1334.     outb(1, HA_MSG_LEN(p->base));            /* length = 1 */
  1335.     outb(message, HA_MSG_START(p->base));        /* message body */
  1336.  
  1337.     /*
  1338.      *  Assert ATN.  Use the value of SCSISIGO saved by the
  1339.      *  sequencer code so we don't alter its contents radically
  1340.      *  in the middle of something critical.
  1341.      */
  1342.     outb(inb(HA_SIGSTATE(p->base)) | 0x10, O_SCSISIGO(p->base));
  1343.  
  1344.     /*
  1345.      *  The command has been killed.  Do the bookkeeping, unpause
  1346.      *  the sequencer, and notify the higher-level SCSI code.
  1347.      */
  1348. complete:
  1349.     p->SCB_array[scb] = NULL;
  1350.     if (unpause)
  1351.         UNPAUSE_SEQUENCER(p);
  1352.  
  1353.     cmd->result = result << 16;
  1354.     cmd->scsi_done(cmd);
  1355.     return(k_ok);
  1356. }
  1357.  
  1358. int aha274x_abort(Scsi_Cmnd *cmd)
  1359. {
  1360.     int rv;
  1361.     long flags;
  1362.  
  1363.     save_flags(flags);
  1364.     cli();
  1365.  
  1366.     switch (aha274x_kill(cmd, ABORT, DID_ABORT, !0)) {
  1367.         case k_ok:        rv = SCSI_ABORT_SUCCESS;    break;
  1368.         case k_busy:    rv = SCSI_ABORT_BUSY;        break;
  1369.         case k_absent:    rv = SCSI_ABORT_NOT_RUNNING;    break;
  1370.         case k_disconnect:    rv = SCSI_ABORT_SNOOZE;        break;
  1371.         default:
  1372.         panic("aha274x_do_abort: internal error\n");
  1373.     }
  1374.  
  1375.     restore_flags(flags);
  1376.     return(rv);
  1377. }
  1378.  
  1379. /*
  1380.  *  Resetting the bus always succeeds - is has to, otherwise the
  1381.  *  kernel will panic!  Try a surgical technique - sending a BUS
  1382.  *  DEVICE RESET message - on the offending target before pulling
  1383.  *  the SCSI bus reset line.
  1384.  */
  1385.  
  1386. int aha274x_reset(Scsi_Cmnd *cmd)
  1387. {
  1388.     int i;
  1389.     long flags;
  1390.     Scsi_Cmnd *reset;
  1391.     struct aha274x_host *p;
  1392.  
  1393.     p = (struct aha274x_host *)cmd->host->hostdata;
  1394.     save_flags(flags);
  1395.     cli();
  1396.  
  1397.     switch (aha274x_kill(cmd, BUS_DEVICE_RESET, DID_RESET, 0)) {
  1398.  
  1399.         case k_ok:
  1400.         /*
  1401.          *  The RESET message was sent to the target
  1402.          *  with no problems.  Flag that target as
  1403.          *  needing a SDTR negotiation on the next
  1404.          *  connection and restart the sequencer.
  1405.          */
  1406.         outb((1 << cmd->target), HA_NEEDSDTR(p->base));
  1407.         UNPAUSE_SEQUENCER(p);
  1408.         break;
  1409.  
  1410.         case k_absent:
  1411.         /*
  1412.          *  The sequencer will not be paused if aha274x_kill()
  1413.          *  couldn't find the command.
  1414.          */
  1415.         PAUSE_SEQUENCER(p);
  1416.         /* falls through */
  1417.  
  1418.         case k_busy:
  1419.         case k_disconnect:
  1420.         /*
  1421.          *  Do a hard reset of the SCSI bus.  According to the
  1422.          *  SCSI-2 draft specification, reset has to be asserted
  1423.          *  for at least 25us.  I'm invoking the kernel delay
  1424.          *  function for 30us since I'm not totally trusting of
  1425.          *  the busy loop timing.
  1426.          *
  1427.          *  XXX - I'm not convinced this works.  I tried resetting
  1428.          *      the bus before, trying to get the devices on the
  1429.          *      bus to revert to asynchronous transfer, and it
  1430.          *      never seemed to work.
  1431.          */
  1432.         debug("aha274x: attempting to reset scsi bus and card\n");
  1433.  
  1434.         outb(1, O_SCSISEQ(p->base));        /* SCSIRSTO */
  1435.         udelay(30);
  1436.         outb(0, O_SCSISEQ(p->base));        /* !SCSIRSTO */
  1437.  
  1438.         outb(0xff, HA_NEEDSDTR(p->base));
  1439.         UNPAUSE_SEQUENCER(p);
  1440.  
  1441.         /*
  1442.          *  Locate the command and return a "reset" status
  1443.          *  for it.  This is not completely correct and will
  1444.          *  probably return to haunt me later.
  1445.          */
  1446.         for (i = 0; i < AHA274X_MAXSCB; i++) {
  1447.             if (cmd == p->SCB_array[i]) {
  1448.                 reset = (Scsi_Cmnd *)p->SCB_array[i];
  1449.                 p->SCB_array[i] = NULL;
  1450.                 reset->result = DID_RESET << 16;
  1451.                 reset->scsi_done(reset);
  1452.                 break;
  1453.             }
  1454.         }
  1455.         break;
  1456.  
  1457.         default:
  1458.         panic("aha274x_reset: internal error\n");
  1459.     }
  1460.  
  1461.     restore_flags(flags);
  1462.     return(SCSI_RESET_SUCCESS);
  1463. }
  1464.  
  1465. int aha274x_biosparam(Disk *disk, int devno, int geom[])
  1466. {
  1467.     int heads, sectors, cylinders;
  1468.  
  1469.     /*
  1470.      *  XXX - if I could portably find the card's configuration
  1471.      *      information, then this could be autodetected instead
  1472.      *      of left to a boot-time switch.
  1473.      */
  1474.     heads = 64;
  1475.     sectors = 32;
  1476.     cylinders = disk->capacity / (heads * sectors);
  1477.  
  1478.     if (aha274x_extended && cylinders > 1024) {
  1479.         heads = 255;
  1480.         sectors = 63;
  1481.         cylinders = disk->capacity / (255 * 63);
  1482.     }
  1483.  
  1484.     geom[0] = heads;
  1485.     geom[1] = sectors;
  1486.     geom[2] = cylinders;
  1487.  
  1488.     return(0);
  1489. }
  1490.  
  1491.