[NETFILTER]: nf_conntrack: fix helper structure alignment

[linux-2.6.22.y-op.git] / drivers / scsi / seagate.c

/*
 *    seagate.c Copyright (C) 1992, 1993 Drew Eckhardt
 *      low level scsi driver for ST01/ST02, Future Domain TMC-885,
 *      TMC-950 by Drew Eckhardt <drew@colorado.edu>
 *
 *      Note : TMC-880 boards don't work because they have two bits in
 *              the status register flipped, I'll fix this "RSN"
 *      [why do I have strong feeling that above message is from 1993? :-)
 *              pavel@ucw.cz]
 *
 *      This card does all the I/O via memory mapped I/O, so there is no need
 *      to check or allocate a region of the I/O address space.
 */

/* 1996 - to use new read{b,w,l}, write{b,w,l}, and phys_to_virt
 * macros, replaced assembler routines with C. There's probably a
 * performance hit, but I only have a cdrom and can't tell. Define
 * SEAGATE_USE_ASM if you want the old assembler code -- SJT
 *
 * 1998-jul-29 - created DPRINTK macros and made it work under 
 * linux 2.1.112, simplified some #defines etc. <pavel@ucw.cz>
 *
 * Aug 2000 - aeb - deleted seagate_st0x_biosparam(). It would try to
 * read the physical disk geometry, a bad mistake. Of course it doesn't
 * matter much what geometry one invents, but on large disks it
 * returned 256 (or more) heads, causing all kind of failures.
 * Of course this means that people might see a different geometry now,
 * so boot parameters may be necessary in some cases.
 */

/*
 * Configuration :
 * To use without BIOS -DOVERRIDE=base_address -DCONTROLLER=FD or SEAGATE
 * -DIRQ will override the default of 5.
 * Note: You can now set these options from the kernel's "command line".
 * The syntax is:
 *
 *     st0x=ADDRESS,IRQ                (for a Seagate controller)
 * or:
 *     tmc8xx=ADDRESS,IRQ              (for a TMC-8xx or TMC-950 controller)
 * eg:
 *     tmc8xx=0xC8000,15
 *
 * will configure the driver for a TMC-8xx style controller using IRQ 15
 * with a base address of 0xC8000.
 *
 * -DARBITRATE 
 *      Will cause the host adapter to arbitrate for the
 *      bus for better SCSI-II compatibility, rather than just
 *      waiting for BUS FREE and then doing its thing.  Should
 *      let us do one command per Lun when I integrate my
 *      reorganization changes into the distribution sources.
 *
 * -DDEBUG=65535
 *      Will activate debug code.
 *
 * -DFAST or -DFAST32 
 *      Will use blind transfers where possible
 *
 * -DPARITY  
 *      This will enable parity.
 *
 * -DSEAGATE_USE_ASM
 *      Will use older seagate assembly code. should be (very small amount)
 *      Faster.
 *
 * -DSLOW_RATE=50
 *      Will allow compatibility with broken devices that don't
 *      handshake fast enough (ie, some CD ROM's) for the Seagate
 *      code.
 *
 *      50 is some number, It will let you specify a default
 *      transfer rate if handshaking isn't working correctly.
 *
 * -DOLDCNTDATASCEME  There is a new sceme to set the CONTROL
 *                    and DATA reigsters which complies more closely
 *                    with the SCSI2 standard. This hopefully eliminates
 *                    the need to swap the order these registers are
 *                    'messed' with. It makes the following two options
 *                    obsolete. To reenable the old sceme define this.
 *
 * The following to options are patches from the SCSI.HOWTO
 *
 * -DSWAPSTAT  This will swap the definitions for STAT_MSG and STAT_CD.
 *
 * -DSWAPCNTDATA  This will swap the order that seagate.c messes with
 *                the CONTROL an DATA registers.
 */

#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/spinlock.h>
#include <linux/signal.h>
#include <linux/string.h>
#include <linux/proc_fs.h>
#include <linux/init.h>
#include <linux/blkdev.h>
#include <linux/stat.h>
#include <linux/delay.h>
#include <linux/io.h>

#include <asm/system.h>
#include <asm/uaccess.h>

#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi.h>

#include <scsi/scsi_dbg.h>
#include <scsi/scsi_host.h>


#ifdef DEBUG
#define DPRINTK( when, msg... ) do { if ( (DEBUG & (when)) == (when) ) printk( msg ); } while (0)
#else
#define DPRINTK( when, msg... ) do { } while (0)
#endif
#define DANY( msg... ) DPRINTK( 0xffff, msg );

#ifndef IRQ
#define IRQ 5
#endif

#ifdef FAST32
#define FAST
#endif

#undef LINKED                   /* Linked commands are currently broken! */

#if defined(OVERRIDE) && !defined(CONTROLLER)
#error Please use -DCONTROLLER=SEAGATE or -DCONTROLLER=FD to override controller type
#endif

#ifndef __i386__
#undef SEAGATE_USE_ASM
#endif

/*
        Thanks to Brian Antoine for the example code in his Messy-Loss ST-01
                driver, and Mitsugu Suzuki for information on the ST-01
                SCSI host.
*/

/*
        CONTROL defines
*/

#define CMD_RST                 0x01
#define CMD_SEL                 0x02
#define CMD_BSY                 0x04
#define CMD_ATTN                0x08
#define CMD_START_ARB           0x10
#define CMD_EN_PARITY           0x20
#define CMD_INTR                0x40
#define CMD_DRVR_ENABLE         0x80

/*
        STATUS
*/
#ifdef SWAPSTAT
#define STAT_MSG                0x08
#define STAT_CD                 0x02
#else
#define STAT_MSG                0x02
#define STAT_CD                 0x08
#endif

#define STAT_BSY                0x01
#define STAT_IO                 0x04
#define STAT_REQ                0x10
#define STAT_SEL                0x20
#define STAT_PARITY             0x40
#define STAT_ARB_CMPL           0x80

/* 
        REQUESTS
*/

#define REQ_MASK (STAT_CD |  STAT_IO | STAT_MSG)
#define REQ_DATAOUT 0
#define REQ_DATAIN STAT_IO
#define REQ_CMDOUT STAT_CD
#define REQ_STATIN (STAT_CD | STAT_IO)
#define REQ_MSGOUT (STAT_MSG | STAT_CD)
#define REQ_MSGIN (STAT_MSG | STAT_CD | STAT_IO)

extern volatile int seagate_st0x_timeout;

#ifdef PARITY
#define BASE_CMD CMD_EN_PARITY
#else
#define BASE_CMD  0
#endif

/*
        Debugging code
*/

#define PHASE_BUS_FREE 1
#define PHASE_ARBITRATION 2
#define PHASE_SELECTION 4
#define PHASE_DATAIN 8
#define PHASE_DATAOUT 0x10
#define PHASE_CMDOUT 0x20
#define PHASE_MSGIN 0x40
#define PHASE_MSGOUT 0x80
#define PHASE_STATUSIN 0x100
#define PHASE_ETC (PHASE_DATAIN | PHASE_DATAOUT | PHASE_CMDOUT | PHASE_MSGIN | PHASE_MSGOUT | PHASE_STATUSIN)
#define PRINT_COMMAND 0x200
#define PHASE_EXIT 0x400
#define PHASE_RESELECT 0x800
#define DEBUG_FAST 0x1000
#define DEBUG_SG   0x2000
#define DEBUG_LINKED    0x4000
#define DEBUG_BORKEN    0x8000

