git.oblomov.eu Git - linux-2.6/blob - drivers/scsi/initio.c

   1 /**************************************************************************
   2  * Initio 9100 device driver for Linux.
   3  *
   4  * Copyright (c) 1994-1998 Initio Corporation
   5  * Copyright (c) 1998 Bas Vermeulen <bvermeul@blackstar.xs4all.nl>
   6  * Copyright (c) 2004 Christoph Hellwig <hch@lst.de>
   7  * Copyright (c) 2007 Red Hat <alan@redhat.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2, or (at your option)
  12  * any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; see the file COPYING.  If not, write to
  21  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  22  *
  23  *
  24  *************************************************************************
  25  *
  26  * DESCRIPTION:
  27  *
  28  * This is the Linux low-level SCSI driver for Initio INI-9X00U/UW SCSI host
  29  * adapters
  30  *
  31  * 08/06/97 hc  - v1.01h
  32  *              - Support inic-940 and inic-935
  33  * 09/26/97 hc  - v1.01i
  34  *              - Make correction from J.W. Schultz suggestion
  35  * 10/13/97 hc  - Support reset function
  36  * 10/21/97 hc  - v1.01j
  37  *              - Support 32 LUN (SCSI 3)
  38  * 01/14/98 hc  - v1.01k
  39  *              - Fix memory allocation problem
  40  * 03/04/98 hc  - v1.01l
  41  *              - Fix tape rewind which will hang the system problem
  42  *              - Set can_queue to initio_num_scb
  43  * 06/25/98 hc  - v1.01m
  44  *              - Get it work for kernel version >= 2.1.75
  45  *              - Dynamic assign SCSI bus reset holding time in initio_init()
  46  * 07/02/98 hc  - v1.01n
  47  *              - Support 0002134A
  48  * 08/07/98 hc  - v1.01o
  49  *              - Change the initio_abort_srb routine to use scsi_done. <01>
  50  * 09/07/98 hl  - v1.02
  51  *              - Change the INI9100U define and proc_dir_entry to
  52  *                reflect the newer Kernel 2.1.118, but the v1.o1o
  53  *                should work with Kernel 2.1.118.
  54  * 09/20/98 wh  - v1.02a
  55  *              - Support Abort command.
  56  *              - Handle reset routine.
  57  * 09/21/98 hl  - v1.03
  58  *              - remove comments.
  59  * 12/09/98 bv  - v1.03a
  60  *              - Removed unused code
  61  * 12/13/98 bv  - v1.03b
  62  *              - Remove cli() locking for kernels >= 2.1.95. This uses
  63  *                spinlocks to serialize access to the pSRB_head and
  64  *                pSRB_tail members of the HCS structure.
  65  * 09/01/99 bv  - v1.03d
  66  *              - Fixed a deadlock problem in SMP.
  67  * 21/01/99 bv  - v1.03e
  68  *              - Add support for the Domex 3192U PCI SCSI
  69  *                This is a slightly modified patch by
  70  *                Brian Macy <bmacy@sunshinecomputing.com>
  71  * 22/02/99 bv  - v1.03f
  72  *              - Didn't detect the INIC-950 in 2.0.x correctly.
  73  *                Now fixed.
  74  * 05/07/99 bv  - v1.03g
  75  *              - Changed the assumption that HZ = 100
  76  * 10/17/03 mc  - v1.04
  77  *              - added new DMA API support
  78  * 06/01/04 jmd - v1.04a
  79  *              - Re-add reset_bus support
  80  **************************************************************************/
  81
  82 #include <linux/module.h>
  83 #include <linux/errno.h>
  84 #include <linux/delay.h>
  85 #include <linux/pci.h>
  86 #include <linux/init.h>
  87 #include <linux/blkdev.h>
  88 #include <linux/spinlock.h>
  89 #include <linux/stat.h>
  90 #include <linux/kernel.h>
  91 #include <linux/proc_fs.h>
  92 #include <linux/string.h>
  93 #include <linux/interrupt.h>
  94 #include <linux/ioport.h>
  95 #include <linux/slab.h>
  96 #include <linux/jiffies.h>
  97 #include <linux/dma-mapping.h>
  98 #include <asm/io.h>
  99
 100 #include <scsi/scsi.h>
 101 #include <scsi/scsi_cmnd.h>
 102 #include <scsi/scsi_device.h>
 103 #include <scsi/scsi_host.h>
 104 #include <scsi/scsi_tcq.h>
 105
 106 #include "initio.h"
 107
 108 #define SENSE_SIZE              14
 109
 110 #define i91u_MAXQUEUE           2
 111 #define i91u_REVID "Initio INI-9X00U/UW SCSI device driver; Revision: 1.04a"
 112
 113 #define I950_DEVICE_ID  0x9500  /* Initio's inic-950 product ID   */
 114 #define I940_DEVICE_ID  0x9400  /* Initio's inic-940 product ID   */
 115 #define I935_DEVICE_ID  0x9401  /* Initio's inic-935 product ID   */
 116 #define I920_DEVICE_ID  0x0002  /* Initio's other product ID      */
 117
 118 #ifdef DEBUG_i91u
 119 static unsigned int i91u_debug = DEBUG_DEFAULT;
 120 #endif
 121
 122 static int initio_tag_enable = 1;
 123
 124 #ifdef DEBUG_i91u
 125 static int setup_debug = 0;
 126 #endif
 127
 128 static void i91uSCBPost(u8 * pHcb, u8 * pScb);
 129
 130 /* PCI Devices supported by this driver */
 131 static struct pci_device_id i91u_pci_devices[] = {
 132         { PCI_VENDOR_ID_INIT,  I950_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 133         { PCI_VENDOR_ID_INIT,  I940_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 134         { PCI_VENDOR_ID_INIT,  I935_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 135         { PCI_VENDOR_ID_INIT,  I920_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 136         { PCI_VENDOR_ID_DOMEX, I920_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 137         { }
 138 };
 139 MODULE_DEVICE_TABLE(pci, i91u_pci_devices);
 140
 141 #define DEBUG_INTERRUPT 0
 142 #define DEBUG_QUEUE     0
 143 #define DEBUG_STATE     0
 144 #define INT_DISC        0
 145
 146 /*--- forward references ---*/
 147 static struct scsi_ctrl_blk *initio_find_busy_scb(struct initio_host * host, u16 tarlun);
 148 static struct scsi_ctrl_blk *initio_find_done_scb(struct initio_host * host);
 149
 150 static int tulip_main(struct initio_host * host);
 151
 152 static int initio_next_state(struct initio_host * host);
 153 static int initio_state_1(struct initio_host * host);
 154 static int initio_state_2(struct initio_host * host);
 155 static int initio_state_3(struct initio_host * host);
 156 static int initio_state_4(struct initio_host * host);
 157 static int initio_state_5(struct initio_host * host);
 158 static int initio_state_6(struct initio_host * host);
 159 static int initio_state_7(struct initio_host * host);
 160 static int initio_xfer_data_in(struct initio_host * host);
 161 static int initio_xfer_data_out(struct initio_host * host);
 162 static int initio_xpad_in(struct initio_host * host);
 163 static int initio_xpad_out(struct initio_host * host);
 164 static int initio_status_msg(struct initio_host * host);
 165
 166 static int initio_msgin(struct initio_host * host);
 167 static int initio_msgin_sync(struct initio_host * host);
 168 static int initio_msgin_accept(struct initio_host * host);
 169 static int initio_msgout_reject(struct initio_host * host);
 170 static int initio_msgin_extend(struct initio_host * host);
 171
 172 static int initio_msgout_ide(struct initio_host * host);
 173 static int initio_msgout_abort_targ(struct initio_host * host);
 174 static int initio_msgout_abort_tag(struct initio_host * host);
 175
 176 static int initio_bus_device_reset(struct initio_host * host);
 177 static void initio_select_atn(struct initio_host * host, struct scsi_ctrl_blk * scb);
 178 static void initio_select_atn3(struct initio_host * host, struct scsi_ctrl_blk * scb);
 179 static void initio_select_atn_stop(struct initio_host * host, struct scsi_ctrl_blk * scb);
 180 static int int_initio_busfree(struct initio_host * host);
 181 static int int_initio_scsi_rst(struct initio_host * host);
 182 static int int_initio_bad_seq(struct initio_host * host);
 183 static int int_initio_resel(struct initio_host * host);
 184 static int initio_sync_done(struct initio_host * host);
 185 static int wdtr_done(struct initio_host * host);
 186 static int wait_tulip(struct initio_host * host);
 187 static int initio_wait_done_disc(struct initio_host * host);
 188 static int initio_wait_disc(struct initio_host * host);
 189 static void tulip_scsi(struct initio_host * host);
 190 static int initio_post_scsi_rst(struct initio_host * host);
 191
 192 static void initio_se2_ew_en(unsigned long base);
 193 static void initio_se2_ew_ds(unsigned long base);
 194 static int initio_se2_rd_all(unsigned long base);
 195 static void initio_se2_update_all(unsigned long base);  /* setup default pattern */
 196 static void initio_read_eeprom(unsigned long base);
 197
 198 /* ---- INTERNAL VARIABLES ---- */
 199
 200 static NVRAM i91unvram;
 201 static NVRAM *i91unvramp;
 202
 203 static u8 i91udftNvRam[64] =
 204 {
 205         /*----------- header -----------*/
 206         0x25, 0xc9,             /* Signature    */
 207         0x40,                   /* Size         */
 208         0x01,                   /* Revision     */
 209         /* -- Host Adapter Structure -- */
 210         0x95,                   /* ModelByte0   */
 211         0x00,                   /* ModelByte1   */
 212         0x00,                   /* ModelInfo    */
 213         0x01,                   /* NumOfCh      */
 214         NBC1_DEFAULT,           /* BIOSConfig1  */
 215         0,                      /* BIOSConfig2  */
 216         0,                      /* HAConfig1    */
 217         0,                      /* HAConfig2    */
 218         /* SCSI channel 0 and target Structure  */
 219         7,                      /* SCSIid       */
 220         NCC1_DEFAULT,           /* SCSIconfig1  */
 221         0,                      /* SCSIconfig2  */
 222         0x10,                   /* NumSCSItarget */
 223
 224         NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT,
 225         NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT,
 226         NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT,
 227         NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT,
 228
 229         /* SCSI channel 1 and target Structure  */
 230         7,                      /* SCSIid       */
 231         NCC1_DEFAULT,           /* SCSIconfig1  */
 232         0,                      /* SCSIconfig2  */
 233         0x10,                   /* NumSCSItarget */
 234
 235         NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT,
 236         NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT,
 237         NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT,
 238         NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT,
 239         0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 240         0, 0};                  /*      - CheckSum -            */
 241
 242
 243 static u8 initio_rate_tbl[8] =  /* fast 20      */
 244 {
 245                                 /* nanosecond devide by 4 */
 246         12,                     /* 50ns,  20M   */
 247         18,                     /* 75ns,  13.3M */
 248         25,                     /* 100ns, 10M   */
 249         31,                     /* 125ns, 8M    */
 250         37,                     /* 150ns, 6.6M  */
 251         43,                     /* 175ns, 5.7M  */
 252         50,                     /* 200ns, 5M    */
 253         62                      /* 250ns, 4M    */
 254 };
 255
 256 static void initio_do_pause(unsigned amount)
 257 {
 258         /* Pause for amount jiffies */
 259         unsigned long the_time = jiffies + amount;
 260
 261         while (time_before_eq(jiffies, the_time))
 262                 cpu_relax();
 263 }
 264
 265 /*-- forward reference --*/
 266
 267 /******************************************************************
 268  Input: instruction for  Serial E2PROM
 269
 270  EX: se2_rd(0 call se2_instr() to send address and read command
 271
 272          StartBit  OP_Code   Address                Data
 273          --------- --------  ------------------     -------
 274          1         1 , 0     A5,A4,A3,A2,A1,A0      D15-D0
 275
 276                  +-----------------------------------------------------
 277                  |
 278  CS -----+
 279                         +--+  +--+  +--+  +--+  +--+
 280                         ^  |  ^  |  ^  |  ^  |  ^  |
 281                         |  |  |  |  |  |  |  |  |  |
 282  CLK -------+  +--+  +--+  +--+  +--+  +--
 283  (leading edge trigger)
 284
 285                  +--1-----1--+
 286                  | SB    OP  |  OP    A5    A4
 287  DI  ----+           +--0------------------
 288  (address and cmd sent to nvram)
 289
 290          -------------------------------------------+
 291                                                                                                 |
 292  DO                                             +---
 293  (data sent from nvram)
 294
 295
 296 ******************************************************************/
 297
 298 /**
 299  *      initio_se2_instr        -       bitbang an instruction
 300  *      @base: Base of InitIO controller
 301  *      @instr: Instruction for serial E2PROM
 302  *
 303  *      Bitbang an instruction out to the serial E2Prom
 304  */
 305
 306 static void initio_se2_instr(unsigned long base, u8 instr)
 307 {
 308         int i;
 309         u8 b;
 310
 311         outb(SE2CS | SE2DO, base + TUL_NVRAM);          /* cs+start bit */
 312         udelay(30);
 313         outb(SE2CS | SE2CLK | SE2DO, base + TUL_NVRAM); /* +CLK */
 314         udelay(30);
 315
 316         for (i = 0; i < 8; i++) {
 317                 if (instr & 0x80)
 318                         b = SE2CS | SE2DO;              /* -CLK+dataBit */
 319                 else
 320                         b = SE2CS;                      /* -CLK */
 321                 outb(b, base + TUL_NVRAM);
 322                 udelay(30);
 323                 outb(b | SE2CLK, base + TUL_NVRAM);     /* +CLK */
 324                 udelay(30);
 325                 instr <<= 1;
 326         }
 327         outb(SE2CS, base + TUL_NVRAM);                  /* -CLK */
 328         udelay(30);
 329 }
 330
 331
 332 /**
 333  *      initio_se2_ew_en        -       Enable erase/write
 334  *      @base: Base address of InitIO controller
 335  *
 336  *      Enable erase/write state of serial EEPROM
 337  */
 338 void initio_se2_ew_en(unsigned long base)
 339 {
 340         initio_se2_instr(base, 0x30);   /* EWEN */
 341         outb(0, base + TUL_NVRAM);      /* -CS  */
 342         udelay(30);
 343 }
 344
 345
 346 /**
 347  *      initio_se2_ew_ds        -       Disable erase/write
 348  *      @base: Base address of InitIO controller
 349  *
 350  *      Disable erase/write state of serial EEPROM
 351  */
 352 void initio_se2_ew_ds(unsigned long base)
 353 {
 354         initio_se2_instr(base, 0);      /* EWDS */
 355         outb(0, base + TUL_NVRAM);      /* -CS  */
 356         udelay(30);
 357 }
 358
 359
 360 /**
 361  *      initio_se2_rd           -       read E2PROM word
 362  *      @base: Base of InitIO controller
 363  *      @addr: Address of word in E2PROM
 364  *
 365  *      Read a word from the NV E2PROM device
 366  */
 367 static u16 initio_se2_rd(unsigned long base, u8 addr)
 368 {
 369         u8 instr, rb;
 370         u16 val = 0;
 371         int i;
 372
 373         instr = (u8) (addr | 0x80);
 374         initio_se2_instr(base, instr);  /* READ INSTR */
 375
 376         for (i = 15; i >= 0; i--) {
 377                 outb(SE2CS | SE2CLK, base + TUL_NVRAM); /* +CLK */
 378                 udelay(30);
 379                 outb(SE2CS, base + TUL_NVRAM);          /* -CLK */
 380
 381                 /* sample data after the following edge of clock  */
 382                 rb = inb(base + TUL_NVRAM);
 383                 rb &= SE2DI;
 384                 val += (rb << i);
 385                 udelay(30);     /* 6/20/95 */
 386         }
 387
 388         outb(0, base + TUL_NVRAM);              /* no chip select */
 389         udelay(30);
 390         return val;
 391 }
 392
 393 /**
 394  *      initio_se2_wr           -       read E2PROM word
 395  *      @base: Base of InitIO controller
 396  *      @addr: Address of word in E2PROM
 397  *      @val: Value to write
 398  *
 399  *      Write a word to the NV E2PROM device. Used when recovering from
 400  *      a problem with the NV.
 401  */
 402 static void initio_se2_wr(unsigned long base, u8 addr, u16 val)
 403 {
 404         u8 rb;
 405         u8 instr;
 406         int i;
 407
 408         instr = (u8) (addr | 0x40);
 409         initio_se2_instr(base, instr);  /* WRITE INSTR */
 410         for (i = 15; i >= 0; i--) {
 411                 if (val & 0x8000)
 412                         outb(SE2CS | SE2DO, base + TUL_NVRAM);  /* -CLK+dataBit 1 */
 413                 else
 414                         outb(SE2CS, base + TUL_NVRAM);          /* -CLK+dataBit 0 */
 415                 udelay(30);
 416                 outb(SE2CS | SE2CLK, base + TUL_NVRAM);         /* +CLK */
 417                 udelay(30);
 418                 val <<= 1;
 419         }
 420         outb(SE2CS, base + TUL_NVRAM);                          /* -CLK */
 421         udelay(30);
 422         outb(0, base + TUL_NVRAM);                              /* -CS  */
 423         udelay(30);
 424
 425         outb(SE2CS, base + TUL_NVRAM);                          /* +CS  */
 426         udelay(30);
 427
 428         for (;;) {
 429                 outb(SE2CS | SE2CLK, base + TUL_NVRAM);         /* +CLK */
 430                 udelay(30);
 431                 outb(SE2CS, base + TUL_NVRAM);                  /* -CLK */
 432                 udelay(30);
 433                 if ((rb = inb(base + TUL_NVRAM)) & SE2DI)
 434                         break;  /* write complete */
 435         }
 436         outb(0, base + TUL_NVRAM);                              /* -CS */
 437 }
 438
 439 /**
 440  *      initio_se2_rd_all       -       read hostadapter NV configuration
 441  *      @base: Base address of InitIO controller
 442  *
 443  *      Reads the E2PROM data into main memory. Ensures that the checksum
 444  *      and header marker are valid. Returns 1 on success -1 on error.
 445  */
 446
 447 static int initio_se2_rd_all(unsigned long base)
 448 {
 449         int i;
 450         u16 chksum = 0;
 451         u16 *np;
 452
 453         i91unvramp = &i91unvram;
 454         np = (u16 *) i91unvramp;
 455         for (i = 0; i < 32; i++)
 456                 *np++ = initio_se2_rd(base, i);
 457
 458         /* Is signature "ini" ok ? */
 459         if (i91unvramp->NVM_Signature != INI_SIGNATURE)
 460                 return -1;
 461         /* Is ckecksum ok ? */
 462         np = (u16 *) i91unvramp;
 463         for (i = 0; i < 31; i++)
 464                 chksum += *np++;
 465         if (i91unvramp->NVM_CheckSum != chksum)
 466                 return -1;
 467         return 1;
 468 }
 469
 470 /**
 471  *      initio_se2_update_all           -       Update E2PROM
 472  *      @base: Base of InitIO controller
 473  *
 474  *      Update the E2PROM by wrting any changes into the E2PROM
 475  *      chip, rewriting the checksum.
 476  */
 477 static void initio_se2_update_all(unsigned long base)
 478 {                               /* setup default pattern */
 479         int i;
 480         u16 chksum = 0;
 481         u16 *np, *np1;
 482
 483         i91unvramp = &i91unvram;
 484         /* Calculate checksum first */
 485         np = (u16 *) i91udftNvRam;
 486         for (i = 0; i < 31; i++)
 487                 chksum += *np++;
 488         *np = chksum;
 489         initio_se2_ew_en(base); /* Enable write  */
 490
 491         np = (u16 *) i91udftNvRam;
 492         np1 = (u16 *) i91unvramp;
 493         for (i = 0; i < 32; i++, np++, np1++) {
 494                 if (*np != *np1)
 495                         initio_se2_wr(base, i, *np);
 496         }
 497         initio_se2_ew_ds(base); /* Disable write   */
 498 }
 499
 500 /**
 501  *      initio_read_eeprom              -       Retrieve configuration
 502  *      @base: Base of InitIO Host Adapter
 503  *
 504  *      Retrieve the host adapter configuration data from E2Prom. If the
 505  *      data is invalid then the defaults are used and are also restored
 506  *      into the E2PROM. This forms the access point for the SCSI driver
 507  *      into the E2PROM layer, the other functions for the E2PROM are all
 508  *      internal use.
 509  *
 510  *      Must be called single threaded, uses a shared global area.
 511  */
 512
 513 static void initio_read_eeprom(unsigned long base)
 514 {
 515         u8 gctrl;
 516
 517         i91unvramp = &i91unvram;
 518         /* Enable EEProm programming */
 519         gctrl = inb(base + TUL_GCTRL);
 520         outb(gctrl | TUL_GCTRL_EEPROM_BIT, base + TUL_GCTRL);
 521         if (initio_se2_rd_all(base) != 1) {
 522                 initio_se2_update_all(base);    /* setup default pattern */
 523                 initio_se2_rd_all(base);        /* load again  */
 524         }
 525         /* Disable EEProm programming */
 526         gctrl = inb(base + TUL_GCTRL);
 527         outb(gctrl & ~TUL_GCTRL_EEPROM_BIT, base + TUL_GCTRL);
 528 }
 529
 530 /**
 531  *      initio_stop_bm          -       stop bus master
 532  *      @host: InitIO we are stopping
 533  *
 534  *      Stop any pending DMA operation, aborting the DMA if neccessary
 535  */
 536
 537 static void initio_stop_bm(struct initio_host * host)
 538 {
 539
 540         if (inb(host->addr + TUL_XStatus) & XPEND) {    /* if DMA xfer is pending, abort DMA xfer */
 541                 outb(TAX_X_ABT | TAX_X_CLR_FIFO, host->addr + TUL_XCmd);
 542                 /* wait Abort DMA xfer done */
 543                 while ((inb(host->addr + TUL_Int) & XABT) == 0)
 544                         cpu_relax();
 545         }
 546         outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
 547 }
 548
 549 /**
 550  *      initio_reset_scsi               -       Reset SCSI host controller
 551  *      @host: InitIO host to reset
 552  *      @seconds: Recovery time
 553  *
 554  *      Perform a full reset of the SCSI subsystem.
 555  */
 556
 557 static int initio_reset_scsi(struct initio_host * host, int seconds)
 558 {
 559         outb(TSC_RST_BUS, host->addr + TUL_SCtrl0);
 560
 561         while (!((host->jsint = inb(host->addr + TUL_SInt)) & TSS_SCSIRST_INT))
 562                 cpu_relax();
 563
 564         /* reset tulip chip */
 565         outb(0, host->addr + TUL_SSignal);
 566
 567         /* Stall for a while, wait for target's firmware ready,make it 2 sec ! */
 568         /* SONY 5200 tape drive won't work if only stall for 1 sec */
 569         /* FIXME: this is a very long busy wait right now */
 570         initio_do_pause(seconds * HZ);
 571
 572         inb(host->addr + TUL_SInt);
 573         return SCSI_RESET_SUCCESS;
 574 }
 575
 576 /**
 577  *      initio_init             -       set up an InitIO host adapter
 578  *      @host: InitIO host adapter
 579  *      @num_scbs: Number of SCBS
 580  *      @bios_addr: BIOS address
 581  *
 582  *      Set up the host adapter and devices according to the configuration
 583  *      retrieved from the E2PROM.
 584  *
 585  *      Locking: Calls E2PROM layer code which is not re-enterable so must
 586  *      run single threaded for now.
 587  */
 588
 589 static void initio_init(struct initio_host * host, u8 *bios_addr)
 590 {
 591         int i;
 592         u8 *flags;
 593         u8 *heads;
 594
 595         /* Get E2Prom configuration */
 596         initio_read_eeprom(host->addr);
 597         if (i91unvramp->NVM_SCSIInfo[0].NVM_NumOfTarg == 8)
 598                 host->max_tar = 8;
 599         else
 600                 host->max_tar = 16;
 601
 602         host->config = i91unvramp->NVM_SCSIInfo[0].NVM_ChConfig1;
 603
 604         host->scsi_id = i91unvramp->NVM_SCSIInfo[0].NVM_ChSCSIID;
 605         host->idmask = ~(1 << host->scsi_id);
 606
 607 #ifdef CHK_PARITY
 608         /* Enable parity error response */
 609         outb(inb(host->addr + TUL_PCMD) | 0x40, host->addr + TUL_PCMD);
 610 #endif
 611
 612         /* Mask all the interrupt       */
 613         outb(0x1F, host->addr + TUL_Mask);
 614
 615         initio_stop_bm(host);
 616         /* --- Initialize the tulip --- */
 617         outb(TSC_RST_CHIP, host->addr + TUL_SCtrl0);
 618
 619         /* program HBA's SCSI ID        */
 620         outb(host->scsi_id << 4, host->addr + TUL_SScsiId);
 621
 622         /* Enable Initiator Mode ,phase latch,alternate sync period mode,
 623            disable SCSI reset */
 624         if (host->config & HCC_EN_PAR)
 625                 host->sconf1 = (TSC_INITDEFAULT | TSC_EN_SCSI_PAR);
 626         else
 627                 host->sconf1 = (TSC_INITDEFAULT);
 628         outb(host->sconf1, host->addr + TUL_SConfig);
 629
 630         /* Enable HW reselect */
 631         outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1);
 632
 633         outb(0, host->addr + TUL_SPeriod);
 634
 635         /* selection time out = 250 ms */
 636         outb(153, host->addr + TUL_STimeOut);
 637
 638         /* Enable SCSI terminator */
 639         outb((host->config & (HCC_ACT_TERM1 | HCC_ACT_TERM2)),
 640                 host->addr + TUL_XCtrl);
 641         outb(((host->config & HCC_AUTO_TERM) >> 4) |
 642                 (inb(host->addr + TUL_GCTRL1) & 0xFE),
 643                 host->addr + TUL_GCTRL1);
 644
 645         for (i = 0,
 646              flags = & (i91unvramp->NVM_SCSIInfo[0].NVM_Targ0Config),
 647              heads = bios_addr + 0x180;
 648              i < host->max_tar;
 649              i++, flags++) {
 650                 host->targets[i].flags = *flags & ~(TCF_SYNC_DONE | TCF_WDTR_DONE);
 651                 if (host->targets[i].flags & TCF_EN_255)
 652                         host->targets[i].drv_flags = TCF_DRV_255_63;
 653                 else
 654                         host->targets[i].drv_flags = 0;
 655                 host->targets[i].js_period = 0;
 656                 host->targets[i].sconfig0 = host->sconf1;
 657                 host->targets[i].heads = *heads++;
 658                 if (host->targets[i].heads == 255)
 659                         host->targets[i].drv_flags = TCF_DRV_255_63;
 660                 else
 661                         host->targets[i].drv_flags = 0;
 662                 host->targets[i].sectors = *heads++;
 663                 host->targets[i].flags &= ~TCF_BUSY;
 664                 host->act_tags[i] = 0;
 665                 host->max_tags[i] = 0xFF;
 666         }                       /* for                          */
 667         printk("i91u: PCI Base=0x%04X, IRQ=%d, BIOS=0x%04X0, SCSI ID=%d\n",
 668                host->addr, host->pci_dev->irq,
 669                host->bios_addr, host->scsi_id);
 670         /* Reset SCSI Bus */
 671         if (host->config & HCC_SCSI_RESET) {
 672                 printk(KERN_INFO "i91u: Reset SCSI Bus ... \n");
 673                 initio_reset_scsi(host, 10);
 674         }
 675         outb(0x17, host->addr + TUL_SCFG1);
 676         outb(0xE9, host->addr + TUL_SIntEnable);
 677 }
 678
 679 /**
 680  *      initio_alloc_scb                -       Allocate an SCB
 681  *      @host: InitIO host we are allocating for
 682  *
 683  *      Walk the SCB list for the controller and allocate a free SCB if
 684  *      one exists.
 685  */
 686 static struct scsi_ctrl_blk *initio_alloc_scb(struct initio_host *host)
 687 {
 688         struct scsi_ctrl_blk *scb;
 689         unsigned long flags;
 690
 691         spin_lock_irqsave(&host->avail_lock, flags);
 692         if ((scb = host->first_avail) != NULL) {
 693 #if DEBUG_QUEUE
 694                 printk("find scb at %p\n", scb);
 695 #endif
 696                 if ((host->first_avail = scb->next) == NULL)
 697                         host->last_avail = NULL;
 698                 scb->next = NULL;
 699                 scb->status = SCB_RENT;
 700         }
 701         spin_unlock_irqrestore(&host->avail_lock, flags);
 702         return scb;
 703 }
 704
 705 /**
 706  *      initio_release_scb              -       Release an SCB
 707  *      @host: InitIO host that owns the SCB
 708  *      @cmnd: SCB command block being returned
 709  *
 710  *      Return an allocated SCB to the host free list
 711  */
 712
 713 static void initio_release_scb(struct initio_host * host, struct scsi_ctrl_blk * cmnd)
 714 {
 715         unsigned long flags;
 716
 717 #if DEBUG_QUEUE
 718         printk("Release SCB %p; ", cmnd);
 719 #endif
 720         spin_lock_irqsave(&(host->avail_lock), flags);
 721         cmnd->srb = NULL;
 722         cmnd->status = 0;
 723         cmnd->next = NULL;
 724         if (host->last_avail != NULL) {
 725                 host->last_avail->next = cmnd;
 726                 host->last_avail = cmnd;
 727         } else {
 728                 host->first_avail = cmnd;
 729                 host->last_avail = cmnd;
 730         }
 731         spin_unlock_irqrestore(&(host->avail_lock), flags);
 732 }
 733
 734 /***************************************************************************/
 735 static void initio_append_pend_scb(struct initio_host * host, struct scsi_ctrl_blk * scbp)
 736 {
 737
 738 #if DEBUG_QUEUE
 739         printk("Append pend SCB %p; ", scbp);
 740 #endif
 741         scbp->status = SCB_PEND;
 742         scbp->next = NULL;
 743         if (host->last_pending != NULL) {
 744                 host->last_pending->next = scbp;
 745                 host->last_pending = scbp;
 746         } else {
 747                 host->first_pending = scbp;
 748                 host->last_pending = scbp;
 749         }
 750 }
 751
 752 /***************************************************************************/
 753 static void initio_push_pend_scb(struct initio_host * host, struct scsi_ctrl_blk * scbp)
 754 {
 755
 756 #if DEBUG_QUEUE
 757         printk("Push pend SCB %p; ", scbp);
 758 #endif
 759         scbp->status = SCB_PEND;
 760         if ((scbp->next = host->first_pending) != NULL) {
 761                 host->first_pending = scbp;
 762         } else {
 763                 host->first_pending = scbp;
 764                 host->last_pending = scbp;
 765         }
 766 }
 767
 768 static struct scsi_ctrl_blk *initio_find_first_pend_scb(struct initio_host * host)
 769 {
 770         struct scsi_ctrl_blk *first;
 771
 772
 773         first = host->first_pending;
 774         while (first != NULL) {
 775                 if (first->opcode != ExecSCSI)
 776                         return first;
 777                 if (first->tagmsg == 0) {
 778                         if ((host->act_tags[first->target] == 0) &&
 779                             !(host->targets[first->target].flags & TCF_BUSY))
 780                                 return first;
 781                 } else {
 782                         if ((host->act_tags[first->target] >=
 783                           host->max_tags[first->target]) |
 784                             (host->targets[first->target].flags & TCF_BUSY)) {
 785                                 first = first->next;
 786                                 continue;
 787                         }
 788                         return first;
 789                 }
 790                 first = first->next;
 791         }
 792         return first;
 793 }
 794
 795 static void initio_unlink_pend_scb(struct initio_host * host, struct scsi_ctrl_blk * scb)
 796 {
 797         struct scsi_ctrl_blk *tmp, *prev;
 798
 799 #if DEBUG_QUEUE
 800         printk("unlink pend SCB %p; ", scb);
 801 #endif
 802
 803         prev = tmp = host->first_pending;
 804         while (tmp != NULL) {
 805                 if (scb == tmp) {       /* Unlink this SCB              */
 806                         if (tmp == host->first_pending) {
 807                                 if ((host->first_pending = tmp->next) == NULL)
 808                                         host->last_pending = NULL;
 809                         } else {
 810                                 prev->next = tmp->next;
 811                                 if (tmp == host->last_pending)
 812                                         host->last_pending = prev;
 813                         }
 814                         tmp->next = NULL;
 815                         break;
 816                 }
 817                 prev = tmp;
 818                 tmp = tmp->next;
 819         }
 820 }
 821
 822 static void initio_append_busy_scb(struct initio_host * host, struct scsi_ctrl_blk * scbp)
 823 {
 824
 825 #if DEBUG_QUEUE
 826         printk("append busy SCB %p; ", scbp);
 827 #endif
 828         if (scbp->tagmsg)
 829                 host->act_tags[scbp->target]++;
 830         else
 831                 host->targets[scbp->target].flags |= TCF_BUSY;
 832         scbp->status = SCB_BUSY;
 833         scbp->next = NULL;
 834         if (host->last_busy != NULL) {
 835                 host->last_busy->next = scbp;
 836                 host->last_busy = scbp;
 837         } else {
 838                 host->first_busy = scbp;
 839                 host->last_busy = scbp;
 840         }
 841 }
 842
 843 /***************************************************************************/
 844 static struct scsi_ctrl_blk *initio_pop_busy_scb(struct initio_host * host)
 845 {
 846         struct scsi_ctrl_blk *tmp;
 847
 848
 849         if ((tmp = host->first_busy) != NULL) {
 850                 if ((host->first_busy = tmp->next) == NULL)
 851                         host->last_busy = NULL;
 852                 tmp->next = NULL;
 853                 if (tmp->tagmsg)
 854                         host->act_tags[tmp->target]--;
 855                 else
 856                         host->targets[tmp->target].flags &= ~TCF_BUSY;
 857         }
 858 #if DEBUG_QUEUE
 859         printk("Pop busy SCB %p; ", tmp);
 860 #endif
 861         return tmp;
 862 }
 863
 864 /***************************************************************************/
 865 static void initio_unlink_busy_scb(struct initio_host * host, struct scsi_ctrl_blk * scb)
 866 {
 867         struct scsi_ctrl_blk *tmp, *prev;
 868
 869 #if DEBUG_QUEUE
 870         printk("unlink busy SCB %p; ", scb);
 871 #endif
 872
 873         prev = tmp = host->first_busy;
 874         while (tmp != NULL) {
 875                 if (scb == tmp) {       /* Unlink this SCB              */
 876                         if (tmp == host->first_busy) {
 877                                 if ((host->first_busy = tmp->next) == NULL)
 878                                         host->last_busy = NULL;
 879                         } else {
 880                                 prev->next = tmp->next;
 881                                 if (tmp == host->last_busy)
 882                                         host->last_busy = prev;
 883                         }
 884                         tmp->next = NULL;
 885                         if (tmp->tagmsg)
 886                                 host->act_tags[tmp->target]--;
 887                         else
 888                                 host->targets[tmp->target].flags &= ~TCF_BUSY;
 889                         break;
 890                 }
 891                 prev = tmp;
 892                 tmp = tmp->next;
 893         }
 894         return;
 895 }
 896
 897 struct scsi_ctrl_blk *initio_find_busy_scb(struct initio_host * host, u16 tarlun)
 898 {
 899         struct scsi_ctrl_blk *tmp, *prev;
 900         u16 scbp_tarlun;
 901
 902
 903         prev = tmp = host->first_busy;
 904         while (tmp != NULL) {
 905                 scbp_tarlun = (tmp->lun << 8) | (tmp->target);
 906                 if (scbp_tarlun == tarlun) {    /* Unlink this SCB              */
 907                         break;
 908                 }
 909                 prev = tmp;
 910                 tmp = tmp->next;
 911         }
 912 #if DEBUG_QUEUE
 913         printk("find busy SCB %p; ", tmp);
 914 #endif
 915         return tmp;
 916 }
 917
 918 static void initio_append_done_scb(struct initio_host * host, struct scsi_ctrl_blk * scbp)
 919 {
 920 #if DEBUG_QUEUE
 921         printk("append done SCB %p; ", scbp);
 922 #endif
 923
 924         scbp->status = SCB_DONE;
 925         scbp->next = NULL;
 926         if (host->last_done != NULL) {
 927                 host->last_done->next = scbp;
 928                 host->last_done = scbp;
 929         } else {
 930                 host->first_done = scbp;
 931                 host->last_done = scbp;
 932         }
 933 }
 934
 935 struct scsi_ctrl_blk *initio_find_done_scb(struct initio_host * host)
 936 {
 937         struct scsi_ctrl_blk *tmp;
 938
 939         if ((tmp = host->first_done) != NULL) {
 940                 if ((host->first_done = tmp->next) == NULL)
 941                         host->last_done = NULL;
 942                 tmp->next = NULL;
 943         }
 944 #if DEBUG_QUEUE
 945         printk("find done SCB %p; ",tmp);
 946 #endif
 947         return tmp;
 948 }
 949
 950 static int initio_abort_srb(struct initio_host * host, struct scsi_cmnd *srbp)
 951 {
 952         unsigned long flags;
 953         struct scsi_ctrl_blk *tmp, *prev;
 954
 955         spin_lock_irqsave(&host->semaph_lock, flags);
 956
 957         if ((host->semaph == 0) && (host->active == NULL)) {
 958                 /* disable Jasmin SCSI Int        */
 959                 outb(0x1F, host->addr + TUL_Mask);
 960                 spin_unlock_irqrestore(&host->semaph_lock, flags);
 961                 /* FIXME: synchronize_irq needed ? */
 962                 tulip_main(host);
 963                 spin_lock_irqsave(&host->semaph_lock, flags);
 964                 host->semaph = 1;
 965                 outb(0x0F, host->addr + TUL_Mask);
 966                 spin_unlock_irqrestore(&host->semaph_lock, flags);
 967                 return SCSI_ABORT_SNOOZE;
 968         }
 969         prev = tmp = host->first_pending;       /* Check Pend queue */
 970         while (tmp != NULL) {
 971                 /* 07/27/98 */
 972                 if (tmp->srb == srbp) {
 973                         if (tmp == host->active) {
 974                                 spin_unlock_irqrestore(&host->semaph_lock, flags);
 975                                 return SCSI_ABORT_BUSY;
 976                         } else if (tmp == host->first_pending) {
 977                                 if ((host->first_pending = tmp->next) == NULL)
 978                                         host->last_pending = NULL;
 979                         } else {
 980                                 prev->next = tmp->next;
 981                                 if (tmp == host->last_pending)
 982                                         host->last_pending = prev;
 983                         }
 984                         tmp->hastat = HOST_ABORTED;
 985                         tmp->flags |= SCF_DONE;
 986                         if (tmp->flags & SCF_POST)
 987                                 (*tmp->post) ((u8 *) host, (u8 *) tmp);
 988                         spin_unlock_irqrestore(&host->semaph_lock, flags);
 989                         return SCSI_ABORT_SUCCESS;
 990                 }
 991                 prev = tmp;
 992                 tmp = tmp->next;
 993         }
 994
 995         prev = tmp = host->first_busy;  /* Check Busy queue */
 996         while (tmp != NULL) {
 997                 if (tmp->srb == srbp) {
 998                         if (tmp == host->active) {
 999                                 spin_unlock_irqrestore(&host->semaph_lock, flags);
1000                                 return SCSI_ABORT_BUSY;
1001                         } else if (tmp->tagmsg == 0) {
1002                                 spin_unlock_irqrestore(&host->semaph_lock, flags);
1003                                 return SCSI_ABORT_BUSY;
1004                         } else {
1005                                 host->act_tags[tmp->target]--;
1006                                 if (tmp == host->first_busy) {
1007                                         if ((host->first_busy = tmp->next) == NULL)
1008                                                 host->last_busy = NULL;
1009                                 } else {
1010                                         prev->next = tmp->next;
1011                                         if (tmp == host->last_busy)
1012                                                 host->last_busy = prev;
1013                                 }
1014                                 tmp->next = NULL;
1015
1016
1017                                 tmp->hastat = HOST_ABORTED;
1018                                 tmp->flags |= SCF_DONE;
1019                                 if (tmp->flags & SCF_POST)
1020                                         (*tmp->post) ((u8 *) host, (u8 *) tmp);
1021                                 spin_unlock_irqrestore(&host->semaph_lock, flags);
1022                                 return SCSI_ABORT_SUCCESS;
1023                         }
1024                 }
1025                 prev = tmp;
1026                 tmp = tmp->next;
1027         }
1028         spin_unlock_irqrestore(&host->semaph_lock, flags);
1029         return SCSI_ABORT_NOT_RUNNING;
1030 }
1031
1032 /***************************************************************************/
1033 static int initio_bad_seq(struct initio_host * host)
1034 {
1035         struct scsi_ctrl_blk *scb;
1036
1037         printk("initio_bad_seg c=%d\n", host->index);
1038
1039         if ((scb = host->active) != NULL) {
1040                 initio_unlink_busy_scb(host, scb);
1041                 scb->hastat = HOST_BAD_PHAS;
1042                 scb->tastat = 0;
1043                 initio_append_done_scb(host, scb);
1044         }
1045         initio_stop_bm(host);
1046         initio_reset_scsi(host, 8);     /* 7/29/98 */
1047         return initio_post_scsi_rst(host);
1048 }
1049
1050
1051 /************************************************************************/
1052 static void initio_exec_scb(struct initio_host * host, struct scsi_ctrl_blk * scb)
1053 {
1054         unsigned long flags;
1055
1056         scb->mode = 0;
1057
1058         scb->sgidx = 0;
1059         scb->sgmax = scb->sglen;
1060
1061         spin_lock_irqsave(&host->semaph_lock, flags);
1062
1063         initio_append_pend_scb(host, scb);      /* Append this SCB to Pending queue */
1064
1065 /* VVVVV 07/21/98 */
1066         if (host->semaph == 1) {
1067                 /* Disable Jasmin SCSI Int */
1068                 outb(0x1F, host->addr + TUL_Mask);
1069                 host->semaph = 0;
1070                 spin_unlock_irqrestore(&host->semaph_lock, flags);
1071
1072                 tulip_main(host);
1073
1074                 spin_lock_irqsave(&host->semaph_lock, flags);
1075                 host->semaph = 1;
1076                 outb(0x0F, host->addr + TUL_Mask);
1077         }
1078         spin_unlock_irqrestore(&host->semaph_lock, flags);
1079         return;
1080 }
1081
1082 /***************************************************************************/
1083 static int initio_isr(struct initio_host * host)
1084 {
1085         if (inb(host->addr + TUL_Int) & TSS_INT_PENDING) {
1086                 if (host->semaph == 1) {
1087                         outb(0x1F, host->addr + TUL_Mask);
1088                         /* Disable Tulip SCSI Int */
1089                         host->semaph = 0;
1090
1091                         tulip_main(host);
1092
1093                         host->semaph = 1;
1094                         outb(0x0F, host->addr + TUL_Mask);
1095                         return 1;
1096                 }
1097         }
1098         return 0;
1099 }
1100
1101 static int tulip_main(struct initio_host * host)
1102 {
1103         struct scsi_ctrl_blk *scb;
1104
1105         for (;;) {
1106                 tulip_scsi(host);       /* Call tulip_scsi              */
1107
1108                 /* Walk the list of completed SCBs */
1109                 while ((scb = initio_find_done_scb(host)) != NULL) {    /* find done entry */
1110                         if (scb->tastat == INI_QUEUE_FULL) {
1111                                 host->max_tags[scb->target] =
1112                                     host->act_tags[scb->target] - 1;
1113                                 scb->tastat = 0;
1114                                 initio_append_pend_scb(host, scb);
1115                                 continue;
1116                         }
1117                         if (!(scb->mode & SCM_RSENS)) {         /* not in auto req. sense mode */
1118                                 if (scb->tastat == 2) {
1119
1120                                         /* clr sync. nego flag */
1121
1122                                         if (scb->flags & SCF_SENSE) {
1123                                                 u8 len;
1124                                                 len = scb->senselen;
1125                                                 if (len == 0)
1126                                                         len = 1;
1127                                                 scb->buflen = scb->senselen;
1128                                                 scb->bufptr = scb->senseptr;
1129                                                 scb->flags &= ~(SCF_SG | SCF_DIR);      /* for xfer_data_in */
1130                                                 /* so, we won't report wrong direction in xfer_data_in,
1131                                                    and won't report HOST_DO_DU in state_6 */
1132                                                 scb->mode = SCM_RSENS;
1133                                                 scb->ident &= 0xBF;     /* Disable Disconnect */
1134                                                 scb->tagmsg = 0;
1135                                                 scb->tastat = 0;
1136                                                 scb->cdblen = 6;
1137                                                 scb->cdb[0] = SCSICMD_RequestSense;
1138                                                 scb->cdb[1] = 0;
1139                                                 scb->cdb[2] = 0;
1140                                                 scb->cdb[3] = 0;
1141                                                 scb->cdb[4] = len;
1142                                                 scb->cdb[5] = 0;
1143                                                 initio_push_pend_scb(host, scb);
1144                                                 break;
1145                                         }
1146                                 }
1147                         } else {        /* in request sense mode */
1148
1149                                 if (scb->tastat == 2) {         /* check contition status again after sending
1150                                                                            requset sense cmd 0x3 */
1151                                         scb->hastat = HOST_BAD_PHAS;
1152                                 }
1153                                 scb->tastat = 2;
1154                         }
1155                         scb->flags |= SCF_DONE;
1156                         if (scb->flags & SCF_POST) {
1157                                 /* FIXME: only one post method and lose casts */
1158                                 (*scb->post) ((u8 *) host, (u8 *) scb);
1159                         }
1160                 }               /* while */
1161                 /* find_active: */
1162                 if (inb(host->addr + TUL_SStatus0) & TSS_INT_PENDING)
1163                         continue;
1164                 if (host->active)       /* return to OS and wait for xfer_done_ISR/Selected_ISR */
1165                         return 1;       /* return to OS, enable interrupt */
1166                 /* Check pending SCB            */
1167                 if (initio_find_first_pend_scb(host) == NULL)
1168                         return 1;       /* return to OS, enable interrupt */
1169         }                       /* End of for loop */
1170         /* statement won't reach here */
1171 }
1172
1173 static void tulip_scsi(struct initio_host * host)
1174 {
1175         struct scsi_ctrl_blk *scb;
1176         struct target_control *active_tc;
1177
1178         /* make sure to service interrupt asap */
1179         if ((host->jsstatus0 = inb(host->addr + TUL_SStatus0)) & TSS_INT_PENDING) {
1180                 host->phase = host->jsstatus0 & TSS_PH_MASK;
1181                 host->jsstatus1 = inb(host->addr + TUL_SStatus1);
1182                 host->jsint = inb(host->addr + TUL_SInt);
1183                 if (host->jsint & TSS_SCSIRST_INT) {    /* SCSI bus reset detected      */
1184                         int_initio_scsi_rst(host);
1185                         return;
1186                 }
1187                 if (host->jsint & TSS_RESEL_INT) {      /* if selected/reselected interrupt */
1188                         if (int_initio_resel(host) == 0)
1189                                 initio_next_state(host);
1190                         return;
1191                 }
1192                 if (host->jsint & TSS_SEL_TIMEOUT) {
1193                         int_initio_busfree(host);
1194                         return;
1195                 }
1196                 if (host->jsint & TSS_DISC_INT) {       /* BUS disconnection            */
1197                         int_initio_busfree(host);       /* unexpected bus free or sel timeout */
1198                         return;
1199                 }
1200                 if (host->jsint & (TSS_FUNC_COMP | TSS_BUS_SERV)) {     /* func complete or Bus service */
1201                         if ((scb = host->active) != NULL)
1202                                 initio_next_state(host);
1203                         return;
1204                 }
1205         }
1206         if (host->active != NULL)
1207                 return;
1208
1209         if ((scb = initio_find_first_pend_scb(host)) == NULL)
1210                 return;
1211
1212         /* program HBA's SCSI ID & target SCSI ID */
1213         outb((host->scsi_id << 4) | (scb->target & 0x0F),
1214                 host->addr + TUL_SScsiId);
1215         if (scb->opcode == ExecSCSI) {
1216                 active_tc = &host->targets[scb->target];
1217
1218                 if (scb->tagmsg)
1219                         active_tc->drv_flags |= TCF_DRV_EN_TAG;
1220                 else
1221                         active_tc->drv_flags &= ~TCF_DRV_EN_TAG;
1222
1223                 outb(active_tc->js_period, host->addr + TUL_SPeriod);
1224                 if ((active_tc->flags & (TCF_WDTR_DONE | TCF_NO_WDTR)) == 0) {  /* do wdtr negotiation          */
1225                         initio_select_atn_stop(host, scb);
1226                 } else {
1227                         if ((active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) == 0) {     /* do sync negotiation          */
1228                                 initio_select_atn_stop(host, scb);
1229                         } else {
1230                                 if (scb->tagmsg)
1231                                         initio_select_atn3(host, scb);
1232                                 else
1233                                         initio_select_atn(host, scb);
1234                         }
1235                 }
1236                 if (scb->flags & SCF_POLL) {
1237                         while (wait_tulip(host) != -1) {
1238                                 if (initio_next_state(host) == -1)
1239                                         break;
1240                         }
1241                 }
1242         } else if (scb->opcode == BusDevRst) {
1243                 initio_select_atn_stop(host, scb);
1244                 scb->next_state = 8;
1245                 if (scb->flags & SCF_POLL) {
1246                         while (wait_tulip(host) != -1) {
1247                                 if (initio_next_state(host) == -1)
1248                                         break;
1249                         }
1250                 }
1251         } else if (scb->opcode == AbortCmd) {
1252                 if (initio_abort_srb(host, scb->srb) != 0) {
1253                         initio_unlink_pend_scb(host, scb);
1254                         initio_release_scb(host, scb);
1255                 } else {
1256                         scb->opcode = BusDevRst;
1257                         initio_select_atn_stop(host, scb);
1258                         scb->next_state = 8;
1259                 }
1260         } else {
1261                 initio_unlink_pend_scb(host, scb);
1262                 scb->hastat = 0x16;     /* bad command */
1263                 initio_append_done_scb(host, scb);
1264         }
1265         return;
1266 }
1267
1268 /**
1269  *      initio_next_state               -       Next SCSI state
1270  *      @host: InitIO host we are processing
1271  *
1272  *      Progress the active command block along the state machine
1273  *      until we hit a state which we must wait for activity to occur.
1274  *
1275  *      Returns zero or a negative code.
1276  */
1277
1278 static int initio_next_state(struct initio_host * host)
1279 {
1280         int next;
1281
1282         next = host->active->next_state;
1283         for (;;) {
1284                 switch (next) {
1285                 case 1:
1286                         next = initio_state_1(host);
1287                         break;
1288                 case 2:
1289                         next = initio_state_2(host);
1290                         break;
1291                 case 3:
1292                         next = initio_state_3(host);
1293                         break;
1294                 case 4:
1295                         next = initio_state_4(host);
1296                         break;
1297                 case 5:
1298                         next = initio_state_5(host);
1299                         break;
1300                 case 6:
1301                         next = initio_state_6(host);
1302                         break;
1303                 case 7:
1304                         next = initio_state_7(host);
1305                         break;
1306                 case 8:
1307                         return initio_bus_device_reset(host);
1308                 default:
1309                         return initio_bad_seq(host);
1310                 }
1311                 if (next <= 0)
1312                         return next;
1313         }
1314 }
1315
1316
1317 /**
1318  *      initio_state_1          -       SCSI state machine
1319  *      @host: InitIO host we are controlling
1320  *
1321  *      Perform SCSI state processing for Select/Attention/Stop
1322  */
1323
1324 static int initio_state_1(struct initio_host * host)
1325 {
1326         struct scsi_ctrl_blk *scb = host->active;
1327         struct target_control *active_tc = host->active_tc;
1328 #if DEBUG_STATE
1329         printk("-s1-");
1330 #endif
1331
1332         /* Move the SCB from pending to busy */
1333         initio_unlink_pend_scb(host, scb);
1334         initio_append_busy_scb(host, scb);
1335
1336         outb(active_tc->sconfig0, host->addr + TUL_SConfig );
1337         /* ATN on */
1338         if (host->phase == MSG_OUT) {
1339                 outb(TSC_EN_BUS_IN | TSC_HW_RESELECT, host->addr + TUL_SCtrl1);
1340                 outb(scb->ident, host->addr + TUL_SFifo);
1341
1342                 if (scb->tagmsg) {
1343                         outb(scb->tagmsg, host->addr + TUL_SFifo);
1344                         outb(scb->tagid, host->addr + TUL_SFifo);
1345                 }
1346                 if ((active_tc->flags & (TCF_WDTR_DONE | TCF_NO_WDTR)) == 0) {
1347                         active_tc->flags |= TCF_WDTR_DONE;
1348                         outb(MSG_EXTEND, host->addr + TUL_SFifo);
1349                         outb(2, host->addr + TUL_SFifo);        /* Extended msg length */
1350                         outb(3, host->addr + TUL_SFifo);        /* Sync request */
1351                         outb(1, host->addr + TUL_SFifo);        /* Start from 16 bits */
1352                 } else if ((active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) == 0) {
1353                         active_tc->flags |= TCF_SYNC_DONE;
1354                         outb(MSG_EXTEND, host->addr + TUL_SFifo);
1355                         outb(3, host->addr + TUL_SFifo);        /* extended msg length */
1356                         outb(1, host->addr + TUL_SFifo);        /* sync request */
1357                         outb(initio_rate_tbl[active_tc->flags & TCF_SCSI_RATE], host->addr + TUL_SFifo);
1358                         outb(MAX_OFFSET, host->addr + TUL_SFifo);       /* REQ/ACK offset */
1359                 }
1360                 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1361                 if (wait_tulip(host) == -1)
1362                         return -1;
1363         }
1364         outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1365         outb((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)), host->addr + TUL_SSignal);
1366         /* Into before CDB xfer */
1367         return 3;
1368 }
1369
1370
1371 /**
1372  *      initio_state_2          -       SCSI state machine
1373  *      @host: InitIO host we are controlling
1374  *
1375  * state after selection with attention
1376  * state after selection with attention3
1377  */
1378
1379 static int initio_state_2(struct initio_host * host)
1380 {
1381         struct scsi_ctrl_blk *scb = host->active;
1382         struct target_control *active_tc = host->active_tc;
1383 #if DEBUG_STATE
1384         printk("-s2-");
1385 #endif
1386
1387         initio_unlink_pend_scb(host, scb);
1388         initio_append_busy_scb(host, scb);
1389
1390         outb(active_tc->sconfig0, host->addr + TUL_SConfig);
1391
1392         if (host->jsstatus1 & TSS_CMD_PH_CMP)
1393                 return 4;
1394
1395         outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1396         outb((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)), host->addr + TUL_SSignal);
1397         /* Into before CDB xfer */
1398         return 3;
1399 }
1400
1401 /**
1402  *      initio_state_3          -       SCSI state machine
1403  *      @host: InitIO host we are controlling
1404  *
1405  * state before CDB xfer is done
1406  */
1407
1408 static int initio_state_3(struct initio_host * host)
1409 {
1410         struct scsi_ctrl_blk *scb = host->active;
1411         struct target_control *active_tc = host->active_tc;
1412         int i;
1413
1414 #if DEBUG_STATE
1415         printk("-s3-");
1416 #endif
1417         for (;;) {
1418                 switch (host->phase) {
1419                 case CMD_OUT:   /* Command out phase            */
1420                         for (i = 0; i < (int) scb->cdblen; i++)
1421                                 outb(scb->cdb[i], host->addr + TUL_SFifo);
1422                         outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1423                         if (wait_tulip(host) == -1)
1424                                 return -1;
1425                         if (host->phase == CMD_OUT)
1426                                 return initio_bad_seq(host);
1427                         return 4;
1428
1429                 case MSG_IN:    /* Message in phase             */
1430                         scb->next_state = 3;
1431                         if (initio_msgin(host) == -1)
1432                                 return -1;
1433                         break;
1434
1435                 case STATUS_IN: /* Status phase                 */
1436                         if (initio_status_msg(host) == -1)
1437                                 return -1;
1438                         break;
1439
1440                 case MSG_OUT:   /* Message out phase            */
1441                         if (active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) {
1442                                 outb(MSG_NOP, host->addr + TUL_SFifo);          /* msg nop */
1443                                 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1444                                 if (wait_tulip(host) == -1)
1445                                         return -1;
1446                         } else {
1447                                 active_tc->flags |= TCF_SYNC_DONE;
1448
1449                                 outb(MSG_EXTEND, host->addr + TUL_SFifo);
1450                                 outb(3, host->addr + TUL_SFifo);        /* ext. msg len */
1451                                 outb(1, host->addr + TUL_SFifo);        /* sync request */
1452                                 outb(initio_rate_tbl[active_tc->flags & TCF_SCSI_RATE], host->addr + TUL_SFifo);
1453                                 outb(MAX_OFFSET, host->addr + TUL_SFifo);       /* REQ/ACK offset */
1454                                 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1455                                 if (wait_tulip(host) == -1)
1456                                         return -1;
1457                                 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1458                                 outb(inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7), host->addr + TUL_SSignal);
1459
1460                         }
1461                         break;
1462                 default:
1463                         return initio_bad_seq(host);
1464                 }
1465         }
1466 }
1467
1468 /**
1469  *      initio_state_4          -       SCSI state machine
1470  *      @host: InitIO host we are controlling
1471  *
1472  *      SCSI state machine. State 4
1473  */
1474
1475 static int initio_state_4(struct initio_host * host)
1476 {
1477         struct scsi_ctrl_blk *scb = host->active;
1478
1479 #if DEBUG_STATE
1480         printk("-s4-");
1481 #endif
1482         if ((scb->flags & SCF_DIR) == SCF_NO_XF) {
1483                 return 6;       /* Go to state 6 (After data) */
1484         }
1485         for (;;) {
1486                 if (scb->buflen == 0)
1487                         return 6;
1488
1489                 switch (host->phase) {
1490
1491                 case STATUS_IN: /* Status phase                 */
1492                         if ((scb->flags & SCF_DIR) != 0)        /* if direction bit set then report data underrun */
1493                                 scb->hastat = HOST_DO_DU;
1494                         if ((initio_status_msg(host)) == -1)
1495                                 return -1;
1496                         break;
1497
1498                 case MSG_IN:    /* Message in phase             */
1499                         scb->next_state = 0x4;
1500                         if (initio_msgin(host) == -1)
1501                                 return -1;
1502                         break;
1503
1504                 case MSG_OUT:   /* Message out phase            */
1505                         if (host->jsstatus0 & TSS_PAR_ERROR) {
1506                                 scb->buflen = 0;
1507                                 scb->hastat = HOST_DO_DU;
1508                                 if (initio_msgout_ide(host) == -1)
1509                                         return -1;
1510                                 return 6;
1511                         } else {
1512                                 outb(MSG_NOP, host->addr + TUL_SFifo);          /* msg nop */
1513                                 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1514                                 if (wait_tulip(host) == -1)
1515                                         return -1;
1516                         }
1517                         break;
1518
1519                 case DATA_IN:   /* Data in phase                */
1520                         return initio_xfer_data_in(host);
1521
1522                 case DATA_OUT:  /* Data out phase               */
1523                         return initio_xfer_data_out(host);
1524
1525                 default:
1526                         return initio_bad_seq(host);
1527                 }
1528         }
1529 }
1530
1531
1532 /**
1533  *      initio_state_5          -       SCSI state machine
1534  *      @host: InitIO host we are controlling
1535  *
1536  *      State after dma xfer done or phase change before xfer done
1537  */
1538
1539 static int initio_state_5(struct initio_host * host)
1540 {
1541         struct scsi_ctrl_blk *scb = host->active;
1542         long cnt, xcnt;         /* cannot use unsigned !! code: if (xcnt < 0) */
1543
1544 #if DEBUG_STATE
1545         printk("-s5-");
1546 #endif
1547         /*------ get remaining count -------*/
1548         cnt = inl(host->addr + TUL_SCnt0) & 0x0FFFFFF;
1549
1550         if (inb(host->addr + TUL_XCmd) & 0x20) {
1551                 /* ----------------------- DATA_IN ----------------------------- */
1552                 /* check scsi parity error */
1553                 if (host->jsstatus0 & TSS_PAR_ERROR)
1554                         scb->hastat = HOST_DO_DU;
1555                 if (inb(host->addr + TUL_XStatus) & XPEND) {    /* DMA xfer pending, Send STOP  */
1556                         /* tell Hardware  scsi xfer has been terminated */
1557                         outb(inb(host->addr + TUL_XCtrl) | 0x80, host->addr + TUL_XCtrl);
1558                         /* wait until DMA xfer not pending */
1559                         while (inb(host->addr + TUL_XStatus) & XPEND)
1560                                 cpu_relax();
1561                 }
1562         } else {
1563                 /*-------- DATA OUT -----------*/
1564                 if ((inb(host->addr + TUL_SStatus1) & TSS_XFER_CMP) == 0) {
1565                         if (host->active_tc->js_period & TSC_WIDE_SCSI)
1566                                 cnt += (inb(host->addr + TUL_SFifoCnt) & 0x1F) << 1;
1567                         else
1568                                 cnt += (inb(host->addr + TUL_SFifoCnt) & 0x1F);
1569                 }
1570                 if (inb(host->addr + TUL_XStatus) & XPEND) {    /* if DMA xfer is pending, abort DMA xfer */
1571                         outb(TAX_X_ABT, host->addr + TUL_XCmd);
1572                         /* wait Abort DMA xfer done */
1573                         while ((inb(host->addr + TUL_Int) & XABT) == 0)
1574                                 cpu_relax();
1575                 }
1576                 if ((cnt == 1) && (host->phase == DATA_OUT)) {
1577                         outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1578                         if (wait_tulip(host) == -1)
1579                                 return -1;
1580                         cnt = 0;
1581                 } else {
1582                         if ((inb(host->addr + TUL_SStatus1) & TSS_XFER_CMP) == 0)
1583                                 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1584                 }
1585         }
1586         if (cnt == 0) {
1587                 scb->buflen = 0;
1588                 return 6;       /* After Data */
1589         }
1590         /* Update active data pointer */
1591         xcnt = (long) scb->buflen - cnt;        /* xcnt== bytes already xferred */
1592         scb->buflen = (u32) cnt;                /* cnt == bytes left to be xferred */
1593         if (scb->flags & SCF_SG) {
1594                 struct sg_entry *sgp;
1595                 unsigned long i;
1596
1597                 sgp = &scb->sglist[scb->sgidx];
1598                 for (i = scb->sgidx; i < scb->sgmax; sgp++, i++) {
1599                         xcnt -= (long) sgp->len;
1600                         if (xcnt < 0) {         /* this sgp xfer half done */
1601                                 xcnt += (long) sgp->len;        /* xcnt == bytes xferred in this sgp */
1602                                 sgp->data += (u32) xcnt;        /* new ptr to be xfer */
1603                                 sgp->len -= (u32) xcnt; /* new len to be xfer */
1604                                 scb->bufptr += ((u32) (i - scb->sgidx) << 3);
1605                                 /* new SG table ptr */
1606                                 scb->sglen = (u8) (scb->sgmax - i);
1607                                 /* new SG table len */
1608                                 scb->sgidx = (u16) i;
1609                                 /* for next disc and come in this loop */
1610                                 return 4;       /* Go to state 4                */
1611                         }
1612                         /* else (xcnt >= 0 , i.e. this sgp already xferred */
1613                 }               /* for */
1614                 return 6;       /* Go to state 6                */
1615         } else {
1616                 scb->bufptr += (u32) xcnt;
1617         }
1618         return 4;               /* Go to state 4                */
1619 }
1620
1621 /**
1622  *      initio_state_6          -       SCSI state machine
1623  *      @host: InitIO host we are controlling
1624  *
1625  *      State after Data phase
1626  */
1627
1628 static int initio_state_6(struct initio_host * host)
1629 {
1630         struct scsi_ctrl_blk *scb = host->active;
1631
1632 #if DEBUG_STATE
1633         printk("-s6-");
1634 #endif
1635         for (;;) {
1636                 switch (host->phase) {
1637                 case STATUS_IN: /* Status phase                 */
1638                         if ((initio_status_msg(host)) == -1)
1639                                 return -1;
1640                         break;
1641
1642                 case MSG_IN:    /* Message in phase             */
1643                         scb->next_state = 6;
1644                         if ((initio_msgin(host)) == -1)
1645                                 return -1;
1646                         break;
1647
1648                 case MSG_OUT:   /* Message out phase            */
1649                         outb(MSG_NOP, host->addr + TUL_SFifo);          /* msg nop */
1650                         outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1651                         if (wait_tulip(host) == -1)
1652                                 return -1;
1653                         break;
1654
1655                 case DATA_IN:   /* Data in phase                */
1656                         return initio_xpad_in(host);
1657
1658                 case DATA_OUT:  /* Data out phase               */
1659                         return initio_xpad_out(host);
1660
1661                 default:
1662                         return initio_bad_seq(host);
1663                 }
1664         }
1665 }
1666
1667 /**
1668  *      initio_state_7          -       SCSI state machine
1669  *      @host: InitIO host we are controlling
1670  *
1671  */
1672
1673 int initio_state_7(struct initio_host * host)
1674 {
1675         int cnt, i;
1676
1677 #if DEBUG_STATE
1678         printk("-s7-");
1679 #endif
1680         /* flush SCSI FIFO */
1681         cnt = inb(host->addr + TUL_SFifoCnt) & 0x1F;
1682         if (cnt) {
1683                 for (i = 0; i < cnt; i++)
1684                         inb(host->addr + TUL_SFifo);
1685         }
1686         switch (host->phase) {
1687         case DATA_IN:           /* Data in phase                */
1688         case DATA_OUT:          /* Data out phase               */
1689                 return initio_bad_seq(host);
1690         default:
1691                 return 6;       /* Go to state 6                */
1692         }
1693 }
1694
1695 /**
1696  *      initio_xfer_data_in     -       Commence data input
1697  *      @host: InitIO host in use
1698  *
1699  *      Commence a block of data transfer. The transfer itself will
1700  *      be managed by the controller and we will get a completion (or
1701  *      failure) interrupt.
1702  */
1703 static int initio_xfer_data_in(struct initio_host * host)
1704 {
1705         struct scsi_ctrl_blk *scb = host->active;
1706
1707         if ((scb->flags & SCF_DIR) == SCF_DOUT)
1708                 return 6;       /* wrong direction */
1709
1710         outl(scb->buflen, host->addr + TUL_SCnt0);
1711         outb(TSC_XF_DMA_IN, host->addr + TUL_SCmd);     /* 7/25/95 */
1712
1713         if (scb->flags & SCF_SG) {      /* S/G xfer */
1714                 outl(((u32) scb->sglen) << 3, host->addr + TUL_XCntH);
1715                 outl(scb->bufptr, host->addr + TUL_XAddH);
1716                 outb(TAX_SG_IN, host->addr + TUL_XCmd);
1717         } else {
1718                 outl(scb->buflen, host->addr + TUL_XCntH);
1719                 outl(scb->bufptr, host->addr + TUL_XAddH);
1720                 outb(TAX_X_IN, host->addr + TUL_XCmd);
1721         }
1722         scb->next_state = 0x5;
1723         return 0;               /* return to OS, wait xfer done , let jas_isr come in */
1724 }
1725
1726 /**
1727  *      initio_xfer_data_out    -       Commence data output
1728  *      @host: InitIO host in use
1729  *
1730  *      Commence a block of data transfer. The transfer itself will
1731  *      be managed by the controller and we will get a completion (or
1732  *      failure) interrupt.
1733  */
1734
1735 static int initio_xfer_data_out(struct initio_host * host)
1736 {
1737         struct scsi_ctrl_blk *scb = host->active;
1738
1739         if ((scb->flags & SCF_DIR) == SCF_DIN)
1740                 return 6;       /* wrong direction */
1741
1742         outl(scb->buflen, host->addr + TUL_SCnt0);
1743         outb(TSC_XF_DMA_OUT, host->addr + TUL_SCmd);
1744
1745         if (scb->flags & SCF_SG) {      /* S/G xfer */
1746                 outl(((u32) scb->sglen) << 3, host->addr + TUL_XCntH);
1747                 outl(scb->bufptr, host->addr + TUL_XAddH);
1748                 outb(TAX_SG_OUT, host->addr + TUL_XCmd);
1749         } else {
1750                 outl(scb->buflen, host->addr + TUL_XCntH);
1751                 outl(scb->bufptr, host->addr + TUL_XAddH);
1752                 outb(TAX_X_OUT, host->addr + TUL_XCmd);
1753         }
1754
1755         scb->next_state = 0x5;
1756         return 0;               /* return to OS, wait xfer done , let jas_isr come in */
1757 }
1758
1759 int initio_xpad_in(struct initio_host * host)
1760 {
1761         struct scsi_ctrl_blk *scb = host->active;
1762         struct target_control *active_tc = host->active_tc;
1763
1764         if ((scb->flags & SCF_DIR) != SCF_NO_DCHK)
1765                 scb->hastat = HOST_DO_DU;       /* over run             */
1766         for (;;) {
1767                 if (active_tc->js_period & TSC_WIDE_SCSI)
1768                         outl(2, host->addr + TUL_SCnt0);
1769                 else
1770                         outl(1, host->addr + TUL_SCnt0);
1771
1772                 outb(TSC_XF_FIFO_IN, host->addr + TUL_SCmd);
1773                 if (wait_tulip(host) == -1)
1774                         return -1;
1775                 if (host->phase != DATA_IN) {
1776                         outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1777                         return 6;
1778                 }
1779                 inb(host->addr + TUL_SFifo);
1780         }
1781 }
1782
1783 int initio_xpad_out(struct initio_host * host)
1784 {
1785         struct scsi_ctrl_blk *scb = host->active;
1786         struct target_control *active_tc = host->active_tc;
1787
1788         if ((scb->flags & SCF_DIR) != SCF_NO_DCHK)
1789                 scb->hastat = HOST_DO_DU;       /* over run             */
1790         for (;;) {
1791                 if (active_tc->js_period & TSC_WIDE_SCSI)
1792                         outl(2, host->addr + TUL_SCnt0);
1793                 else
1794                         outl(1, host->addr + TUL_SCnt0);
1795
1796                 outb(0, host->addr + TUL_SFifo);
1797                 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1798                 if ((wait_tulip(host)) == -1)
1799                         return -1;
1800                 if (host->phase != DATA_OUT) {  /* Disable wide CPU to allow read 16 bits */
1801                         outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1);
1802                         outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1803                         return 6;
1804                 }
1805         }
1806 }
1807
1808 int initio_status_msg(struct initio_host * host)
1809 {                               /* status & MSG_IN */
1810         struct scsi_ctrl_blk *scb = host->active;
1811         u8 msg;
1812
1813         outb(TSC_CMD_COMP, host->addr + TUL_SCmd);
1814         if (wait_tulip(host) == -1)
1815                 return -1;
1816
1817         /* get status */
1818         scb->tastat = inb(host->addr + TUL_SFifo);
1819
1820         if (host->phase == MSG_OUT) {
1821                 if (host->jsstatus0 & TSS_PAR_ERROR)
1822                         outb(MSG_PARITY, host->addr + TUL_SFifo);
1823                 else
1824                         outb(MSG_NOP, host->addr + TUL_SFifo);
1825                 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1826                 return wait_tulip(host);
1827         }
1828         if (host->phase == MSG_IN) {
1829                 msg = inb(host->addr + TUL_SFifo);
1830                 if (host->jsstatus0 & TSS_PAR_ERROR) {  /* Parity error                 */
1831                         if ((initio_msgin_accept(host)) == -1)
1832                                 return -1;
1833                         if (host->phase != MSG_OUT)
1834                                 return initio_bad_seq(host);
1835                         outb(MSG_PARITY, host->addr + TUL_SFifo);
1836                         outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1837                         return wait_tulip(host);
1838                 }
1839                 if (msg == 0) { /* Command complete             */
1840
1841                         if ((scb->tastat & 0x18) == 0x10)       /* No link support              */
1842                                 return initio_bad_seq(host);
1843                         outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1844                         outb(TSC_MSG_ACCEPT, host->addr + TUL_SCmd);
1845                         return initio_wait_done_disc(host);
1846
1847                 }
1848                 if (msg == MSG_LINK_COMP || msg == MSG_LINK_FLAG) {
1849                         if ((scb->tastat & 0x18) == 0x10)
1850                                 return initio_msgin_accept(host);
1851                 }
1852         }
1853         return initio_bad_seq(host);
1854 }
1855
1856
1857 /* scsi bus free */
1858 int int_initio_busfree(struct initio_host * host)
1859 {
1860         struct scsi_ctrl_blk *scb = host->active;
1861
1862         if (scb != NULL) {
1863                 if (scb->status & SCB_SELECT) {         /* selection timeout */
1864                         initio_unlink_pend_scb(host, scb);
1865                         scb->hastat = HOST_SEL_TOUT;
1866                         initio_append_done_scb(host, scb);
1867                 } else {        /* Unexpected bus free          */
1868                         initio_unlink_busy_scb(host, scb);
1869                         scb->hastat = HOST_BUS_FREE;
1870                         initio_append_done_scb(host, scb);
1871                 }
1872                 host->active = NULL;
1873                 host->active_tc = NULL;
1874         }
1875         outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);          /* Flush SCSI FIFO  */
1876         outb(TSC_INITDEFAULT, host->addr + TUL_SConfig);
1877         outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1); /* Enable HW reselect       */
1878         return -1;
1879 }
1880
1881
1882 /**
1883  *      int_initio_scsi_rst     -       SCSI reset occurred
1884  *      @host: Host seeing the reset
1885  *
1886  *      A SCSI bus reset has occurred. Clean up any pending transfer
1887  *      the hardware is doing by DMA and then abort all active and
1888  *      disconnected commands. The mid layer should sort the rest out
1889  *      for us
1890  */
1891
1892 static int int_initio_scsi_rst(struct initio_host * host)
1893 {
1894         struct scsi_ctrl_blk *scb;
1895         int i;
1896
1897         /* if DMA xfer is pending, abort DMA xfer */
1898         if (inb(host->addr + TUL_XStatus) & 0x01) {
1899                 outb(TAX_X_ABT | TAX_X_CLR_FIFO, host->addr + TUL_XCmd);
1900                 /* wait Abort DMA xfer done */
1901                 while ((inb(host->addr + TUL_Int) & 0x04) == 0)
1902                         cpu_relax();
1903                 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1904         }
1905         /* Abort all active & disconnected scb */
1906         while ((scb = initio_pop_busy_scb(host)) != NULL) {
1907                 scb->hastat = HOST_BAD_PHAS;
1908                 initio_append_done_scb(host, scb);
1909         }
1910         host->active = NULL;
1911         host->active_tc = NULL;
1912
1913         /* clr sync nego. done flag */
1914         for (i = 0; i < host->max_tar; i++)
1915                 host->targets[i].flags &= ~(TCF_SYNC_DONE | TCF_WDTR_DONE);
1916         return -1;
1917 }
1918
1919 /**
1920  *      int_initio_scsi_resel   -       Reselection occured
1921  *      @host: InitIO host adapter
1922  *
1923  *      A SCSI reselection event has been signalled and the interrupt
1924  *      is now being processed. Work out which command block needs attention
1925  *      and continue processing that command.
1926  */
1927
1928 int int_initio_resel(struct initio_host * host)
1929 {
1930         struct scsi_ctrl_blk *scb;
1931         struct target_control *active_tc;
1932         u8 tag, msg = 0;
1933         u8 tar, lun;
1934
1935         if ((scb = host->active) != NULL) {
1936                 /* FIXME: Why check and not just clear ? */
1937                 if (scb->status & SCB_SELECT)           /* if waiting for selection complete */
1938                         scb->status &= ~SCB_SELECT;
1939                 host->active = NULL;
1940         }
1941         /* --------- get target id---------------------- */
1942         tar = inb(host->addr + TUL_SBusId);
1943         /* ------ get LUN from Identify message----------- */
1944         lun = inb(host->addr + TUL_SIdent) & 0x0F;
1945         /* 07/22/98 from 0x1F -> 0x0F */
1946         active_tc = &host->targets[tar];
1947         host->active_tc = active_tc;
1948         outb(active_tc->sconfig0, host->addr + TUL_SConfig);
1949         outb(active_tc->js_period, host->addr + TUL_SPeriod);
1950
1951         /* ------------- tag queueing ? ------------------- */
1952         if (active_tc->drv_flags & TCF_DRV_EN_TAG) {
1953                 if ((initio_msgin_accept(host)) == -1)
1954                         return -1;
1955                 if (host->phase != MSG_IN)
1956                         goto no_tag;
1957                 outl(1, host->addr + TUL_SCnt0);
1958                 outb(TSC_XF_FIFO_IN, host->addr + TUL_SCmd);
1959                 if (wait_tulip(host) == -1)
1960                         return -1;
1961                 msg = inb(host->addr + TUL_SFifo);      /* Read Tag Message    */
1962
1963                 if (msg < MSG_STAG || msg > MSG_OTAG)           /* Is simple Tag      */
1964                         goto no_tag;
1965
1966                 if (initio_msgin_accept(host) == -1)
1967                         return -1;
1968
1969                 if (host->phase != MSG_IN)
1970                         goto no_tag;
1971
1972                 outl(1, host->addr + TUL_SCnt0);
1973                 outb(TSC_XF_FIFO_IN, host->addr + TUL_SCmd);
1974                 if (wait_tulip(host) == -1)
1975                         return -1;
1976                 tag = inb(host->addr + TUL_SFifo);      /* Read Tag ID       */
1977                 scb = host->scb + tag;
1978                 if (scb->target != tar || scb->lun != lun) {
1979                         return initio_msgout_abort_tag(host);
1980                 }
1981                 if (scb->status != SCB_BUSY) {  /* 03/24/95             */
1982                         return initio_msgout_abort_tag(host);
1983                 }
1984                 host->active = scb;
1985                 if ((initio_msgin_accept(host)) == -1)
1986                         return -1;
1987         } else {                /* No tag               */
1988               no_tag:
1989                 if ((scb = initio_find_busy_scb(host, tar | (lun << 8))) == NULL) {
1990                         return initio_msgout_abort_targ(host);
1991                 }
1992                 host->active = scb;
1993                 if (!(active_tc->drv_flags & TCF_DRV_EN_TAG)) {
1994                         if ((initio_msgin_accept(host)) == -1)
1995                                 return -1;
1996                 }
1997         }
1998         return 0;
1999 }
2000
2001 /**
2002  *      int_initio_bad_seq              -       out of phase
2003  *      @host: InitIO host flagging event
2004  *
2005  *      We have ended up out of phase somehow. Reset the host controller
2006  *      and throw all our toys out of the pram. Let the midlayer clean up
2007  */
2008
2009 static int int_initio_bad_seq(struct initio_host * host)
2010 {                               /* target wrong phase           */
2011         struct scsi_ctrl_blk *scb;
2012         int i;
2013
2014         initio_reset_scsi(host, 10);
2015
2016         while ((scb = initio_pop_busy_scb(host)) != NULL) {
2017                 scb->hastat = HOST_BAD_PHAS;
2018                 initio_append_done_scb(host, scb);
2019         }
2020         for (i = 0; i < host->max_tar; i++)
2021                 host->targets[i].flags &= ~(TCF_SYNC_DONE | TCF_WDTR_DONE);
2022         return -1;
2023 }
2024
2025
2026 /**
2027  *      initio_msgout_abort_targ                -       abort a tag
2028  *      @host: InitIO host
2029  *
2030  *      Abort when the target/lun does not match or when our SCB is not
2031  *      busy. Used by untagged commands.
2032  */
2033
2034 static int initio_msgout_abort_targ(struct initio_host * host)
2035 {
2036
2037         outb(((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), host->addr + TUL_SSignal);
2038         if (initio_msgin_accept(host) == -1)
2039                 return -1;
2040         if (host->phase != MSG_OUT)
2041                 return initio_bad_seq(host);
2042
2043         outb(MSG_ABORT, host->addr + TUL_SFifo);
2044         outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
2045
2046         return initio_wait_disc(host);
2047 }
2048
2049 /**
2050  *      initio_msgout_abort_tag         -       abort a tag
2051  *      @host: InitIO host
2052  *
2053  *      Abort when the target/lun does not match or when our SCB is not
2054  *      busy. Used for tagged commands.
2055  */
2056
2057 static int initio_msgout_abort_tag(struct initio_host * host)
2058 {
2059
2060         outb(((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), host->addr + TUL_SSignal);
2061         if (initio_msgin_accept(host) == -1)
2062                 return -1;
2063         if (host->phase != MSG_OUT)
2064                 return initio_bad_seq(host);
2065
2066         outb(MSG_ABORT_TAG, host->addr + TUL_SFifo);
2067         outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
2068
2069         return initio_wait_disc(host);
2070
2071 }
2072
2073 /**
2074  *      initio_msgin            -       Message in
2075  *      @host: InitIO Host
2076  *
2077  *      Process incoming message
2078  */
2079 static int initio_msgin(struct initio_host * host)
2080 {
2081         struct target_control *active_tc;
2082
2083         for (;;) {
2084                 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
2085
2086                 outl(1, host->addr + TUL_SCnt0);
2087                 outb(TSC_XF_FIFO_IN, host->addr + TUL_SCmd);
2088                 if (wait_tulip(host) == -1)
2089                         return -1;
2090
2091                 switch (inb(host->addr + TUL_SFifo)) {
2092                 case MSG_DISC:  /* Disconnect msg */
2093                         outb(TSC_MSG_ACCEPT, host->addr + TUL_SCmd);
2094                         return initio_wait_disc(host);
2095                 case MSG_SDP:
2096                 case MSG_RESTORE:
2097                 case MSG_NOP:
2098                         initio_msgin_accept(host);
2099                         break;
2100                 case MSG_REJ:   /* Clear ATN first              */
2101                         outb((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)),
2102                                 host->addr + TUL_SSignal);
2103                         active_tc = host->active_tc;
2104                         if ((active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) == 0)       /* do sync nego */
2105                                 outb(((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN),
2106                                         host->addr + TUL_SSignal);
2107                         initio_msgin_accept(host);
2108                         break;
2109                 case MSG_EXTEND:        /* extended msg */
2110                         initio_msgin_extend(host);
2111                         break;
2112                 case MSG_IGNOREWIDE:
2113                         initio_msgin_accept(host);
2114                         break;
2115                 case MSG_COMP:
2116                         outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
2117                         outb(TSC_MSG_ACCEPT, host->addr + TUL_SCmd);
2118                         return initio_wait_done_disc(host);
2119                 default:
2120                         initio_msgout_reject(host);
2121                         break;
2122                 }
2123                 if (host->phase != MSG_IN)
2124                         return host->phase;
2125         }
2126         /* statement won't reach here */
2127 }
2128
2129 static int initio_msgout_reject(struct initio_host * host)
2130 {
2131         outb(((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), host->addr + TUL_SSignal);
2132
2133         if (initio_msgin_accept(host) == -1)
2134                 return -1;
2135
2136         if (host->phase == MSG_OUT) {
2137                 outb(MSG_REJ, host->addr + TUL_SFifo);          /* Msg reject           */
2138                 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
2139                 return wait_tulip(host);
2140         }
2141         return host->phase;
2142 }
2143
2144 static int initio_msgout_ide(struct initio_host * host)
2145 {
2146         outb(MSG_IDE, host->addr + TUL_SFifo);          /* Initiator Detected Error */
2147         outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
2148         return wait_tulip(host);
2149 }
2150
2151 static int initio_msgin_extend(struct initio_host * host)
2152 {
2153         u8 len, idx;
2154
2155         if (initio_msgin_accept(host) != MSG_IN)
2156                 return host->phase;
2157
2158         /* Get extended msg length      */
2159         outl(1, host->addr + TUL_SCnt0);
2160         outb(TSC_XF_FIFO_IN, host->addr + TUL_SCmd);
2161         if (wait_tulip(host) == -1)
2162                 return -1;
2163
2164         len = inb(host->addr + TUL_SFifo);
2165         host->msg[0] = len;
2166         for (idx = 1; len != 0; len--) {
2167
2168                 if ((initio_msgin_accept(host)) != MSG_IN)
2169                         return host->phase;
2170                 outl(1, host->addr + TUL_SCnt0);
2171                 outb(TSC_XF_FIFO_IN, host->addr + TUL_SCmd);
2172                 if (wait_tulip(host) == -1)
2173                         return -1;
2174                 host->msg[idx++] = inb(host->addr + TUL_SFifo);
2175         }
2176         if (host->msg[1] == 1) {                /* if it's synchronous data transfer request */
2177                 u8 r;
2178                 if (host->msg[0] != 3)  /* if length is not right */
2179                         return initio_msgout_reject(host);
2180                 if (host->active_tc->flags & TCF_NO_SYNC_NEGO) {        /* Set OFFSET=0 to do async, nego back */
2181                         host->msg[3] = 0;
2182                 } else {
2183                         if (initio_msgin_sync(host) == 0 &&
2184                             (host->active_tc->flags & TCF_SYNC_DONE)) {
2185                                 initio_sync_done(host);
2186                                 return initio_msgin_accept(host);
2187                         }
2188                 }
2189
2190                 r = inb(host->addr + TUL_SSignal);
2191                 outb((r & (TSC_SET_ACK | 7)) | TSC_SET_ATN,
2192                         host->addr + TUL_SSignal);
2193                 if (initio_msgin_accept(host) != MSG_OUT)
2194                         return host->phase;
2195                 /* sync msg out */
2196                 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
2197
2198                 initio_sync_done(host);
2199
2200                 outb(MSG_EXTEND, host->addr + TUL_SFifo);
2201                 outb(3, host->addr + TUL_SFifo);
2202                 outb(1, host->addr + TUL_SFifo);
2203                 outb(host->msg[2], host->addr + TUL_SFifo);
2204                 outb(host->msg[3], host->addr + TUL_SFifo);
2205                 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
2206                 return wait_tulip(host);
2207         }
2208         if (host->msg[0] != 2 || host->msg[1] != 3)
2209                 return initio_msgout_reject(host);
2210         /* if it's WIDE DATA XFER REQ   */
2211         if (host->active_tc->flags & TCF_NO_WDTR) {
2212                 host->msg[2] = 0;
2213         } else {
2214                 if (host->msg[2] > 2)   /* > 32 bits            */
2215                         return initio_msgout_reject(host);
2216                 if (host->msg[2] == 2) {                /* == 32                */
2217                         host->msg[2] = 1;
2218                 } else {
2219                         if ((host->active_tc->flags & TCF_NO_WDTR) == 0) {
2220                                 wdtr_done(host);
2221                                 if ((host->active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) == 0)
2222                                         outb(((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), host->addr + TUL_SSignal);
2223                                 return initio_msgin_accept(host);
2224                         }
2225                 }
2226         }
2227         outb(((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), host->addr + TUL_SSignal);
2228
2229         if (initio_msgin_accept(host) != MSG_OUT)
2230                 return host->phase;
2231         /* WDTR msg out                 */
2232         outb(MSG_EXTEND, host->addr + TUL_SFifo);
2233         outb(2, host->addr + TUL_SFifo);
2234         outb(3, host->addr + TUL_SFifo);
2235         outb(host->msg[2], host->addr + TUL_SFifo);
2236         outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
2237         return wait_tulip(host);
2238 }
2239
2240 static int initio_msgin_sync(struct initio_host * host)
2241 {
2242         char default_period;
2243
2244         default_period = initio_rate_tbl[host->active_tc->flags & TCF_SCSI_RATE];
2245         if (host->msg[3] > MAX_OFFSET) {
2246                 host->msg[3] = MAX_OFFSET;
2247                 if (host->msg[2] < default_period) {
2248                         host->msg[2] = default_period;
2249                         return 1;
2250                 }
2251                 if (host->msg[2] >= 59) /* Change to async              */
2252                         host->msg[3] = 0;
2253                 return 1;
2254         }
2255         /* offset requests asynchronous transfers ? */
2256         if (host->msg[3] == 0) {
2257                 return 0;
2258         }
2259         if (host->msg[2] < default_period) {
2260                 host->msg[2] = default_period;
2261                 return 1;
2262         }
2263         if (host->msg[2] >= 59) {
2264                 host->msg[3] = 0;
2265                 return 1;
2266         }
2267         return 0;
2268 }
2269
2270 static int wdtr_done(struct initio_host * host)
2271 {
2272         host->active_tc->flags &= ~TCF_SYNC_DONE;
2273         host->active_tc->flags |= TCF_WDTR_DONE;
2274
2275         host->active_tc->js_period = 0;
2276         if (host->msg[2])       /* if 16 bit */
2277                 host->active_tc->js_period |= TSC_WIDE_SCSI;
2278         host->active_tc->sconfig0 &= ~TSC_ALT_PERIOD;
2279         outb(host->active_tc->sconfig0, host->addr + TUL_SConfig);
2280         outb(host->active_tc->js_period, host->addr + TUL_SPeriod);
2281
2282         return 1;
2283 }
2284
2285 static int initio_sync_done(struct initio_host * host)
2286 {
2287         int i;
2288
2289         host->active_tc->flags |= TCF_SYNC_DONE;
2290
2291         if (host->msg[3]) {
2292                 host->active_tc->js_period |= host->msg[3];
2293                 for (i = 0; i < 8; i++) {
2294                         if (initio_rate_tbl[i] >= host->msg[2]) /* pick the big one */
2295                                 break;
2296                 }
2297                 host->active_tc->js_period |= (i << 4);
2298                 host->active_tc->sconfig0 |= TSC_ALT_PERIOD;
2299         }
2300         outb(host->active_tc->sconfig0, host->addr + TUL_SConfig);
2301         outb(host->active_tc->js_period, host->addr + TUL_SPeriod);
2302
2303         return -1;
2304 }
2305
2306
2307 static int initio_post_scsi_rst(struct initio_host * host)
2308 {
2309         struct scsi_ctrl_blk *scb;
2310         struct target_control *active_tc;
2311         int i;
2312
2313         host->active = NULL;
2314         host->active_tc = NULL;
2315         host->flags = 0;
2316
2317         while ((scb = initio_pop_busy_scb(host)) != NULL) {
2318                 scb->hastat = HOST_BAD_PHAS;
2319                 initio_append_done_scb(host, scb);
2320         }
2321         /* clear sync done flag         */
2322         active_tc = &host->targets[0];
2323         for (i = 0; i < host->max_tar; active_tc++, i++) {
2324                 active_tc->flags &= ~(TCF_SYNC_DONE | TCF_WDTR_DONE);
2325                 /* Initialize the sync. xfer register values to an asyn xfer */
2326                 active_tc->js_period = 0;
2327                 active_tc->sconfig0 = host->sconf1;
2328                 host->act_tags[0] = 0;  /* 07/22/98 */
2329                 host->targets[i].flags &= ~TCF_BUSY;    /* 07/22/98 */
2330         }                       /* for */
2331
2332         return -1;
2333 }
2334
2335 static void initio_select_atn_stop(struct initio_host * host, struct scsi_ctrl_blk * scb)
2336 {
2337         scb->status |= SCB_SELECT;
2338         scb->next_state = 0x1;
2339         host->active = scb;
2340         host->active_tc = &host->targets[scb->target];
2341         outb(TSC_SELATNSTOP, host->addr + TUL_SCmd);
2342 }
2343
2344
2345 static void initio_select_atn(struct initio_host * host, struct scsi_ctrl_blk * scb)
2346 {
2347         int i;
2348
2349         scb->status |= SCB_SELECT;
2350         scb->next_state = 0x2;
2351
2352         outb(scb->ident, host->addr + TUL_SFifo);
2353         for (i = 0; i < (int) scb->cdblen; i++)
2354                 outb(scb->cdb[i], host->addr + TUL_SFifo);
2355         host->active_tc = &host->targets[scb->target];
2356         host->active = scb;
2357         outb(TSC_SEL_ATN, host->addr + TUL_SCmd);
2358 }
2359
2360 static void initio_select_atn3(struct initio_host * host, struct scsi_ctrl_blk * scb)
2361 {
2362         int i;
2363
2364         scb->status |= SCB_SELECT;
2365         scb->next_state = 0x2;
2366
2367         outb(scb->ident, host->addr + TUL_SFifo);
2368         outb(scb->tagmsg, host->addr + TUL_SFifo);
2369         outb(scb->tagid, host->addr + TUL_SFifo);
2370         for (i = 0; i < scb->cdblen; i++)
2371                 outb(scb->cdb[i], host->addr + TUL_SFifo);
2372         host->active_tc = &host->targets[scb->target];
2373         host->active = scb;
2374         outb(TSC_SEL_ATN3, host->addr + TUL_SCmd);
2375 }
2376
2377 /**
2378  *      initio_bus_device_reset -        SCSI Bus Device Reset
2379  *      @host: InitIO host to reset
2380  *
2381  *      Perform a device reset and abort all pending SCBs for the
2382  *      victim device
2383  */
2384 int initio_bus_device_reset(struct initio_host * host)
2385 {
2386         struct scsi_ctrl_blk *scb = host->active;
2387         struct target_control *active_tc = host->active_tc;
2388         struct scsi_ctrl_blk *tmp, *prev;
2389         u8 tar;
2390
2391         if (host->phase != MSG_OUT)
2392                 return int_initio_bad_seq(host);        /* Unexpected phase */
2393
2394         initio_unlink_pend_scb(host, scb);
2395         initio_release_scb(host, scb);
2396
2397
2398         tar = scb->target;      /* target                       */
2399         active_tc->flags &= ~(TCF_SYNC_DONE | TCF_WDTR_DONE | TCF_BUSY);
2400         /* clr sync. nego & WDTR flags  07/22/98 */
2401
2402         /* abort all SCB with same target */
2403         prev = tmp = host->first_busy;  /* Check Busy queue */
2404         while (tmp != NULL) {
2405                 if (tmp->target == tar) {
2406                         /* unlink it */
2407                         if (tmp == host->first_busy) {
2408                                 if ((host->first_busy = tmp->next) == NULL)
2409                                         host->last_busy = NULL;
2410                         } else {
2411                                 prev->next = tmp->next;
2412                                 if (tmp == host->last_busy)
2413                                         host->last_busy = prev;
2414                         }
2415                         tmp->hastat = HOST_ABORTED;
2416                         initio_append_done_scb(host, tmp);
2417                 }
2418                 /* Previous haven't change      */
2419                 else {
2420                         prev = tmp;
2421                 }
2422                 tmp = tmp->next;
2423         }
2424         outb(MSG_DEVRST, host->addr + TUL_SFifo);
2425         outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
2426         return initio_wait_disc(host);
2427
2428 }
2429
2430 static int initio_msgin_accept(struct initio_host * host)
2431 {
2432         outb(TSC_MSG_ACCEPT, host->addr + TUL_SCmd);
2433         return wait_tulip(host);
2434 }
2435
2436 static int wait_tulip(struct initio_host * host)
2437 {
2438
2439         while (!((host->jsstatus0 = inb(host->addr + TUL_SStatus0))
2440                  & TSS_INT_PENDING))
2441                         cpu_relax();
2442
2443         host->jsint = inb(host->addr + TUL_SInt);
2444         host->phase = host->jsstatus0 & TSS_PH_MASK;
2445         host->jsstatus1 = inb(host->addr + TUL_SStatus1);
2446
2447         if (host->jsint & TSS_RESEL_INT)        /* if SCSI bus reset detected */
2448                 return int_initio_resel(host);
2449         if (host->jsint & TSS_SEL_TIMEOUT)      /* if selected/reselected timeout interrupt */
2450                 return int_initio_busfree(host);
2451         if (host->jsint & TSS_SCSIRST_INT)      /* if SCSI bus reset detected   */
2452                 return int_initio_scsi_rst(host);
2453
2454         if (host->jsint & TSS_DISC_INT) {       /* BUS disconnection            */
2455                 if (host->flags & HCF_EXPECT_DONE_DISC) {
2456                         outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); /* Flush SCSI FIFO */
2457                         initio_unlink_busy_scb(host, host->active);
2458                         host->active->hastat = 0;
2459                         initio_append_done_scb(host, host->active);
2460                         host->active = NULL;
2461                         host->active_tc = NULL;
2462                         host->flags &= ~HCF_EXPECT_DONE_DISC;
2463                         outb(TSC_INITDEFAULT, host->addr + TUL_SConfig);
2464                         outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1); /* Enable HW reselect */
2465                         return -1;
2466                 }
2467                 if (host->flags & HCF_EXPECT_DISC) {
2468                         outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); /* Flush SCSI FIFO */
2469                         host->active = NULL;
2470                         host->active_tc = NULL;
2471                         host->flags &= ~HCF_EXPECT_DISC;
2472                         outb(TSC_INITDEFAULT, host->addr + TUL_SConfig);
2473                         outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1); /* Enable HW reselect */
2474                         return -1;
2475                 }
2476                 return int_initio_busfree(host);
2477         }
2478         /* The old code really does the below. Can probably be removed */
2479         if (host->jsint & (TSS_FUNC_COMP | TSS_BUS_SERV))
2480                 return host->phase;
2481         return host->phase;
2482 }
2483
2484 static int initio_wait_disc(struct initio_host * host)
2485 {
2486         while (!((host->jsstatus0 = inb(host->addr + TUL_SStatus0)) & TSS_INT_PENDING))
2487                 cpu_relax();
2488
2489         host->jsint = inb(host->addr + TUL_SInt);
2490
2491         if (host->jsint & TSS_SCSIRST_INT)      /* if SCSI bus reset detected */
2492                 return int_initio_scsi_rst(host);
2493         if (host->jsint & TSS_DISC_INT) {       /* BUS disconnection */
2494                 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); /* Flush SCSI FIFO */
2495                 outb(TSC_INITDEFAULT, host->addr + TUL_SConfig);
2496                 outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1); /* Enable HW reselect */
2497                 host->active = NULL;
2498                 return -1;
2499         }
2500         return initio_bad_seq(host);
2501 }
2502
2503 static int initio_wait_done_disc(struct initio_host * host)
2504 {
2505         while (!((host->jsstatus0 = inb(host->addr + TUL_SStatus0))
2506                  & TSS_INT_PENDING))
2507                  cpu_relax();
2508
2509         host->jsint = inb(host->addr + TUL_SInt);
2510
2511         if (host->jsint & TSS_SCSIRST_INT)      /* if SCSI bus reset detected */
2512                 return int_initio_scsi_rst(host);
2513         if (host->jsint & TSS_DISC_INT) {       /* BUS disconnection */
2514                 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);          /* Flush SCSI FIFO */
2515                 outb(TSC_INITDEFAULT, host->addr + TUL_SConfig);
2516                 outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1);         /* Enable HW reselect */
2517                 initio_unlink_busy_scb(host, host->active);
2518
2519                 initio_append_done_scb(host, host->active);
2520                 host->active = NULL;
2521                 return -1;
2522         }
2523         return initio_bad_seq(host);
2524 }
2525
2526 /**
2527  *      i91u_intr               -       IRQ handler
2528  *      @irqno: IRQ number
2529  *      @dev_id: IRQ identifier
2530  *
2531  *      Take the relevant locks and then invoke the actual isr processing
2532  *      code under the lock.
2533  */
2534
2535 static irqreturn_t i91u_intr(int irqno, void *dev_id)
2536 {
2537         struct Scsi_Host *dev = dev_id;
2538         unsigned long flags;
2539         int r;
2540
2541         spin_lock_irqsave(dev->host_lock, flags);
2542         r = initio_isr((struct initio_host *)dev->hostdata);
2543         spin_unlock_irqrestore(dev->host_lock, flags);
2544         if (r)
2545                 return IRQ_HANDLED;
2546         else
2547                 return IRQ_NONE;
2548 }
2549
2550
2551 /**
2552  *      initio_build_scb                -       Build the mappings and SCB
2553  *      @host: InitIO host taking the command
2554  *      @cblk: Firmware command block
2555  *      @cmnd: SCSI midlayer command block
2556  *
2557  *      Translate the abstract SCSI command into a firmware command block
2558  *      suitable for feeding to the InitIO host controller. This also requires
2559  *      we build the scatter gather lists and ensure they are mapped properly.
2560  */
2561
2562 static void initio_build_scb(struct initio_host * host, struct scsi_ctrl_blk * cblk, struct scsi_cmnd * cmnd)
2563 {                               /* Create corresponding SCB     */
2564         struct scatterlist *sglist;
2565         struct sg_entry *sg;            /* Pointer to SG list           */
2566         int i, nseg;
2567         long total_len;
2568         dma_addr_t dma_addr;
2569
2570         /* Fill in the command headers */
2571         cblk->post = i91uSCBPost;       /* i91u's callback routine      */
2572         cblk->srb = cmnd;
2573         cblk->opcode = ExecSCSI;
2574         cblk->flags = SCF_POST; /* After SCSI done, call post routine */
2575         cblk->target = cmnd->device->id;
2576         cblk->lun = cmnd->device->lun;
2577         cblk->ident = cmnd->device->lun | DISC_ALLOW;
2578
2579         cblk->flags |= SCF_SENSE;       /* Turn on auto request sense   */
2580
2581         /* Map the sense buffer into bus memory */
2582         dma_addr = dma_map_single(&host->pci_dev->dev, cmnd->sense_buffer,
2583                                   SENSE_SIZE, DMA_FROM_DEVICE);
2584         cblk->senseptr = (u32)dma_addr;
2585         cblk->senselen = SENSE_SIZE;
2586         cmnd->SCp.ptr = (char *)(unsigned long)dma_addr;
2587         cblk->cdblen = cmnd->cmd_len;
2588
2589         /* Clear the returned status */
2590         cblk->hastat = 0;
2591         cblk->tastat = 0;
2592         /* Command the command */
2593         memcpy(&cblk->cdb[0], &cmnd->cmnd, cmnd->cmd_len);
2594
2595         /* Set up tags */
2596         if (cmnd->device->tagged_supported) {   /* Tag Support                  */
2597                 cblk->tagmsg = SIMPLE_QUEUE_TAG;        /* Do simple tag only   */
2598         } else {
2599                 cblk->tagmsg = 0;       /* No tag support               */
2600         }
2601
2602         /* todo handle map_sg error */
2603         nseg = scsi_dma_map(cmnd);
2604         BUG_ON(nseg < 0);
2605         if (nseg) {
2606                 dma_addr = dma_map_single(&host->pci_dev->dev, &cblk->sglist[0],
2607                                           sizeof(struct sg_entry) * TOTAL_SG_ENTRY,
2608                                           DMA_BIDIRECTIONAL);
2609                 cblk->bufptr = (u32)dma_addr;
2610                 cmnd->SCp.dma_handle = dma_addr;
2611
2612                 cblk->sglen = nseg;
2613
2614                 cblk->flags |= SCF_SG;  /* Turn on SG list flag       */
2615                 total_len = 0;
2616                 sg = &cblk->sglist[0];
2617                 scsi_for_each_sg(cmnd, sglist, cblk->sglen, i) {
2618                         sg->data = cpu_to_le32((u32)sg_dma_address(sglist));
2619                         sg->len = cpu_to_le32((u32)sg_dma_len(sglist));
2620                         total_len += sg_dma_len(sglist);
2621                         ++sg;
2622                 }
2623
2624                 cblk->buflen = (scsi_bufflen(cmnd) > total_len) ?
2625                         total_len : scsi_bufflen(cmnd);
2626         } else {        /* No data transfer required */
2627                 cblk->buflen = 0;
2628                 cblk->sglen = 0;
2629         }
2630 }
2631
2632 /**
2633  *      i91u_queuecommand       -       Queue a new command if possible
2634  *      @cmd: SCSI command block from the mid layer
2635  *      @done: Completion handler
2636  *
2637  *      Attempts to queue a new command with the host adapter. Will return
2638  *      zero if successful or indicate a host busy condition if not (which
2639  *      will cause the mid layer to call us again later with the command)
2640  */
2641
2642 static int i91u_queuecommand(struct scsi_cmnd *cmd,
2643                 void (*done)(struct scsi_cmnd *))
2644 {
2645         struct initio_host *host = (struct initio_host *) cmd->device->host->hostdata;
2646         struct scsi_ctrl_blk *cmnd;
2647
2648         cmd->scsi_done = done;
2649
2650         cmnd = initio_alloc_scb(host);
2651         if (!cmnd)
2652                 return SCSI_MLQUEUE_HOST_BUSY;
2653
2654         initio_build_scb(host, cmnd, cmd);
2655         initio_exec_scb(host, cmnd);
2656         return 0;
2657 }
2658
2659 /**
2660  *      i91u_bus_reset          -       reset the SCSI bus
2661  *      @cmnd: Command block we want to trigger the reset for
2662  *
2663  *      Initiate a SCSI bus reset sequence
2664  */
2665
2666 static int i91u_bus_reset(struct scsi_cmnd * cmnd)
2667 {
2668         struct initio_host *host;
2669
2670         host = (struct initio_host *) cmnd->device->host->hostdata;
2671
2672         spin_lock_irq(cmnd->device->host->host_lock);
2673         initio_reset_scsi(host, 0);
2674         spin_unlock_irq(cmnd->device->host->host_lock);
2675
2676         return SUCCESS;
2677 }
2678
2679 /**
2680  *      i91u_biospararm                 -       return the "logical geometry
2681  *      @sdev: SCSI device
2682  *      @dev; Matching block device
2683  *      @capacity: Sector size of drive
2684  *      @info_array: Return space for BIOS geometry
2685  *
2686  *      Map the device geometry in a manner compatible with the host
2687  *      controller BIOS behaviour.
2688  *
2689  *      FIXME: limited to 2^32 sector devices.
2690  */
2691
2692 static int i91u_biosparam(struct scsi_device *sdev, struct block_device *dev,
2693                 sector_t capacity, int *info_array)
2694 {
2695         struct initio_host *host;               /* Point to Host adapter control block */
2696         struct target_control *tc;
2697
2698         host = (struct initio_host *) sdev->host->hostdata;
2699         tc = &host->targets[sdev->id];
2700
2701         if (tc->heads) {
2702                 info_array[0] = tc->heads;
2703                 info_array[1] = tc->sectors;
2704                 info_array[2] = (unsigned long)capacity / tc->heads / tc->sectors;
2705         } else {
2706                 if (tc->drv_flags & TCF_DRV_255_63) {
2707                         info_array[0] = 255;
2708                         info_array[1] = 63;
2709                         info_array[2] = (unsigned long)capacity / 255 / 63;
2710                 } else {
2711                         info_array[0] = 64;
2712                         info_array[1] = 32;
2713                         info_array[2] = (unsigned long)capacity >> 11;
2714                 }
2715         }
2716
2717 #if defined(DEBUG_BIOSPARAM)
2718         if (i91u_debug & debug_biosparam) {
2719                 printk("bios geometry: head=%d, sec=%d, cyl=%d\n",
2720                        info_array[0], info_array[1], info_array[2]);
2721                 printk("WARNING: check, if the bios geometry is correct.\n");
2722         }
2723 #endif
2724
2725         return 0;
2726 }
2727
2728 /**
2729  *      i91u_unmap_scb          -       Unmap a command
2730  *      @pci_dev: PCI device the command is for
2731  *      @cmnd: The command itself
2732  *
2733  *      Unmap any PCI mapping/IOMMU resources allocated when the command
2734  *      was mapped originally as part of initio_build_scb
2735  */
2736
2737 static void i91u_unmap_scb(struct pci_dev *pci_dev, struct scsi_cmnd *cmnd)
2738 {
2739         /* auto sense buffer */
2740         if (cmnd->SCp.ptr) {
2741                 dma_unmap_single(&pci_dev->dev,
2742                                  (dma_addr_t)((unsigned long)cmnd->SCp.ptr),
2743                                  SENSE_SIZE, DMA_FROM_DEVICE);
2744                 cmnd->SCp.ptr = NULL;
2745         }
2746
2747         /* request buffer */
2748         if (scsi_sg_count(cmnd)) {
2749                 dma_unmap_single(&pci_dev->dev, cmnd->SCp.dma_handle,
2750                                  sizeof(struct sg_entry) * TOTAL_SG_ENTRY,
2751                                  DMA_BIDIRECTIONAL);
2752
2753                 scsi_dma_unmap(cmnd);
2754         }
2755 }
2756
2757 /**
2758  *      i91uSCBPost             -       SCSI callback
2759  *      @host: Pointer to host adapter control block.
2760  *      @cmnd: Pointer to SCSI control block.
2761  *
2762  *      This is callback routine be called when tulip finish one
2763  *      SCSI command.
2764  */
2765
2766 static void i91uSCBPost(u8 * host_mem, u8 * cblk_mem)
2767 {
2768         struct scsi_cmnd *cmnd; /* Pointer to SCSI request block */
2769         struct initio_host *host;
2770         struct scsi_ctrl_blk *cblk;
2771
2772         host = (struct initio_host *) host_mem;
2773         cblk = (struct scsi_ctrl_blk *) cblk_mem;
2774         if ((cmnd = cblk->srb) == NULL) {
2775                 printk(KERN_ERR "i91uSCBPost: SRB pointer is empty\n");
2776                 WARN_ON(1);
2777                 initio_release_scb(host, cblk); /* Release SCB for current channel */
2778                 return;
2779         }
2780
2781         /*
2782          *      Remap the firmware error status into a mid layer one
2783          */
2784         switch (cblk->hastat) {
2785         case 0x0:
2786         case 0xa:               /* Linked command complete without error and linked normally */
2787         case 0xb:               /* Linked command complete without error interrupt generated */
2788                 cblk->hastat = 0;
2789                 break;
2790
2791         case 0x11:              /* Selection time out-The initiator selection or target
2792                                    reselection was not complete within the SCSI Time out period */
2793                 cblk->hastat = DID_TIME_OUT;
2794                 break;
2795
2796         case 0x14:              /* Target bus phase sequence failure-An invalid bus phase or bus
2797                                    phase sequence was requested by the target. The host adapter
2798                                    will generate a SCSI Reset Condition, notifying the host with
2799                                    a SCRD interrupt */
2800                 cblk->hastat = DID_RESET;
2801                 break;
2802
2803         case 0x1a:              /* SCB Aborted. 07/21/98 */
2804                 cblk->hastat = DID_ABORT;
2805                 break;
2806
2807         case 0x12:              /* Data overrun/underrun-The target attempted to transfer more data
2808                                    than was allocated by the Data Length field or the sum of the
2809                                    Scatter / Gather Data Length fields. */
2810         case 0x13:              /* Unexpected bus free-The target dropped the SCSI BSY at an unexpected time. */
2811         case 0x16:              /* Invalid SCB Operation Code. */
2812
2813         default:
2814                 printk("ini9100u: %x %x\n", cblk->hastat, cblk->tastat);
2815                 cblk->hastat = DID_ERROR;       /* Couldn't find any better */
2816                 break;
2817         }
2818
2819         cmnd->result = cblk->tastat | (cblk->hastat << 16);
2820         WARN_ON(cmnd == NULL);
2821         i91u_unmap_scb(host->pci_dev, cmnd);
2822         cmnd->scsi_done(cmnd);  /* Notify system DONE           */
2823         initio_release_scb(host, cblk); /* Release SCB for current channel */
2824 }
2825
2826 static struct scsi_host_template initio_template = {
2827         .proc_name              = "INI9100U",
2828         .name                   = "Initio INI-9X00U/UW SCSI device driver",
2829         .queuecommand           = i91u_queuecommand,
2830         .eh_bus_reset_handler   = i91u_bus_reset,
2831         .bios_param             = i91u_biosparam,
2832         .can_queue              = MAX_TARGETS * i91u_MAXQUEUE,
2833         .this_id                = 1,
2834         .sg_tablesize           = SG_ALL,
2835         .cmd_per_lun            = 1,
2836         .use_clustering         = ENABLE_CLUSTERING,
2837 };
2838
2839 static int initio_probe_one(struct pci_dev *pdev,
2840         const struct pci_device_id *id)
2841 {
2842         struct Scsi_Host *shost;
2843         struct initio_host *host;
2844         u32 reg;
2845         u16 bios_seg;
2846         struct scsi_ctrl_blk *scb, *tmp, *prev = NULL /* silence gcc */;
2847         int num_scb, i, error;
2848
2849         error = pci_enable_device(pdev);
2850         if (error)
2851                 return error;
2852
2853         pci_read_config_dword(pdev, 0x44, (u32 *) & reg);
2854         bios_seg = (u16) (reg & 0xFF);
2855         if (((reg & 0xFF00) >> 8) == 0xFF)
2856                 reg = 0;
2857         bios_seg = (bios_seg << 8) + ((u16) ((reg & 0xFF00) >> 8));
2858
2859         if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
2860                 printk(KERN_WARNING  "i91u: Could not set 32 bit DMA mask\n");
2861                 error = -ENODEV;
2862                 goto out_disable_device;
2863         }
2864         shost = scsi_host_alloc(&initio_template, sizeof(struct initio_host));
2865         if (!shost) {
2866                 printk(KERN_WARNING "initio: Could not allocate host structure.\n");
2867                 error = -ENOMEM;
2868                 goto out_disable_device;
2869         }
2870         host = (struct initio_host *)shost->hostdata;
2871         memset(host, 0, sizeof(struct initio_host));
2872         host->addr = pci_resource_start(pdev, 0);
2873         host->bios_addr = bios_seg;
2874
2875         if (!request_region(host->addr, 256, "i91u")) {
2876                 printk(KERN_WARNING "initio: I/O port range 0x%x is busy.\n", host->addr);
2877                 error = -ENODEV;
2878                 goto out_host_put;
2879         }
2880
2881         if (initio_tag_enable)  /* 1.01i */
2882                 num_scb = MAX_TARGETS * i91u_MAXQUEUE;
2883         else
2884                 num_scb = MAX_TARGETS + 3;      /* 1-tape, 1-CD_ROM, 1- extra */
2885
2886         for (; num_scb >= MAX_TARGETS + 3; num_scb--) {
2887                 i = num_scb * sizeof(struct scsi_ctrl_blk);
2888                 if ((scb = kzalloc(i, GFP_DMA)) != NULL)
2889                         break;
2890         }
2891
2892         if (!scb) {
2893                 printk(KERN_WARNING "initio: Cannot allocate SCB array.\n");
2894                 error = -ENOMEM;
2895                 goto out_release_region;
2896         }
2897
2898         host->pci_dev = pdev;
2899
2900         host->semaph = 1;
2901         spin_lock_init(&host->semaph_lock);
2902         host->num_scbs = num_scb;
2903         host->scb = scb;
2904         host->next_pending = scb;
2905         host->next_avail = scb;
2906         for (i = 0, tmp = scb; i < num_scb; i++, tmp++) {
2907                 tmp->tagid = i;
2908                 if (i != 0)
2909                         prev->next = tmp;
2910                 prev = tmp;
2911         }
2912         prev->next = NULL;
2913         host->scb_end = tmp;
2914         host->first_avail = scb;
2915         host->last_avail = prev;
2916         spin_lock_init(&host->avail_lock);
2917
2918         initio_init(host, phys_to_virt(((u32)bios_seg << 4)));
2919
2920         host->jsstatus0 = 0;
2921
2922         shost->io_port = host->addr;
2923         shost->n_io_port = 0xff;
2924         shost->can_queue = num_scb;             /* 03/05/98                      */
2925         shost->unique_id = host->addr;
2926         shost->max_id = host->max_tar;
2927         shost->max_lun = 32;    /* 10/21/97                     */
2928         shost->irq = pdev->irq;
2929         shost->this_id = host->scsi_id; /* Assign HCS index           */
2930         shost->base = host->addr;
2931         shost->sg_tablesize = TOTAL_SG_ENTRY;
2932
2933         error = request_irq(pdev->irq, i91u_intr, IRQF_DISABLED|IRQF_SHARED, "i91u", shost);
2934         if (error < 0) {
2935                 printk(KERN_WARNING "initio: Unable to request IRQ %d\n", pdev->irq);
2936                 goto out_free_scbs;
2937         }
2938
2939         pci_set_drvdata(pdev, shost);
2940
2941         error = scsi_add_host(shost, &pdev->dev);
2942         if (error)
2943                 goto out_free_irq;
2944         scsi_scan_host(shost);
2945         return 0;
2946 out_free_irq:
2947         free_irq(pdev->irq, shost);
2948 out_free_scbs:
2949         kfree(host->scb);
2950 out_release_region:
2951         release_region(host->addr, 256);
2952 out_host_put:
2953         scsi_host_put(shost);
2954 out_disable_device:
2955         pci_disable_device(pdev);
2956         return error;
2957 }
2958
2959 /**
2960  *      initio_remove_one       -       control shutdown
2961  *      @pdev:  PCI device being released
2962  *
2963  *      Release the resources assigned to this adapter after it has
2964  *      finished being used.
2965  */
2966
2967 static void initio_remove_one(struct pci_dev *pdev)
2968 {
2969         struct Scsi_Host *host = pci_get_drvdata(pdev);
2970         struct initio_host *s = (struct initio_host *)host->hostdata;
2971         scsi_remove_host(host);
2972         free_irq(pdev->irq, host);
2973         release_region(s->addr, 256);
2974         scsi_host_put(host);
2975         pci_disable_device(pdev);
2976 }
2977
2978 MODULE_LICENSE("GPL");
2979
2980 static struct pci_device_id initio_pci_tbl[] = {
2981         {PCI_VENDOR_ID_INIT, 0x9500, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2982         {PCI_VENDOR_ID_INIT, 0x9400, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2983         {PCI_VENDOR_ID_INIT, 0x9401, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2984         {PCI_VENDOR_ID_INIT, 0x0002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2985         {PCI_VENDOR_ID_DOMEX, 0x0002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2986         {0,}
2987 };
2988 MODULE_DEVICE_TABLE(pci, initio_pci_tbl);
2989
2990 static struct pci_driver initio_pci_driver = {
2991         .name           = "initio",
2992         .id_table       = initio_pci_tbl,
2993         .probe          = initio_probe_one,
2994         .remove         = __devexit_p(initio_remove_one),
2995 };
2996
2997 static int __init initio_init_driver(void)
2998 {
2999         return pci_register_driver(&initio_pci_driver);
3000 }
3001
3002 static void __exit initio_exit_driver(void)
3003 {
3004         pci_unregister_driver(&initio_pci_driver);
3005 }
3006
3007 MODULE_DESCRIPTION("Initio INI-9X00U/UW SCSI device driver");
3008 MODULE_AUTHOR("Initio Corporation");
3009 MODULE_LICENSE("GPL");
3010
3011 module_init(initio_init_driver);
3012 module_exit(initio_exit_driver);