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