/* 
 *      Control options - these are timeouts specified in .01 seconds.
 */

/* 30, 20 work */
#define ST0X_BUS_FREE_DELAY 25
#define ST0X_SELECTION_DELAY 25

#define SEAGATE 1               /* these determine the type of the controller */
#define FD      2

#define ST0X_ID_STR     "Seagate ST-01/ST-02"
#define FD_ID_STR       "TMC-8XX/TMC-950"

static int internal_command (unsigned char target, unsigned char lun,
                             const void *cmnd,
                             void *buff, int bufflen, int reselect);

static int incommand;           /* set if arbitration has finished
                                   and we are in some command phase. */

static unsigned int base_address = 0;   /* Where the card ROM starts, used to 
                                           calculate memory mapped register
                                           location.  */

static void __iomem *st0x_cr_sr;        /* control register write, status
                                           register read.  256 bytes in
                                           length.
                                           Read is status of SCSI BUS, as per 
                                           STAT masks.  */

static void __iomem *st0x_dr;   /* data register, read write 256
                                   bytes in length.  */

static volatile int st0x_aborted = 0;   /* set when we are aborted, ie by a
                                           time out, etc.  */

static unsigned char controller_type = 0;       /* set to SEAGATE for ST0x
                                                   boards or FD for TMC-8xx
                                                   boards */
static int irq = IRQ;

module_param(base_address, uint, 0);
module_param(controller_type, byte, 0);
module_param(irq, int, 0);
MODULE_LICENSE("GPL");


#define retcode(result) (((result) << 16) | (message << 8) | status)
#define STATUS ((u8) readb(st0x_cr_sr))
#define DATA ((u8) readb(st0x_dr))
#define WRITE_CONTROL(d) { writeb((d), st0x_cr_sr); }
#define WRITE_DATA(d) { writeb((d), st0x_dr); }

#ifndef OVERRIDE
static unsigned int seagate_bases[] = {
        0xc8000, 0xca000, 0xcc000,
        0xce000, 0xdc000, 0xde000
};

typedef struct {
        const unsigned char *signature;
        unsigned offset;
        unsigned length;
        unsigned char type;
} Signature;

static Signature __initdata signatures[] = {
        {"ST01 v1.7  (C) Copyright 1987 Seagate", 15, 37, SEAGATE},
        {"SCSI BIOS 2.00  (C) Copyright 1987 Seagate", 15, 40, SEAGATE},

/*
 * The following two lines are NOT mistakes.  One detects ROM revision
 * 3.0.0, the other 3.2.  Since seagate has only one type of SCSI adapter,
 * and this is not going to change, the "SEAGATE" and "SCSI" together
 * are probably "good enough"
 */

        {"SEAGATE SCSI BIOS ", 16, 17, SEAGATE},
        {"SEAGATE SCSI BIOS ", 17, 17, SEAGATE},

/*
 * However, future domain makes several incompatible SCSI boards, so specific
 * signatures must be used.
 */

        {"FUTURE DOMAIN CORP. (C) 1986-1989 V5.0C2/14/89", 5, 46, FD},
        {"FUTURE DOMAIN CORP. (C) 1986-1989 V6.0A7/28/89", 5, 46, FD},
        {"FUTURE DOMAIN CORP. (C) 1986-1990 V6.0105/31/90", 5, 47, FD},
        {"FUTURE DOMAIN CORP. (C) 1986-1990 V6.0209/18/90", 5, 47, FD},
        {"FUTURE DOMAIN CORP. (C) 1986-1990 V7.009/18/90", 5, 46, FD},
        {"FUTURE DOMAIN CORP. (C) 1992 V8.00.004/02/92", 5, 44, FD},
        {"IBM F1 BIOS V1.1004/30/92", 5, 25, FD},
        {"FUTURE DOMAIN TMC-950", 5, 21, FD},
        /* Added for 2.2.16 by Matthias_Heidbrink@b.maus.de */
        {"IBM F1 V1.2009/22/93", 5, 25, FD},
};

#define NUM_SIGNATURES ARRAY_SIZE(signatures)
#endif                          /* n OVERRIDE */

/*
 * hostno stores the hostnumber, as told to us by the init routine.
 */

static int hostno = -1;
static void seagate_reconnect_intr (int, void *);
static irqreturn_t do_seagate_reconnect_intr (int, void *);
static int seagate_st0x_bus_reset(struct scsi_cmnd *);

#ifdef FAST
static int fast = 1;
#else
#define fast 0
#endif

#ifdef SLOW_RATE
/*
 * Support for broken devices :
 * The Seagate board has a handshaking problem.  Namely, a lack
 * thereof for slow devices.  You can blast 600K/second through
 * it if you are polling for each byte, more if you do a blind
 * transfer.  In the first case, with a fast device, REQ will
 * transition high-low or high-low-high before your loop restarts
 * and you'll have no problems.  In the second case, the board
 * will insert wait states for up to 13.2 usecs for REQ to
 * transition low->high, and everything will work.
 *
 * However, there's nothing in the state machine that says
 * you *HAVE* to see a high-low-high set of transitions before
 * sending the next byte, and slow things like the Trantor CD ROMS
 * will break because of this.
 *
 * So, we need to slow things down, which isn't as simple as it
 * seems.  We can't slow things down period, because then people
 * who don't recompile their kernels will shoot me for ruining
 * their performance.  We need to do it on a case per case basis.
 *
 * The best for performance will be to, only for borken devices
 * (this is stored on a per-target basis in the scsi_devices array)
 *
 * Wait for a low->high transition before continuing with that
 * transfer.  If we timeout, continue anyways.  We don't need
 * a long timeout, because REQ should only be asserted until the
 * corresponding ACK is received and processed.
 *
 * Note that we can't use the system timer for this, because of
 * resolution, and we *really* can't use the timer chip since
 * gettimeofday() and the beeper routines use that.  So,
 * the best thing for us to do will be to calibrate a timing
 * loop in the initialization code using the timer chip before
 * gettimeofday() can screw with it.
 *
 * FIXME: this is broken (not borken :-). Empty loop costs less than
 * loop with ISA access in it! -- pavel@ucw.cz
 */

static int borken_calibration = 0;

static void __init borken_init (void)
{
        register int count = 0, start = jiffies + 1, stop = start + 25;

        /* FIXME: There may be a better approach, this is a straight port for
           now */
        preempt_disable();
        while (time_before (jiffies, start))
                cpu_relax();
        for (; time_before (jiffies, stop); ++count)
                cpu_relax();
        preempt_enable();

/*
 * Ok, we now have a count for .25 seconds.  Convert to a
 * count per second and divide by transfer rate in K.  */

        borken_calibration = (count * 4) / (SLOW_RATE * 1024);

        if (borken_calibration < 1)
                borken_calibration = 1;
}

static inline void borken_wait (void)
{
        register int count;

        for (count = borken_calibration; count && (STATUS & STAT_REQ); --count)
                cpu_relax();
                
#if (DEBUG & DEBUG_BORKEN)
        if (count)
                printk ("scsi%d : borken timeout\n", hostno);
#endif
}

#endif                          /* def SLOW_RATE */

/* These beasts only live on ISA, and ISA means 8MHz. Each ULOOP()
 * contains at least one ISA access, which takes more than 0.125
 * usec. So if we loop 8 times time in usec, we are safe.
 */

#define ULOOP( i ) for (clock = i*8;;)
#define TIMEOUT (!(clock--))

