drivers/scsi/initio.c

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