int __init seagate_st0x_detect (struct scsi_host_template * tpnt)
{
        struct Scsi_Host *instance;
        int i, j;
        unsigned long cr, dr;

        tpnt->proc_name = "seagate";
/*
 *      First, we try for the manual override.
 */
        DANY ("Autodetecting ST0x / TMC-8xx\n");

        if (hostno != -1) {
                printk (KERN_ERR "seagate_st0x_detect() called twice?!\n");
                return 0;
        }

/* If the user specified the controller type from the command line,
   controller_type will be non-zero, so don't try to detect one */

        if (!controller_type) {
#ifdef OVERRIDE
                base_address = OVERRIDE;
                controller_type = CONTROLLER;

                DANY ("Base address overridden to %x, controller type is %s\n",
                      base_address,
                      controller_type == SEAGATE ? "SEAGATE" : "FD");
#else                           /* OVERRIDE */
/*
 *      To detect this card, we simply look for the signature
 *      from the BIOS version notice in all the possible locations
 *      of the ROM's.  This has a nice side effect of not trashing
 *      any register locations that might be used by something else.
 *
 * XXX - note that we probably should be probing the address
 * space for the on-board RAM instead.
 */

                for (i = 0; i < ARRAY_SIZE(seagate_bases); ++i) {
                        void __iomem *p = ioremap(seagate_bases[i], 0x2000);
                        if (!p)
                                continue;
                        for (j = 0; j < NUM_SIGNATURES; ++j)
                                if (check_signature(p + signatures[j].offset, signatures[j].signature, signatures[j].length)) {
                                        base_address = seagate_bases[i];
                                        controller_type = signatures[j].type;
                                        break;
                                }
                        iounmap(p);
                }
#endif                          /* OVERRIDE */
        }
        /* (! controller_type) */
        tpnt->this_id = (controller_type == SEAGATE) ? 7 : 6;
        tpnt->name = (controller_type == SEAGATE) ? ST0X_ID_STR : FD_ID_STR;

        if (!base_address) {
                printk(KERN_INFO "seagate: ST0x/TMC-8xx not detected.\n");
                return 0;
        }

        cr = base_address + (controller_type == SEAGATE ? 0x1a00 : 0x1c00);
        dr = cr + 0x200;
        st0x_cr_sr = ioremap(cr, 0x100);
        st0x_dr = ioremap(dr, 0x100);

        DANY("%s detected. Base address = %x, cr = %x, dr = %x\n",
              tpnt->name, base_address, cr, dr);

        /*
         *      At all times, we will use IRQ 5.  Should also check for IRQ3
         *      if we lose our first interrupt.
         */
        instance = scsi_register (tpnt, 0);
        if (instance == NULL)
                return 0;

        hostno = instance->host_no;
        if (request_irq (irq, do_seagate_reconnect_intr, IRQF_DISABLED, (controller_type == SEAGATE) ? "seagate" : "tmc-8xx", instance)) {
                printk(KERN_ERR "scsi%d : unable to allocate IRQ%d\n", hostno, irq);
                return 0;
        }
        instance->irq = irq;
        instance->io_port = base_address;
#ifdef SLOW_RATE
        printk(KERN_INFO "Calibrating borken timer... ");
        borken_init();
        printk(" %d cycles per transfer\n", borken_calibration);
#endif
        printk (KERN_INFO "This is one second... ");
        {
                int clock;
                ULOOP (1 * 1000 * 1000) {
                        STATUS;
                        if (TIMEOUT)
                                break;
                }
        }

        printk ("done, %s options:"
#ifdef ARBITRATE
                " ARBITRATE"
#endif
#ifdef DEBUG
                " DEBUG"
#endif
#ifdef FAST
                " FAST"
#ifdef FAST32
                "32"
#endif
#endif
#ifdef LINKED
                " LINKED"
#endif
#ifdef PARITY
                " PARITY"
#endif
#ifdef SEAGATE_USE_ASM
                " SEAGATE_USE_ASM"
#endif
#ifdef SLOW_RATE
                " SLOW_RATE"
#endif
#ifdef SWAPSTAT
                " SWAPSTAT"
#endif
#ifdef SWAPCNTDATA
                " SWAPCNTDATA"
#endif
                "\n", tpnt->name);
        return 1;
}

static const char *seagate_st0x_info (struct Scsi_Host *shpnt)
{
        static char buffer[64];

        snprintf(buffer, 64, "%s at irq %d, address 0x%05X",
                 (controller_type == SEAGATE) ? ST0X_ID_STR : FD_ID_STR,
                 irq, base_address);
        return buffer;
}

/*
 * These are our saved pointers for the outstanding command that is
 * waiting for a reconnect
 */

static unsigned char current_target, current_lun;
static unsigned char *current_cmnd, *current_data;
static int current_nobuffs;
static struct scatterlist *current_buffer;
static int current_bufflen;

#ifdef LINKED
/*
 * linked_connected indicates whether or not we are currently connected to
 * linked_target, linked_lun and in an INFORMATION TRANSFER phase,
 * using linked commands.
 */

static int linked_connected = 0;
static unsigned char linked_target, linked_lun;
#endif

static void (*done_fn) (struct scsi_cmnd *) = NULL;
static struct scsi_cmnd *SCint = NULL;

/*
 * These control whether or not disconnect / reconnect will be attempted,
 * or are being attempted.
 */

#define NO_RECONNECT    0
#define RECONNECT_NOW   1
#define CAN_RECONNECT   2

/*
 * LINKED_RIGHT indicates that we are currently connected to the correct target
 * for this command, LINKED_WRONG indicates that we are connected to the wrong
 * target. Note that these imply CAN_RECONNECT and require defined(LINKED).
 */

#define LINKED_RIGHT    3
#define LINKED_WRONG    4

/*
 * This determines if we are expecting to reconnect or not.
 */

static int should_reconnect = 0;

/*
 * The seagate_reconnect_intr routine is called when a target reselects the
 * host adapter.  This occurs on the interrupt triggered by the target
 * asserting SEL.
 */

static irqreturn_t do_seagate_reconnect_intr(int irq, void *dev_id)
{
        unsigned long flags;
        struct Scsi_Host *dev = dev_id;
        
        spin_lock_irqsave (dev->host_lock, flags);
        seagate_reconnect_intr (irq, dev_id);
        spin_unlock_irqrestore (dev->host_lock, flags);
        return IRQ_HANDLED;
}

static void seagate_reconnect_intr (int irq, void *dev_id)
{
        int temp;
        struct scsi_cmnd *SCtmp;

        DPRINTK (PHASE_RESELECT, "scsi%d : seagate_reconnect_intr() called\n", hostno);

        if (!should_reconnect)
                printk(KERN_WARNING "scsi%d: unexpected interrupt.\n", hostno);
        else {
                should_reconnect = 0;

                DPRINTK (PHASE_RESELECT, "scsi%d : internal_command(%d, %08x, %08x, RECONNECT_NOW\n", 
                        hostno, current_target, current_data, current_bufflen);

                temp = internal_command (current_target, current_lun, current_cmnd, current_data, current_bufflen, RECONNECT_NOW);

                if (msg_byte(temp) != DISCONNECT) {
                        if (done_fn) {
                                DPRINTK(PHASE_RESELECT, "scsi%d : done_fn(%d,%08x)", hostno, hostno, temp);
                                if (!SCint)
                                        panic ("SCint == NULL in seagate");
                                SCtmp = SCint;
                                SCint = NULL;
                                SCtmp->result = temp;
                                done_fn(SCtmp);
                        } else
                                printk(KERN_ERR "done_fn() not defined.\n");
                }
        }
}

/*
 * The seagate_st0x_queue_command() function provides a queued interface
 * to the seagate SCSI driver.  Basically, it just passes control onto the
 * seagate_command() function, after fixing it so that the done_fn()
 * is set to the one passed to the function.  We have to be very careful,
 * because there are some commands on some devices that do not disconnect,
 * and if we simply call the done_fn when the command is done then another
 * command is started and queue_command is called again...  We end up
 * overflowing the kernel stack, and this tends not to be such a good idea.
 */

static int recursion_depth = 0;

static int seagate_st0x_queue_command(struct scsi_cmnd * SCpnt,
                                      void (*done) (struct scsi_cmnd *))
{
        int result, reconnect;
        struct scsi_cmnd *SCtmp;

        DANY ("seagate: que_command");
        done_fn = done;
        current_target = SCpnt->device->id;
        current_lun = SCpnt->device->lun;
        current_cmnd = SCpnt->cmnd;
        current_data = (unsigned char *) SCpnt->request_buffer;
        current_bufflen = SCpnt->request_bufflen;
        SCint = SCpnt;
        if (recursion_depth)
                return 1;
        recursion_depth++;
        do {
#ifdef LINKED
                /*
                 * Set linked command bit in control field of SCSI command.
                 */

                current_cmnd[SCpnt->cmd_len] |= 0x01;
                if (linked_connected) {
                        DPRINTK (DEBUG_LINKED, "scsi%d : using linked commands, current I_T_L nexus is ", hostno);
                        if (linked_target == current_target && linked_lun == current_lun) 
                        {
                                DPRINTK(DEBUG_LINKED, "correct\n");
                                reconnect = LINKED_RIGHT;
                        } else {
                                DPRINTK(DEBUG_LINKED, "incorrect\n");
                                reconnect = LINKED_WRONG;
                        }
                } else
#endif                          /* LINKED */
                        reconnect = CAN_RECONNECT;

                result = internal_command(SCint->device->id, SCint->device->lun, SCint->cmnd,
                                      SCint->request_buffer, SCint->request_bufflen, reconnect);
                if (msg_byte(result) == DISCONNECT)
                        break;
                SCtmp = SCint;
                SCint = NULL;
                SCtmp->result = result;
                done_fn(SCtmp);
        }
        while (SCint);
        recursion_depth--;
        return 0;
}

static int internal_command (unsigned char target, unsigned char lun,
                  const void *cmnd, void *buff, int bufflen, int reselect)
{
        unsigned char *data = NULL;
        struct scatterlist *buffer = NULL;
        int clock, temp, nobuffs = 0, done = 0, len = 0;
#ifdef DEBUG
        int transfered = 0, phase = 0, newphase;
#endif
        register unsigned char status_read;
        unsigned char tmp_data, tmp_control, status = 0, message = 0;
        unsigned transfersize = 0, underflow = 0;
#ifdef SLOW_RATE
        int borken = (int) SCint->device->borken;       /* Does the current target require
                                                           Very Slow I/O ?  */
#endif

        incommand = 0;
        st0x_aborted = 0;

#if (DEBUG & PRINT_COMMAND)
        printk("scsi%d : target = %d, command = ", hostno, target);
        __scsi_print_command((unsigned char *) cmnd);
#endif

#if (DEBUG & PHASE_RESELECT)
        switch (reselect) {
        case RECONNECT_NOW:
                printk("scsi%d : reconnecting\n", hostno);
                break;
#ifdef LINKED
        case LINKED_RIGHT:
                printk("scsi%d : connected, can reconnect\n", hostno);
                break;
        case LINKED_WRONG:
                printk("scsi%d : connected to wrong target, can reconnect\n",
                        hostno);
                break;
#endif
        case CAN_RECONNECT:
                printk("scsi%d : allowed to reconnect\n", hostno);
                break;
        default:
                printk("scsi%d : not allowed to reconnect\n", hostno);
        }
#endif

        if (target == (controller_type == SEAGATE ? 7 : 6))
                return DID_BAD_TARGET;

        /*
         *      We work it differently depending on if this is is "the first time,"
         *      or a reconnect.  If this is a reselect phase, then SEL will
         *      be asserted, and we must skip selection / arbitration phases.
         */

        switch (reselect) {
        case RECONNECT_NOW:
                DPRINTK (PHASE_RESELECT, "scsi%d : phase RESELECT \n", hostno);
                /*
                 *      At this point, we should find the logical or of our ID
                 *      and the original target's ID on the BUS, with BSY, SEL,
                 *      and I/O signals asserted.
                 *
                 *      After ARBITRATION phase is completed, only SEL, BSY,
                 *      and the target ID are asserted.  A valid initiator ID
                 *      is not on the bus until IO is asserted, so we must wait
                 *      for that.
                 */
                ULOOP (100 * 1000) {
                        temp = STATUS;
                        if ((temp & STAT_IO) && !(temp & STAT_BSY))
                                break;
                        if (TIMEOUT) {
                                DPRINTK (PHASE_RESELECT, "scsi%d : RESELECT timed out while waiting for IO .\n", hostno);
                                return (DID_BAD_INTR << 16);
                        }
                }

                /*
                 *      After I/O is asserted by the target, we can read our ID
                 *      and its ID off of the BUS.
                 */

                if (!((temp = DATA) & (controller_type == SEAGATE ? 0x80 : 0x40))) {
                        DPRINTK (PHASE_RESELECT, "scsi%d : detected reconnect request to different target.\n\tData bus = %d\n", hostno, temp);
                        return (DID_BAD_INTR << 16);
                }

                if (!(temp & (1 << current_target))) {
                        printk(KERN_WARNING "scsi%d : Unexpected reselect interrupt.  Data bus = %d\n", hostno, temp);
                        return (DID_BAD_INTR << 16);
                }

                buffer = current_buffer;
                cmnd = current_cmnd;    /* WDE add */
                data = current_data;    /* WDE add */
                len = current_bufflen;  /* WDE add */
                nobuffs = current_nobuffs;

                /*
                 *      We have determined that we have been selected.  At this
                 *      point, we must respond to the reselection by asserting
                 *      BSY ourselves
                 */

#if 1
                WRITE_CONTROL (BASE_CMD | CMD_DRVR_ENABLE | CMD_BSY);
#else
                WRITE_CONTROL (BASE_CMD | CMD_BSY);
#endif

                /*
                 *      The target will drop SEL, and raise BSY, at which time
                 *      we must drop BSY.
                 */

                ULOOP (100 * 1000) {
                        if (!(STATUS & STAT_SEL))
                                break;
                        if (TIMEOUT) {
                                WRITE_CONTROL (BASE_CMD | CMD_INTR);
                                DPRINTK (PHASE_RESELECT, "scsi%d : RESELECT timed out while waiting for SEL.\n", hostno);
                                return (DID_BAD_INTR << 16);
                        }
                }
                WRITE_CONTROL (BASE_CMD);
                /*
                 *      At this point, we have connected with the target
                 *      and can get on with our lives.
                 */
                break;
        case CAN_RECONNECT:
#ifdef LINKED
                /*
                 * This is a bletcherous hack, just as bad as the Unix #!
                 * interpreter stuff. If it turns out we are using the wrong
                 * I_T_L nexus, the easiest way to deal with it is to go into
                 *  our INFORMATION TRANSFER PHASE code, send a ABORT
                 * message on MESSAGE OUT phase, and then loop back to here.
                 */
connect_loop:
#endif
                DPRINTK (PHASE_BUS_FREE, "scsi%d : phase = BUS FREE \n", hostno);

                /*
                 *    BUS FREE PHASE
                 *
                 *      On entry, we make sure that the BUS is in a BUS FREE
                 *      phase, by insuring that both BSY and SEL are low for
                 *      at least one bus settle delay.  Several reads help
                 *      eliminate wire glitch.
                 */

#ifndef ARBITRATE
#error FIXME: this is broken: we may not use jiffies here - we are under cli(). It will hardlock.
                clock = jiffies + ST0X_BUS_FREE_DELAY;

                while (((STATUS | STATUS | STATUS) & (STAT_BSY | STAT_SEL)) && (!st0x_aborted) && time_before (jiffies, clock))
                        cpu_relax();

                if (time_after (jiffies, clock))
                        return retcode (DID_BUS_BUSY);
                else if (st0x_aborted)
                        return retcode (st0x_aborted);
#endif
                DPRINTK (PHASE_SELECTION, "scsi%d : phase = SELECTION\n", hostno);

                clock = jiffies + ST0X_SELECTION_DELAY;

                /*
                 * Arbitration/selection procedure :
                 * 1.  Disable drivers
                 * 2.  Write HOST adapter address bit
                 * 3.  Set start arbitration.
                 * 4.  We get either ARBITRATION COMPLETE or SELECT at this
                 *     point.
                 * 5.  OR our ID and targets on bus.
                 * 6.  Enable SCSI drivers and asserted SEL and ATTN
                 */

#ifdef ARBITRATE
                /* FIXME: verify host lock is always held here */
                WRITE_CONTROL(0);
                WRITE_DATA((controller_type == SEAGATE) ? 0x80 : 0x40);
                WRITE_CONTROL(CMD_START_ARB);

                ULOOP (ST0X_SELECTION_DELAY * 10000) {
                        status_read = STATUS;
                        if (status_read & STAT_ARB_CMPL)
                                break;
                        if (st0x_aborted)       /* FIXME: What? We are going to do something even after abort? */
                                break;
                        if (TIMEOUT || (status_read & STAT_SEL)) {
                                printk(KERN_WARNING "scsi%d : arbitration lost or timeout.\n", hostno);
                                WRITE_CONTROL (BASE_CMD);
                                return retcode (DID_NO_CONNECT);
                        }
                }
                DPRINTK (PHASE_SELECTION, "scsi%d : arbitration complete\n", hostno);
#endif

                /*
                 *    When the SCSI device decides that we're gawking at it, 
                 *    it will respond by asserting BUSY on the bus.
                 *
                 *    Note : the Seagate ST-01/02 product manual says that we
                 *    should twiddle the DATA register before the control
                 *    register. However, this does not work reliably so we do
                 *    it the other way around.
                 *
                 *    Probably could be a problem with arbitration too, we
                 *    really should try this with a SCSI protocol or logic 
                 *    analyzer to see what is going on.
                 */
                tmp_data = (unsigned char) ((1 << target) | (controller_type == SEAGATE ? 0x80 : 0x40));
                tmp_control = BASE_CMD | CMD_DRVR_ENABLE | CMD_SEL | (reselect ? CMD_ATTN : 0);

                /* FIXME: verify host lock is always held here */
#ifdef OLDCNTDATASCEME
#ifdef SWAPCNTDATA
                WRITE_CONTROL (tmp_control);
                WRITE_DATA (tmp_data);
#else
                WRITE_DATA (tmp_data);
                WRITE_CONTROL (tmp_control);
#endif
#else
                tmp_control ^= CMD_BSY; /* This is guesswork. What used to be in driver    */
                WRITE_CONTROL (tmp_control);    /* could never work: it sent data into control     */
                WRITE_DATA (tmp_data);  /* register and control info into data. Hopefully  */
                tmp_control ^= CMD_BSY; /* fixed, but order of first two may be wrong.     */
                WRITE_CONTROL (tmp_control);    /* -- pavel@ucw.cz   */
#endif

                ULOOP (250 * 1000) {
                        if (st0x_aborted) {
                                /*
                                 *      If we have been aborted, and we have a
                                 *      command in progress, IE the target 
                                 *      still has BSY asserted, then we will
                                 *      reset the bus, and notify the midlevel
                                 *      driver to expect sense.
                                 */

                                WRITE_CONTROL (BASE_CMD);
                                if (STATUS & STAT_BSY) {
                                        printk(KERN_WARNING "scsi%d : BST asserted after we've been aborted.\n", hostno);
                                        seagate_st0x_bus_reset(NULL);
                                        return retcode (DID_RESET);
                                }
                                return retcode (st0x_aborted);
                        }
                        if (STATUS & STAT_BSY)
                                break;
                        if (TIMEOUT) {
                                DPRINTK (PHASE_SELECTION, "scsi%d : NO CONNECT with target %d, stat = %x \n", hostno, target, STATUS);
                                return retcode (DID_NO_CONNECT);
                        }
                }

                /* Establish current pointers.  Take into account scatter / gather */

                if ((nobuffs = SCint->use_sg)) {
#if (DEBUG & DEBUG_SG)
                        {
                                int i;
                                printk("scsi%d : scatter gather requested, using %d buffers.\n", hostno, nobuffs);
                                for (i = 0; i < nobuffs; ++i)
                                        printk("scsi%d : buffer %d address = %p length = %d\n",
                                             hostno, i,
                                             page_address(buffer[i].page) + buffer[i].offset,
                                             buffer[i].length);
                        }
#endif

                        buffer = (struct scatterlist *) SCint->request_buffer;
                        len = buffer->length;
                        data = page_address(buffer->page) + buffer->offset;
                } else {
                        DPRINTK (DEBUG_SG, "scsi%d : scatter gather not requested.\n", hostno);
                        buffer = NULL;
                        len = SCint->request_bufflen;
                        data = (unsigned char *) SCint->request_buffer;
                }

                DPRINTK (PHASE_DATAIN | PHASE_DATAOUT, "scsi%d : len = %d\n",
                         hostno, len);

                break;
#ifdef LINKED
        case LINKED_RIGHT:
                break;
        case LINKED_WRONG:
                break;
#endif
        }                       /* end of switch(reselect) */

        /*
         *    There are several conditions under which we wish to send a message :
         *      1.  When we are allowing disconnect / reconnect, and need to
         *      establish the I_T_L nexus via an IDENTIFY with the DiscPriv bit
         *      set.
         *
         *      2.  When we are doing linked commands, are have the wrong I_T_L
         *      nexus established and want to send an ABORT message.
         */

        /* GCC does not like an ifdef inside a macro, so do it the hard way. */
#ifdef LINKED
        WRITE_CONTROL (BASE_CMD | CMD_DRVR_ENABLE | (((reselect == CAN_RECONNECT)|| (reselect == LINKED_WRONG))? CMD_ATTN : 0));
#else
        WRITE_CONTROL (BASE_CMD | CMD_DRVR_ENABLE | (((reselect == CAN_RECONNECT))? CMD_ATTN : 0));
#endif

        /*
         *    INFORMATION TRANSFER PHASE
         *
         *      The nasty looking read / write inline assembler loops we use for
         *      DATAIN and DATAOUT phases are approximately 4-5 times as fast as
         *      the 'C' versions - since we're moving 1024 bytes of data, this
         *      really adds up.
         *
         *      SJT: The nasty-looking assembler is gone, so it's slower.
         *
         */

        DPRINTK (PHASE_ETC, "scsi%d : phase = INFORMATION TRANSFER\n", hostno);

        incommand = 1;
        transfersize = SCint->transfersize;
        underflow = SCint->underflow;

        /*
         *      Now, we poll the device for status information,
         *      and handle any requests it makes.  Note that since we are unsure
         *      of how much data will be flowing across the system, etc and
         *      cannot make reasonable timeouts, that we will instead have the
         *      midlevel driver handle any timeouts that occur in this phase.
         */

        while (((status_read = STATUS) & STAT_BSY) && !st0x_aborted && !done) {
#ifdef PARITY
                if (status_read & STAT_PARITY) {
                        printk(KERN_ERR "scsi%d : got parity error\n", hostno);
                        st0x_aborted = DID_PARITY;
                }
#endif
                if (status_read & STAT_REQ) {
#if ((DEBUG & PHASE_ETC) == PHASE_ETC)
                        if ((newphase = (status_read & REQ_MASK)) != phase) {
                                phase = newphase;
                                switch (phase) {
                                case REQ_DATAOUT:
                                        printk ("scsi%d : phase = DATA OUT\n", hostno);
                                        break;
                                case REQ_DATAIN:
                                        printk ("scsi%d : phase = DATA IN\n", hostno);
                                        break;
                                case REQ_CMDOUT:
                                        printk
                                            ("scsi%d : phase = COMMAND OUT\n", hostno);
                                        break;
                                case REQ_STATIN:
                                        printk ("scsi%d : phase = STATUS IN\n", hostno);
                                        break;
                                case REQ_MSGOUT:
                                        printk
                                            ("scsi%d : phase = MESSAGE OUT\n", hostno);
                                        break;
                                case REQ_MSGIN:
                                        printk ("scsi%d : phase = MESSAGE IN\n", hostno);
                                        break;
                                default:
                                        printk ("scsi%d : phase = UNKNOWN\n", hostno);
                                        st0x_aborted = DID_ERROR;
                                }
                        }
#endif
                        switch (status_read & REQ_MASK) {
                        case REQ_DATAOUT:
                                /*
                                 * If we are in fast mode, then we simply splat
                                 * the data out in word-sized chunks as fast as
                                 * we can.
                                 */

                                if (!len) {
#if 0
                                        printk("scsi%d: underflow to target %d lun %d \n", hostno, target, lun);
                                        st0x_aborted = DID_ERROR;
                                        fast = 0;
#endif
                                        break;
                                }

                                if (fast && transfersize
                                    && !(len % transfersize)
                                    && (len >= transfersize)
#ifdef FAST32
                                    && !(transfersize % 4)
#endif
                                    ) {
                                        DPRINTK (DEBUG_FAST,
                                                 "scsi%d : FAST transfer, underflow = %d, transfersize = %d\n"
                                                 "         len = %d, data = %08x\n",
                                                 hostno, SCint->underflow,
                                                 SCint->transfersize, len,
                                                 data);

                        /* SJT: Start. Fast Write */
#ifdef SEAGATE_USE_ASM
                                        __asm__ ("cld\n\t"
#ifdef FAST32
                                                 "shr $2, %%ecx\n\t"
                                                 "1:\t"
                                                 "lodsl\n\t"
                                                 "movl %%eax, (%%edi)\n\t"
#else
                                                 "1:\t"
                                                 "lodsb\n\t"
                                                 "movb %%al, (%%edi)\n\t"
#endif
                                                 "loop 1b;"
                                      /* output */ :
                                      /* input */ :"D" (st0x_dr),
                                                 "S"
                                                 (data),
                                                 "c" (SCint->transfersize)
/* clobbered */
                                      :  "eax", "ecx",
                                                 "esi");
#else                           /* SEAGATE_USE_ASM */
                                        memcpy_toio(st0x_dr, data, transfersize);
#endif                          /* SEAGATE_USE_ASM */
/* SJT: End */
                                        len -= transfersize;
                                        data += transfersize;
                                        DPRINTK (DEBUG_FAST, "scsi%d : FAST transfer complete len = %d data = %08x\n", hostno, len, data);
                                } else {
                                        /*
                                         *    We loop as long as we are in a 
                                         *    data out phase, there is data to
                                         *    send, and BSY is still active.
                                         */

/* SJT: Start. Slow Write. */
#ifdef SEAGATE_USE_ASM

                                        int __dummy_1, __dummy_2;

/*
 *      We loop as long as we are in a data out phase, there is data to send, 
 *      and BSY is still active.
 */
/* Local variables : len = ecx , data = esi, 
                     st0x_cr_sr = ebx, st0x_dr =  edi
*/
                                        __asm__ (
                                                        /* Test for any data here at all. */
                                                        "orl %%ecx, %%ecx\n\t"
                                                        "jz 2f\n\t" "cld\n\t"
/*                    "movl st0x_cr_sr, %%ebx\n\t"  */
/*                    "movl st0x_dr, %%edi\n\t"  */
                                                        "1:\t"
                                                        "movb (%%ebx), %%al\n\t"
                                                        /* Test for BSY */
                                                        "test $1, %%al\n\t"
                                                        "jz 2f\n\t"
                                                        /* Test for data out phase - STATUS & REQ_MASK should be 
                                                           REQ_DATAOUT, which is 0. */
                                                        "test $0xe, %%al\n\t"
                                                        "jnz 2f\n\t"
                                                        /* Test for REQ */
                                                        "test $0x10, %%al\n\t"
                                                        "jz 1b\n\t"
                                                        "lodsb\n\t"
                                                        "movb %%al, (%%edi)\n\t"
                                                        "loop 1b\n\t" "2:\n"
                                      /* output */ :"=S" (data), "=c" (len),
                                                        "=b"
                                                        (__dummy_1),
                                                        "=D" (__dummy_2)
/* input */
                                      :         "0" (data), "1" (len),
                                                        "2" (st0x_cr_sr),
                                                        "3" (st0x_dr)
/* clobbered */
                                      :         "eax");
#else                           /* SEAGATE_USE_ASM */
                                        while (len) {
                                                unsigned char stat;

                                                stat = STATUS;
                                                if (!(stat & STAT_BSY)
                                                    || ((stat & REQ_MASK) !=
                                                        REQ_DATAOUT))
                                                        break;
                                                if (stat & STAT_REQ) {
                                                        WRITE_DATA (*data++);
                                                        --len;
                                                }
                                        }
#endif                          /* SEAGATE_USE_ASM */
/* SJT: End. */
                                }

                                if (!len && nobuffs) {
                                        --nobuffs;
                                        ++buffer;
                                        len = buffer->length;
                                        data = page_address(buffer->page) + buffer->offset;
                                        DPRINTK (DEBUG_SG,
                                                 "scsi%d : next scatter-gather buffer len = %d address = %08x\n",
                                                 hostno, len, data);
                                }
                                break;

                        case REQ_DATAIN:
#ifdef SLOW_RATE
                                if (borken) {
#if (DEBUG & (PHASE_DATAIN))
                                        transfered += len;
#endif
                                        for (; len && (STATUS & (REQ_MASK | STAT_REQ)) == (REQ_DATAIN | STAT_REQ); --len) {
                                                *data++ = DATA;
                                                borken_wait();
                                        }
#if (DEBUG & (PHASE_DATAIN))
                                        transfered -= len;
#endif
                                } else
#endif

                                        if (fast && transfersize
                                            && !(len % transfersize)
                                            && (len >= transfersize)
#ifdef FAST32
                                            && !(transfersize % 4)
#endif
                                    ) {
                                        DPRINTK (DEBUG_FAST,
                                                 "scsi%d : FAST transfer, underflow = %d, transfersize = %d\n"
                                                 "         len = %d, data = %08x\n",
                                                 hostno, SCint->underflow,
                                                 SCint->transfersize, len,
                                                 data);

/* SJT: Start. Fast Read */
#ifdef SEAGATE_USE_ASM
                                        __asm__ ("cld\n\t"
#ifdef FAST32
                                                 "shr $2, %%ecx\n\t"
                                                 "1:\t"
                                                 "movl (%%esi), %%eax\n\t"
                                                 "stosl\n\t"
#else
                                                 "1:\t"
                                                 "movb (%%esi), %%al\n\t"
                                                 "stosb\n\t"
#endif
                                                 "loop 1b\n\t"
                                      /* output */ :
                                      /* input */ :"S" (st0x_dr),
                                                 "D"
                                                 (data),
                                                 "c" (SCint->transfersize)
/* clobbered */
                                      :  "eax", "ecx",
                                                 "edi");
#else                           /* SEAGATE_USE_ASM */
                                        memcpy_fromio(data, st0x_dr, len);
#endif                          /* SEAGATE_USE_ASM */
/* SJT: End */
                                        len -= transfersize;
                                        data += transfersize;
#if (DEBUG & PHASE_DATAIN)
                                        printk ("scsi%d: transfered += %d\n", hostno, transfersize);
                                        transfered += transfersize;
#endif

                                        DPRINTK (DEBUG_FAST, "scsi%d : FAST transfer complete len = %d data = %08x\n", hostno, len, data);
                                } else {

#if (DEBUG & PHASE_DATAIN)
                                        printk ("scsi%d: transfered += %d\n", hostno, len);
                                        transfered += len;      /* Assume we'll transfer it all, then
                                                                   subtract what we *didn't* transfer */
#endif

/*
 *      We loop as long as we are in a data in phase, there is room to read,
 *      and BSY is still active
 */

/* SJT: Start. */
#ifdef SEAGATE_USE_ASM

                                        int __dummy_3, __dummy_4;

/* Dummy clobbering variables for the new gcc-2.95 */

/*
 *      We loop as long as we are in a data in phase, there is room to read, 
 *      and BSY is still active
 */
                                        /* Local variables : ecx = len, edi = data
                                           esi = st0x_cr_sr, ebx = st0x_dr */
                                        __asm__ (
                                                        /* Test for room to read */
                                                        "orl %%ecx, %%ecx\n\t"
                                                        "jz 2f\n\t" "cld\n\t"
/*                "movl st0x_cr_sr, %%esi\n\t"  */
/*                "movl st0x_dr, %%ebx\n\t"  */
                                                        "1:\t"
                                                        "movb (%%esi), %%al\n\t"
                                                        /* Test for BSY */
                                                        "test $1, %%al\n\t"
                                                        "jz 2f\n\t"
                                                        /* Test for data in phase - STATUS & REQ_MASK should be REQ_DATAIN, 
                                                           = STAT_IO, which is 4. */
                                                        "movb $0xe, %%ah\n\t"
                                                        "andb %%al, %%ah\n\t"
                                                        "cmpb $0x04, %%ah\n\t"
                                                        "jne 2f\n\t"
                                                        /* Test for REQ */
                                                        "test $0x10, %%al\n\t"
                                                        "jz 1b\n\t"
                                                        "movb (%%ebx), %%al\n\t"
                                                        "stosb\n\t"
                                                        "loop 1b\n\t" "2:\n"
                                      /* output */ :"=D" (data), "=c" (len),
                                                        "=S"
                                                        (__dummy_3),
                                                        "=b" (__dummy_4)
/* input */
                                      :         "0" (data), "1" (len),
                                                        "2" (st0x_cr_sr),
                                                        "3" (st0x_dr)
/* clobbered */
                                      :         "eax");
#else                           /* SEAGATE_USE_ASM */
                                        while (len) {
                                                unsigned char stat;

                                                stat = STATUS;
                                                if (!(stat & STAT_BSY)
                                                    || ((stat & REQ_MASK) !=
                                                        REQ_DATAIN))
                                                        break;
                                                if (stat & STAT_REQ) {
                                                        *data++ = DATA;
                                                        --len;
                                                }
                                        }
#endif                          /* SEAGATE_USE_ASM */
/* SJT: End. */
#if (DEBUG & PHASE_DATAIN)
                                        printk ("scsi%d: transfered -= %d\n", hostno, len);
                                        transfered -= len;      /* Since we assumed all of Len got  *
                                                                   transfered, correct our mistake */
#endif
                                }

                                if (!len && nobuffs) {
                                        --nobuffs;
                                        ++buffer;
                                        len = buffer->length;
                                        data = page_address(buffer->page) + buffer->offset;
                                        DPRINTK (DEBUG_SG, "scsi%d : next scatter-gather buffer len = %d address = %08x\n", hostno, len, data);
                                }
                                break;

                        case REQ_CMDOUT:
                                while (((status_read = STATUS) & STAT_BSY) &&
                                       ((status_read & REQ_MASK) == REQ_CMDOUT))
                                        if (status_read & STAT_REQ) {
                                                WRITE_DATA (*(const unsigned char *) cmnd);
                                                cmnd = 1 + (const unsigned char *)cmnd;
#ifdef SLOW_RATE
                                                if (borken)
                                                        borken_wait ();
#endif
                                        }
                                break;

                        case REQ_STATIN:
                                status = DATA;
                                break;

                        case REQ_MSGOUT:
                                /*
                                 *      We can only have sent a MSG OUT if we
                                 *      requested to do this by raising ATTN.
                                 *      So, we must drop ATTN.
                                 */
                                WRITE_CONTROL (BASE_CMD | CMD_DRVR_ENABLE);
                                /*
                                 *      If we are reconnecting, then we must 
                                 *      send an IDENTIFY message in response
                                 *      to MSGOUT.
                                 */
                                switch (reselect) {
                                case CAN_RECONNECT:
                                        WRITE_DATA (IDENTIFY (1, lun));
                                        DPRINTK (PHASE_RESELECT | PHASE_MSGOUT, "scsi%d : sent IDENTIFY message.\n", hostno);
                                        break;
#ifdef LINKED
                                case LINKED_WRONG:
                                        WRITE_DATA (ABORT);
                                        linked_connected = 0;
                                        reselect = CAN_RECONNECT;
                                        goto connect_loop;
                                        DPRINTK (PHASE_MSGOUT | DEBUG_LINKED, "scsi%d : sent ABORT message to cancel incorrect I_T_L nexus.\n", hostno);
#endif                                  /* LINKED */
                                        DPRINTK (DEBUG_LINKED, "correct\n");
                                default:
                                        WRITE_DATA (NOP);
                                        printk("scsi%d : target %d requested MSGOUT, sent NOP message.\n", hostno, target);
                                }
                                break;

                        case REQ_MSGIN:
                                switch (message = DATA) {
                                case DISCONNECT:
                                        DANY("seagate: deciding to disconnect\n");
                                        should_reconnect = 1;
                                        current_data = data;    /* WDE add */
                                        current_buffer = buffer;
                                        current_bufflen = len;  /* WDE add */
                                        current_nobuffs = nobuffs;
#ifdef LINKED
                                        linked_connected = 0;
#endif
                                        done = 1;
                                        DPRINTK ((PHASE_RESELECT | PHASE_MSGIN), "scsi%d : disconnected.\n", hostno);
                                        break;

#ifdef LINKED
                                case LINKED_CMD_COMPLETE:
                                case LINKED_FLG_CMD_COMPLETE:
#endif
                                case COMMAND_COMPLETE:
                                        /*
                                         * Note : we should check for underflow here.
                                         */
                                        DPRINTK(PHASE_MSGIN, "scsi%d : command complete.\n", hostno);
                                        done = 1;
                                        break;
                                case ABORT:
                                        DPRINTK(PHASE_MSGIN, "scsi%d : abort message.\n", hostno);
                                        done = 1;
                                        break;
                                case SAVE_POINTERS:
                                        current_buffer = buffer;
                                        current_bufflen = len;  /* WDE add */
                                        current_data = data;    /* WDE mod */
                                        current_nobuffs = nobuffs;
                                        DPRINTK (PHASE_MSGIN, "scsi%d : pointers saved.\n", hostno);
                                        break;
                                case RESTORE_POINTERS:
                                        buffer = current_buffer;
                                        cmnd = current_cmnd;
                                        data = current_data;    /* WDE mod */
                                        len = current_bufflen;
                                        nobuffs = current_nobuffs;
                                        DPRINTK(PHASE_MSGIN, "scsi%d : pointers restored.\n", hostno);
                                        break;
                                default:

                                        /*
                                         *      IDENTIFY distinguishes itself
                                         *      from the other messages by 
                                         *      setting the high bit.
                                         *
                                         *      Note : we need to handle at 
                                         *      least one outstanding command
                                         *      per LUN, and need to hash the 
                                         *      SCSI command for that I_T_L
                                         *      nexus based on the known ID 
                                         *      (at this point) and LUN.
                                         */

                                        if (message & 0x80) {
                                                DPRINTK (PHASE_MSGIN, "scsi%d : IDENTIFY message received from id %d, lun %d.\n", hostno, target, message & 7);
                                        } else {
                                                /*
                                                 *      We should go into a
                                                 *      MESSAGE OUT phase, and
                                                 *      send  a MESSAGE_REJECT
                                                 *      if we run into a message 
                                                 *      that we don't like.  The
                                                 *      seagate driver needs 
                                                 *      some serious 
                                                 *      restructuring first
                                                 *      though.
                                                 */
                                                DPRINTK (PHASE_MSGIN, "scsi%d : unknown message %d from target %d.\n", hostno, message, target);
                                        }
                                }
                                break;
                        default:
                                printk(KERN_ERR "scsi%d : unknown phase.\n", hostno);
                                st0x_aborted = DID_ERROR;
                        }       /* end of switch (status_read &  REQ_MASK) */
#ifdef SLOW_RATE
                        /*
                         * I really don't care to deal with borken devices in
                         * each single byte transfer case (ie, message in,
                         * message out, status), so I'll do the wait here if 
                         * necessary.
                         */
                        if(borken)
                                borken_wait();
#endif

                }               /* if(status_read & STAT_REQ) ends */
        }                       /* while(((status_read = STATUS)...) ends */

        DPRINTK(PHASE_DATAIN | PHASE_DATAOUT | PHASE_EXIT, "scsi%d : Transfered %d bytes\n", hostno, transfered);

#if (DEBUG & PHASE_EXIT)
#if 0                           /* Doesn't work for scatter/gather */
        printk("Buffer : \n");
        for(i = 0; i < 20; ++i)
                printk("%02x  ", ((unsigned char *) data)[i]);  /* WDE mod */
        printk("\n");
#endif
        printk("scsi%d : status = ", hostno);
        scsi_print_status(status);
        printk(" message = %02x\n", message);
#endif

        /* We shouldn't reach this until *after* BSY has been deasserted */

#ifdef LINKED
        else
        {
                /*
                 * Fix the message byte so that unsuspecting high level drivers
                 * don't puke when they see a LINKED COMMAND message in place of
                 * the COMMAND COMPLETE they may be expecting.  Shouldn't be
                 * necessary, but it's better to be on the safe side.
                 *
                 * A non LINKED* message byte will indicate that the command
                 * completed, and we are now disconnected.
                 */

                switch (message) {
                case LINKED_CMD_COMPLETE:
                case LINKED_FLG_CMD_COMPLETE:
                        message = COMMAND_COMPLETE;
                        linked_target = current_target;
                        linked_lun = current_lun;
                        linked_connected = 1;
                        DPRINTK (DEBUG_LINKED, "scsi%d : keeping I_T_L nexus established for linked command.\n", hostno);
                        /* We also will need to adjust status to accommodate intermediate
                           conditions. */
                        if ((status == INTERMEDIATE_GOOD) || (status == INTERMEDIATE_C_GOOD))
                                status = GOOD;
                        break;
                        /*
                         * We should also handle what are "normal" termination
                         * messages here (ABORT, BUS_DEVICE_RESET?, and
                         * COMMAND_COMPLETE individually, and flake if things
                         * aren't right.
                         */
                default:
                        DPRINTK (DEBUG_LINKED, "scsi%d : closing I_T_L nexus.\n", hostno);
                        linked_connected = 0;
                }
        }
#endif  /* LINKED */

        if (should_reconnect) {
                DPRINTK (PHASE_RESELECT, "scsi%d : exiting seagate_st0x_queue_command() with reconnect enabled.\n", hostno);
                WRITE_CONTROL (BASE_CMD | CMD_INTR);
        } else
                WRITE_CONTROL (BASE_CMD);

        return retcode (st0x_aborted);
}                               /* end of internal_command */

static int seagate_st0x_abort(struct scsi_cmnd * SCpnt)
{
        st0x_aborted = DID_ABORT;
        return SUCCESS;
}

#undef ULOOP
#undef TIMEOUT

/*
 * the seagate_st0x_reset function resets the SCSI bus 
 *
 * May be called with SCpnt = NULL
 */

static int seagate_st0x_bus_reset(struct scsi_cmnd * SCpnt)
{
        /* No timeouts - this command is going to fail because it was reset. */
        DANY ("scsi%d: Reseting bus... ", hostno);

        /* assert  RESET signal on SCSI bus.  */
        WRITE_CONTROL (BASE_CMD | CMD_RST);

        mdelay (20);

        WRITE_CONTROL (BASE_CMD);
        st0x_aborted = DID_RESET;

        DANY ("done.\n");
        return SUCCESS;
}

static int seagate_st0x_release(struct Scsi_Host *shost)
{
        if (shost->irq)
                free_irq(shost->irq, shost);
        release_region(shost->io_port, shost->n_io_port);
        return 0;
}

static struct scsi_host_template driver_template = {
        .detect                 = seagate_st0x_detect,
        .release                = seagate_st0x_release,
        .info                   = seagate_st0x_info,
        .queuecommand           = seagate_st0x_queue_command,
        .eh_abort_handler       = seagate_st0x_abort,
        .eh_bus_reset_handler   = seagate_st0x_bus_reset,
        .can_queue              = 1,
        .this_id                = 7,
        .sg_tablesize           = SG_ALL,
        .cmd_per_lun            = 1,
        .use_clustering         = DISABLE_CLUSTERING,
};
#include "scsi_module.c"