drivers/scsi/pci2220i.c

   1 /****************************************************************************
   2  * Perceptive Solutions, Inc. PCI-2220I device driver for Linux.
   3  *
   4  * pci2220i.c - Linux Host Driver for PCI-2220I EIDE RAID Adapters
   5  *
   6  * Copyright (c) 1997-1999 Perceptive Solutions, Inc.
   7  * All Rights Reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that redistributions of source
  11  * code retain the above copyright notice and this comment without
  12  * modification.
  13  *
  14  * Technical updates and product information at:
  15  *  http://www.psidisk.com
  16  *
  17  * Please send questions, comments, bug reports to:
  18  *  tech@psidisk.com Technical Support
  19  *
  20  *
  21  *      Revisions 1.10          Mar-26-1999
  22  *              - Updated driver for RAID and hot reconstruct support.
  23  *
  24  *      Revisions 1.11          Mar-26-1999
  25  *              - Fixed spinlock and PCI configuration.
  26  *
  27  *      Revision 2.00           December-1-1999
  28  *              - Added code for the PCI-2240I controller
  29  *              - Added code for ATAPI devices.
  30  *              - Double buffer for scatter/gather support
  31  *
  32  *      Revision 2.10           March-27-2000
  33  *              - Added support for dynamic DMA
  34  *
  35  ****************************************************************************/
  36
  37 #error Convert me to understand page+offset based scatterlists
  38
  39 //#define DEBUG 1
  40
  41 #include <linux/interrupt.h>
  42 #include <linux/module.h>
  43 #include <linux/kernel.h>
  44 #include <linux/types.h>
  45 #include <linux/string.h>
  46 #include <linux/slab.h>
  47 #include <linux/pci.h>
  48 #include <linux/ioport.h>
  49 #include <linux/delay.h>
  50 #include <linux/sched.h>
  51 #include <linux/proc_fs.h>
  52 #include <linux/stat.h>
  53 #include <linux/blkdev.h>
  54 #include <linux/timer.h>
  55 #include <linux/spinlock.h>
  56
  57 #include <asm/dma.h>
  58 #include <asm/system.h>
  59 #include <asm/io.h>
  60
  61 #include "scsi.h"
  62 #include <scsi/scsi_host.h>
  63 #include "pci2220i.h"
  64 #include "psi_dale.h"
  65
  66
  67 #define PCI2220I_VERSION                "2.10"
  68 #define READ_CMD                                IDE_CMD_READ_MULTIPLE
  69 #define WRITE_CMD                               IDE_CMD_WRITE_MULTIPLE
  70 #define MAX_BUS_MASTER_BLOCKS   SECTORSXFER             // This is the maximum we can bus master
  71
  72 #ifdef DEBUG
  73 #define DEB(x) x
  74 #define STOP_HERE()     {int st;for(st=0;st<100;st++){st=1;}}
  75 #else
  76 #define DEB(x)
  77 #define STOP_HERE()
  78 #endif
  79
  80 #define MAXADAPTER 4                                    // Increase this and the sizes of the arrays below, if you need more.
  81
  82
  83 typedef struct
  84         {
  85         UCHAR                   byte6;                          // device select register image
  86         UCHAR                   spigot;                         // spigot number
  87         UCHAR                   spigots[2];                     // RAID spigots
  88         UCHAR                   deviceID[2];            // device ID codes
  89         USHORT                  sectors;                        // number of sectors per track
  90         USHORT                  heads;                          // number of heads
  91         USHORT                  cylinders;                      // number of cylinders for this device
  92         USHORT                  spareword;                      // placeholder
  93         ULONG                   blocks;                         // number of blocks on device
  94         DISK_MIRROR             DiskMirror[2];          // RAID status and control
  95         ULONG                   lastsectorlba[2];       // last addressable sector on the drive
  96         USHORT                  raid;                           // RAID active flag
  97         USHORT                  mirrorRecon;
  98         UCHAR                   reconOn;
  99         USHORT                  reconCount;
 100         USHORT                  reconIsStarting;        // indicate hot reconstruct is starting
 101         UCHAR                   cmdDrqInt;                      // flag for command interrupt
 102         UCHAR                   packet;                         // command packet size in bytes
 103         }       OUR_DEVICE, *POUR_DEVICE;
 104
 105 typedef struct
 106         {
 107         USHORT           bigD;                                  // identity is a PCI-2240I if true, otherwise a PCI-2220I
 108         USHORT           atapi;                                 // this interface is for ATAPI devices only
 109         ULONG            regDmaDesc;                    // address of the DMA discriptor register for direction of transfer
 110         ULONG            regDmaCmdStat;                 // Byte #1 of DMA command status register
 111         ULONG            regDmaAddrPci;                 // 32 bit register for PCI address of DMA
 112         ULONG            regDmaAddrLoc;                 // 32 bit register for local bus address of DMA
 113         ULONG            regDmaCount;                   // 32 bit register for DMA transfer count
 114         ULONG            regDmaMode;                    // 32 bit register for DMA mode control
 115         ULONG            regRemap;                              // 32 bit local space remap
 116         ULONG            regDesc;                               // 32 bit local region descriptor
 117         ULONG            regRange;                              // 32 bit local range
 118         ULONG            regIrqControl;                 // 16 bit Interrupt enable/disable and status
 119         ULONG            regScratchPad;                 // scratch pad I/O base address
 120         ULONG            regBase;                               // Base I/O register for data space
 121         ULONG            regData;                               // data register I/O address
 122         ULONG            regError;                              // error register I/O address
 123         ULONG            regSectCount;                  // sector count register I/O address
 124         ULONG            regLba0;                               // least significant byte of LBA
 125         ULONG            regLba8;                               // next least significant byte of LBA
 126         ULONG            regLba16;                              // next most significan byte of LBA
 127         ULONG            regLba24;                              // head and most 4 significant bits of LBA
 128         ULONG            regStatCmd;                    // status on read and command on write register
 129         ULONG            regStatSel;                    // board status on read and spigot select on write register
 130         ULONG            regFail;                               // fail bits control register
 131         ULONG            regAltStat;                    // alternate status and drive control register
 132         ULONG            basePort;                              // PLX base I/O port
 133         USHORT           timingMode;                    // timing mode currently set for adapter
 134         USHORT           timingPIO;                             // TRUE if PIO timing is active
 135         struct pci_dev  *pcidev;
 136         ULONG            timingAddress;                 // address to use on adapter for current timing mode
 137         ULONG            irqOwned;                              // owned IRQ or zero if shared
 138         UCHAR            numberOfDrives;                // saved number of drives on this controller
 139         UCHAR            failRegister;                  // current inverted data in fail register
 140         OUR_DEVICE       device[BIGD_MAXDRIVES];
 141         DISK_MIRROR     *raidData[BIGD_MAXDRIVES];
 142         ULONG            startSector;
 143         USHORT           sectorCount;
 144         ULONG            readCount;
 145         UCHAR           *currentSgBuffer;
 146         ULONG            currentSgCount;
 147         USHORT           nextSg;
 148         UCHAR            cmd;
 149         Scsi_Cmnd       *SCpnt;
 150         POUR_DEVICE      pdev;                                  // current device opearating on
 151         USHORT           devInReconIndex;
 152         USHORT           expectingIRQ;
 153         USHORT           reconOn;                               // Hot reconstruct is to be done.
 154         USHORT           reconPhase;                    // Hot reconstruct operation is in progress.
 155         ULONG            reconSize;
 156         USHORT           demoFail;                              // flag for RAID failure demonstration
 157         USHORT           survivor;
 158         USHORT           failinprog;
 159         struct timer_list       reconTimer;
 160         struct timer_list       timer;
 161         UCHAR           *kBuffer;
 162         dma_addr_t       kBufferDma;
 163         UCHAR            reqSense;
 164         UCHAR            atapiCdb[16];
 165         UCHAR            atapiSpecial;
 166         }       ADAPTER2220I, *PADAPTER2220I;
 167
 168 #define HOSTDATA(host) ((PADAPTER2220I)&host->hostdata)
 169
 170 #define RECON_PHASE_READY               0x01
 171 #define RECON_PHASE_COPY                0x02
 172 #define RECON_PHASE_UPDATE              0x03
 173 #define RECON_PHASE_LAST                0x04
 174 #define RECON_PHASE_END                 0x07
 175 #define RECON_PHASE_MARKING             0x80
 176 #define RECON_PHASE_FAILOVER    0xFF
 177
 178 static struct   Scsi_Host          *PsiHost[MAXADAPTER] = {NULL,};  // One for each adapter
 179 static                  int                             NumAdapters = 0;
 180 static                  int                             Installed = 0;
 181 static                  SETUP                   DaleSetup;
 182 static                  DISK_MIRROR             DiskMirror[BIGD_MAXDRIVES];
 183 static                  ULONG                   ModeArray[] = {DALE_DATA_MODE2, DALE_DATA_MODE3, DALE_DATA_MODE4, DALE_DATA_MODE5};
 184 static                  ULONG                   ModeArray2[] = {BIGD_DATA_MODE2, BIGD_DATA_MODE3, BIGD_DATA_MODE4, BIGD_DATA_MODE5};
 185
 186 static void ReconTimerExpiry (unsigned long data);
 187
 188 /*******************************************************************************************************
 189  *      Name:                   Alarm
 190  *
 191  *      Description:    Sound the for the given device
 192  *
 193  *      Parameters:             padapter - Pointer adapter data structure.
 194  *                                      device   - Device number.
 195  *
 196  *      Returns:                Nothing.
 197  *
 198  ******************************************************************************************************/
 199 static void Alarm (PADAPTER2220I padapter, UCHAR device)
 200         {
 201         UCHAR   zc;
 202
 203         if ( padapter->bigD )
 204                 {
 205                 zc = device | (FAIL_ANY | FAIL_AUDIBLE);
 206                 if ( padapter->failRegister & FAIL_ANY )
 207                         zc |= FAIL_MULTIPLE;
 208
 209                 padapter->failRegister = zc;
 210                 outb_p (~zc, padapter->regFail);
 211                 }
 212         else
 213                 outb_p (0x3C | (1 << device), padapter->regFail);                       // sound alarm and set fail light
 214         }
 215 /****************************************************************
 216  *      Name:   MuteAlarm       :LOCAL
 217  *
 218  *      Description:    Mute the audible alarm.
 219  *
 220  *      Parameters:             padapter - Pointer adapter data structure.
 221  *
 222  *      Returns:                TRUE if drive does not assert DRQ in time.
 223  *
 224  ****************************************************************/
 225 static void MuteAlarm (PADAPTER2220I padapter)
 226         {
 227         UCHAR   old;
 228
 229         if ( padapter->bigD )
 230                 {
 231                 padapter->failRegister &= ~FAIL_AUDIBLE;
 232                 outb_p (~padapter->failRegister, padapter->regFail);
 233                 }
 234         else
 235                 {
 236                 old = (inb_p (padapter->regStatSel) >> 3) | (inb_p (padapter->regStatSel) & 0x83);
 237                 outb_p (old | 0x40, padapter->regFail);
 238                 }
 239         }
 240 /****************************************************************
 241  *      Name:   WaitReady       :LOCAL
 242  *
 243  *      Description:    Wait for device ready.
 244  *
 245  *      Parameters:             padapter - Pointer adapter data structure.
 246  *
 247  *      Returns:                TRUE if drive does not assert DRQ in time.
 248  *
 249  ****************************************************************/
 250 static int WaitReady (PADAPTER2220I padapter)
 251         {
 252         ULONG   z;
 253         UCHAR   status;
 254
 255         for ( z = 0;  z < (TIMEOUT_READY * 4);  z++ )
 256                 {
 257                 status = inb_p (padapter->regStatCmd);
 258                 if ( (status & (IDE_STATUS_DRDY | IDE_STATUS_BUSY)) == IDE_STATUS_DRDY )
 259                         return 0;
 260                 udelay (250);
 261                 }
 262         return status;
 263         }
 264 /****************************************************************
 265  *      Name:   WaitReadyReset  :LOCAL
 266  *
 267  *      Description:    Wait for device ready.
 268  *
 269  *      Parameters:             padapter - Pointer adapter data structure.
 270  *
 271  *      Returns:                TRUE if drive does not assert DRQ in time.
 272  *
 273  ****************************************************************/
 274 static int WaitReadyReset (PADAPTER2220I padapter)
 275         {
 276         ULONG   z;
 277         UCHAR   status;
 278
 279         for ( z = 0;  z < (125 * 16);  z++ )                            // wait up to 1/4 second
 280                 {
 281                 status = inb_p (padapter->regStatCmd);
 282                 if ( (status & (IDE_STATUS_DRDY | IDE_STATUS_BUSY)) == IDE_STATUS_DRDY )
 283                         {
 284                         DEB (printk ("\nPCI2220I:  Reset took %ld mSec to be ready", z / 8));
 285                         return 0;
 286                         }
 287                 udelay (125);
 288                 }
 289         DEB (printk ("\nPCI2220I:  Reset took more than 2 Seconds to come ready, Disk Failure"));
 290         return status;
 291         }
 292 /****************************************************************
 293  *      Name:   WaitDrq :LOCAL
 294  *
 295  *      Description:    Wait for device ready for data transfer.
 296  *
 297  *      Parameters:             padapter - Pointer adapter data structure.
 298  *
 299  *      Returns:                TRUE if drive does not assert DRQ in time.
 300  *
 301  ****************************************************************/
 302 static int WaitDrq (PADAPTER2220I padapter)
 303         {
 304         ULONG   z;
 305         UCHAR   status;
 306
 307         for ( z = 0;  z < (TIMEOUT_DRQ * 4);  z++ )
 308                 {
 309                 status = inb_p (padapter->regStatCmd);
 310                 if ( status & IDE_STATUS_DRQ )
 311                         return 0;
 312                 udelay (250);
 313                 }
 314         return status;
 315         }
 316 /****************************************************************
 317  *      Name:   AtapiWaitReady  :LOCAL
 318  *
 319  *      Description:    Wait for device busy and DRQ to be cleared.
 320  *
 321  *      Parameters:             padapter - Pointer adapter data structure.
 322  *                                      msec     - Number of milliseconds to wait.
 323  *
 324  *      Returns:                TRUE if drive does not clear busy in time.
 325  *
 326  ****************************************************************/
 327 static int AtapiWaitReady (PADAPTER2220I padapter, int msec)
 328         {
 329         int z;
 330
 331         for ( z = 0;  z < (msec * 16);  z++ )
 332                 {
 333                 if ( !(inb_p (padapter->regStatCmd) & (IDE_STATUS_BUSY | IDE_STATUS_DRQ)) )
 334                         return FALSE;
 335                 udelay (125);
 336                 }
 337         return TRUE;
 338         }
 339 /****************************************************************
 340  *      Name:   AtapiWaitDrq    :LOCAL
 341  *
 342  *      Description:    Wait for device ready for data transfer.
 343  *
 344  *      Parameters:             padapter - Pointer adapter data structure.
 345  *                                      msec     - Number of milliseconds to wait.
 346  *
 347  *      Returns:                TRUE if drive does not assert DRQ in time.
 348  *
 349  ****************************************************************/
 350 static int AtapiWaitDrq (PADAPTER2220I padapter, int msec)
 351         {
 352         ULONG   z;
 353
 354         for ( z = 0;  z < (msec * 16);  z++ )
 355                 {
 356                 if ( inb_p (padapter->regStatCmd) & IDE_STATUS_DRQ )
 357                         return 0;
 358                 udelay (128);
 359                 }
 360         return TRUE;
 361         }
 362 /****************************************************************
 363  *      Name:   HardReset       :LOCAL
 364  *
 365  *      Description:    Wait for device ready for data transfer.
 366  *
 367  *      Parameters:             padapter - Pointer adapter data structure.
 368  *                                      pdev     - Pointer to device.
 369  *                                      spigot   - Spigot number.
 370  *
 371  *      Returns:                TRUE if drive does not assert DRQ in time.
 372  *
 373  ****************************************************************/
 374 static int HardReset (PADAPTER2220I padapter, POUR_DEVICE pdev, UCHAR spigot)
 375         {
 376         DEB (printk ("\npci2220i:RESET  spigot = %X  devices = %d, %d", spigot, pdev->deviceID[0], pdev->deviceID[1]));
 377         mdelay (100);                                                                           // just wait 100 mSec to let drives flush
 378         SelectSpigot (padapter, spigot | SEL_IRQ_OFF);
 379
 380         outb_p (0x0E, padapter->regAltStat);                                    // reset the suvivor
 381         udelay (100);                                                                                   // wait a little
 382         outb_p (0x08, padapter->regAltStat);                                    // clear the reset
 383         udelay (100);
 384
 385         outb_p (0xA0, padapter->regLba24);                                              // select the master drive
 386         if ( WaitReadyReset (padapter) )
 387                 {
 388                 DEB (printk ("\npci2220i: master not ready after reset"));
 389                 return TRUE;
 390                 }
 391         outb_p (0xB0, padapter->regLba24);                                              // try the slave drive
 392         if ( (inb_p (padapter->regStatCmd) & (IDE_STATUS_DRDY | IDE_STATUS_BUSY)) == IDE_STATUS_DRDY )
 393                 {
 394                 DEB (printk ("\nPCI2220I: initializing slave drive on spigot %X", spigot));
 395                 outb_p (SECTORSXFER, padapter->regSectCount);
 396                 WriteCommand (padapter, IDE_CMD_SET_MULTIPLE);
 397                 if ( WaitReady (padapter) )
 398                         {
 399                         DEB (printk ("\npci2220i: slave not ready after set multiple"));
 400                         return TRUE;
 401                         }
 402                 }
 403
 404         outb_p (0xA0, padapter->regLba24);                              // select the drive
 405         outb_p (SECTORSXFER, padapter->regSectCount);
 406         WriteCommand (padapter, IDE_CMD_SET_MULTIPLE);
 407         if ( WaitReady (padapter) )
 408                 {
 409                 DEB (printk ("\npci2220i: master not ready after set multiple"));
 410                 return TRUE;
 411                 }
 412         return FALSE;
 413         }
 414 /****************************************************************
 415  *      Name:   AtapiReset      :LOCAL
 416  *
 417  *      Description:    Wait for device ready for data transfer.
 418  *
 419  *      Parameters:             padapter - Pointer adapter data structure.
 420  *                                      pdev     - Pointer to device.
 421  *
 422  *      Returns:                TRUE if drive does not come ready.
 423  *
 424  ****************************************************************/
 425 static int AtapiReset (PADAPTER2220I padapter, POUR_DEVICE pdev)
 426         {
 427         SelectSpigot (padapter, pdev->spigot);
 428         AtapiDevice (padapter, pdev->byte6);
 429         AtapiCountLo (padapter, 0);
 430         AtapiCountHi (padapter, 0);
 431         WriteCommand (padapter, IDE_COMMAND_ATAPI_RESET);
 432         udelay (125);
 433         if ( AtapiWaitReady (padapter, 1000) )
 434                 return TRUE;
 435         if ( inb_p (padapter->regStatCmd) || (inb_p (padapter->regLba8) != 0x14) || (inb_p (padapter->regLba16) != 0xEB) )
 436                 return TRUE;
 437         return FALSE;
 438         }
 439 /****************************************************************
 440  *      Name:   WalkScatGath    :LOCAL
 441  *
 442  *      Description:    Transfer data to/from scatter/gather buffers.
 443  *
 444  *      Parameters:             padapter - Pointer adapter data structure.
 445  *                                      datain   - TRUE if data read.
 446  *                                      length   - Number of bytes to transfer.
 447  *
 448  *      Returns:                Nothing.
 449  *
 450  ****************************************************************/
 451 static void WalkScatGath (PADAPTER2220I padapter, UCHAR datain, ULONG length)
 452         {
 453         ULONG    count;
 454         UCHAR   *buffer = padapter->kBuffer;
 455
 456         while ( length )
 457                 {
 458                 count = ( length > padapter->currentSgCount ) ? padapter->currentSgCount : length;
 459
 460                 if ( datain )
 461                         memcpy (padapter->currentSgBuffer, buffer, count);
 462                 else
 463                         memcpy (buffer, padapter->currentSgBuffer, count);
 464
 465                 padapter->currentSgCount -= count;
 466                 if ( !padapter->currentSgCount )
 467                         {
 468                         if ( padapter->nextSg < padapter->SCpnt->use_sg )
 469                                 {
 470                                 padapter->currentSgBuffer = ((struct scatterlist *)padapter->SCpnt->request_buffer)[padapter->nextSg].address;
 471                                 padapter->currentSgCount = ((struct scatterlist *)padapter->SCpnt->request_buffer)[padapter->nextSg].length;
 472                                 padapter->nextSg++;
 473                                 }
 474                         }
 475                 else
 476                         padapter->currentSgBuffer += count;
 477
 478                 length -= count;
 479                 buffer += count;
 480                 }
 481         }
 482 /****************************************************************
 483  *      Name:   BusMaster       :LOCAL
 484  *
 485  *      Description:    Do a bus master I/O.
 486  *
 487  *      Parameters:             padapter - Pointer adapter data structure.
 488  *                                      datain   - TRUE if data read.
 489  *                                      irq              - TRUE if bus master interrupt expected.
 490  *
 491  *      Returns:                Nothing.
 492  *
 493  ****************************************************************/
 494 static void BusMaster (PADAPTER2220I padapter, UCHAR datain, UCHAR irq)
 495         {
 496         ULONG zl;
 497
 498         zl = ( padapter->sectorCount > MAX_BUS_MASTER_BLOCKS ) ? MAX_BUS_MASTER_BLOCKS : padapter->sectorCount;
 499         padapter->sectorCount -= zl;
 500         zl *= (ULONG)BYTES_PER_SECTOR;
 501
 502         if ( datain )
 503                 {
 504                 padapter->readCount = zl;
 505                 outb_p (8, padapter->regDmaDesc);                                                       // read operation
 506                 if ( padapter->bigD )
 507                         {
 508                         if ( irq && !padapter->sectorCount )
 509                                 outb_p (0x0C, padapter->regDmaMode);                            // interrupt on
 510                         else
 511                                 outb_p (0x08, padapter->regDmaMode);                            // no interrupt
 512                         }
 513                 else
 514                         {
 515                         if ( irq && !padapter->sectorCount )
 516                                 outb_p (0x05, padapter->regDmaMode);                            // interrupt on
 517                         else
 518                                 outb_p (0x01, padapter->regDmaMode);                            // no interrupt
 519                         }
 520                 }
 521         else
 522                 {
 523                 outb_p (0x00, padapter->regDmaDesc);                                            // write operation
 524                 if ( padapter->bigD )
 525                         outb_p (0x08, padapter->regDmaMode);                                    // no interrupt
 526                 else
 527                         outb_p (0x01, padapter->regDmaMode);                                    // no interrupt
 528                 WalkScatGath (padapter, FALSE, zl);
 529                 }
 530
 531         outl (padapter->timingAddress, padapter->regDmaAddrLoc);
 532         outl (padapter->kBufferDma, padapter->regDmaAddrPci);
 533         outl (zl, padapter->regDmaCount);
 534         outb_p (0x03, padapter->regDmaCmdStat);                                                 // kick the DMA engine in gear
 535         }
 536 /****************************************************************
 537  *      Name:   AtapiBusMaster  :LOCAL
 538  *
 539  *      Description:    Do a bus master I/O.
 540  *
 541  *      Parameters:             padapter - Pointer adapter data structure.
 542  *                                      datain   - TRUE if data read.
 543  *                                      length   - Number of bytes to transfer.
 544  *
 545  *      Returns:                Nothing.
 546  *
 547  ****************************************************************/
 548 static void AtapiBusMaster (PADAPTER2220I padapter, UCHAR datain, ULONG length)
 549         {
 550         outl (padapter->timingAddress, padapter->regDmaAddrLoc);
 551         outl (padapter->kBufferDma, padapter->regDmaAddrPci);
 552         outl (length, padapter->regDmaCount);
 553         if ( datain )
 554                 {
 555                 if ( padapter->readCount )
 556                                 WalkScatGath (padapter, TRUE, padapter->readCount);
 557                 outb_p (0x08, padapter->regDmaDesc);                                            // read operation
 558                 outb_p (0x08, padapter->regDmaMode);                                            // no interrupt
 559                 padapter->readCount = length;
 560                 }
 561         else
 562                 {
 563                 outb_p (0x00, padapter->regDmaDesc);                                            // write operation
 564                 outb_p (0x08, padapter->regDmaMode);                                            // no interrupt
 565                 if ( !padapter->atapiSpecial )
 566                         WalkScatGath (padapter, FALSE, length);
 567                 }
 568         outb_p (0x03, padapter->regDmaCmdStat);                                                 // kick the DMA engine in gear
 569         }
 570 /****************************************************************
 571  *      Name:   WriteData       :LOCAL
 572  *
 573  *      Description:    Write data to device.
 574  *
 575  *      Parameters:             padapter - Pointer adapter data structure.
 576  *
 577  *      Returns:                TRUE if drive does not assert DRQ in time.
 578  *
 579  ****************************************************************/
 580 static int WriteData (PADAPTER2220I padapter)
 581         {
 582         ULONG   zl;
 583
 584         if ( !WaitDrq (padapter) )
 585                 {
 586                 if ( padapter->timingPIO )
 587                         {
 588                         zl = (padapter->sectorCount > MAX_BUS_MASTER_BLOCKS) ? MAX_BUS_MASTER_BLOCKS : padapter->sectorCount;
 589                         WalkScatGath (padapter, FALSE, zl * BYTES_PER_SECTOR);
 590                         outsw (padapter->regData, padapter->kBuffer, zl * (BYTES_PER_SECTOR / 2));
 591                         padapter->sectorCount -= zl;
 592                         }
 593                 else
 594                         BusMaster (padapter, 0, 0);
 595                 return 0;
 596                 }
 597         padapter->cmd = 0;                                                                                              // null out the command byte
 598         return 1;
 599         }
 600 /****************************************************************
 601  *      Name:   WriteDataBoth   :LOCAL
 602  *
 603  *      Description:    Write data to device.
 604  *
 605  *      Parameters:             padapter - Pointer to adapter structure.
 606  *                                      pdev     - Pointer to device structure
 607  *
 608  *      Returns:                Index + 1 of drive not failed or zero for OK.
 609  *
 610  ****************************************************************/
 611 static int WriteDataBoth (PADAPTER2220I padapter, POUR_DEVICE pdev)
 612         {
 613         ULONG   zl;
 614         UCHAR   status0, status1;
 615
 616         SelectSpigot (padapter, pdev->spigots[0]);
 617         status0 = WaitDrq (padapter);
 618         if ( !status0 )
 619                 {
 620                 SelectSpigot (padapter, pdev->spigots[1]);
 621                 status1 = WaitDrq (padapter);
 622                 if ( !status1 )
 623                         {
 624                         SelectSpigot (padapter, pdev->spigots[0] | pdev->spigots[1] | padapter->bigD);
 625                         if ( padapter->timingPIO )
 626                                 {
 627                                 zl = (padapter->sectorCount > MAX_BUS_MASTER_BLOCKS) ? MAX_BUS_MASTER_BLOCKS : padapter->sectorCount;
 628                                 WalkScatGath (padapter, FALSE, zl * BYTES_PER_SECTOR);
 629                                 outsw (padapter->regData, padapter->kBuffer, zl * (BYTES_PER_SECTOR / 2));
 630                                 padapter->sectorCount -= zl;
 631                                 }
 632                         else
 633                                 BusMaster (padapter, 0, 0);
 634                         return 0;
 635                         }
 636                 }
 637         padapter->cmd = 0;                                                                                              // null out the command byte
 638         if ( status0 )
 639                 return 2;
 640         return 1;
 641         }
 642 /****************************************************************
 643  *      Name:   IdeCmd  :LOCAL
 644  *
 645  *      Description:    Process an IDE command.
 646  *
 647  *      Parameters:             padapter - Pointer adapter data structure.
 648  *                                      pdev     - Pointer to device.
 649  *
 650  *      Returns:                Zero if no error or status register contents on error.
 651  *
 652  ****************************************************************/
 653 static UCHAR IdeCmd (PADAPTER2220I padapter, POUR_DEVICE pdev)
 654         {
 655         UCHAR   status;
 656
 657         SelectSpigot (padapter, pdev->spigot | padapter->bigD);                                                 // select the spigot
 658         outb_p (pdev->byte6 | ((UCHAR *)(&padapter->startSector))[3], padapter->regLba24);                      // select the drive
 659         status = WaitReady (padapter);
 660         if ( !status )
 661                 {
 662                 outb_p (padapter->sectorCount, padapter->regSectCount);
 663                 outb_p (((UCHAR *)(&padapter->startSector))[0], padapter->regLba0);
 664                 outb_p (((UCHAR *)(&padapter->startSector))[1], padapter->regLba8);
 665                 outb_p (((UCHAR *)(&padapter->startSector))[2], padapter->regLba16);
 666                 padapter->expectingIRQ = TRUE;
 667                 WriteCommand (padapter, padapter->cmd);
 668                 return 0;
 669                 }
 670
 671         padapter->cmd = 0;                                                                      // null out the command byte
 672         return status;
 673         }
 674 /****************************************************************
 675  *      Name:   IdeCmdBoth      :LOCAL
 676  *
 677  *      Description:    Process an IDE command to both drivers.
 678  *
 679  *      Parameters:             padapter - Pointer adapter data structure.
 680  *                                      pdev     - Pointer to device structure
 681  *
 682  *      Returns:                Index + 1 of drive not failed or zero for OK.
 683  *
 684  ****************************************************************/
 685 static UCHAR IdeCmdBoth (PADAPTER2220I padapter, POUR_DEVICE pdev)
 686         {
 687         UCHAR   status0;
 688         UCHAR   status1;
 689
 690         SelectSpigot (padapter, pdev->spigots[0] | pdev->spigots[1]);                                                           // select the spigots
 691         outb_p (padapter->pdev->byte6 | ((UCHAR *)(&padapter->startSector))[3], padapter->regLba24);// select the drive
 692         SelectSpigot (padapter, pdev->spigots[0]);
 693         status0 = WaitReady (padapter);
 694         if ( !status0 )
 695                 {
 696                 SelectSpigot (padapter, pdev->spigots[1]);
 697                 status1 = WaitReady (padapter);
 698                 if ( !status1 )
 699                         {
 700                         SelectSpigot (padapter, pdev->spigots[0] | pdev->spigots[1] | padapter->bigD);
 701                         outb_p (padapter->sectorCount, padapter->regSectCount);
 702                         outb_p (((UCHAR *)(&padapter->startSector))[0], padapter->regLba0);
 703                         outb_p (((UCHAR *)(&padapter->startSector))[1], padapter->regLba8);
 704                         outb_p (((UCHAR *)(&padapter->startSector))[2], padapter->regLba16);
 705                         padapter->expectingIRQ = TRUE;
 706                         WriteCommand (padapter, padapter->cmd);
 707                         return 0;
 708                         }
 709                 }
 710         padapter->cmd = 0;                                                                      // null out the command byte
 711         if ( status0 )
 712                 return 2;
 713         return 1;
 714         }
 715 /****************************************************************
 716  *      Name:   OpDone  :LOCAL
 717  *
 718  *      Description:    Complete an operatoin done sequence.
 719  *
 720  *      Parameters:             padapter - Pointer to host data block.
 721  *                                      spigot   - Spigot select code.
 722  *                                      device   - Device byte code.
 723  *
 724  *      Returns:                Nothing.
 725  *
 726  ****************************************************************/
 727 static void OpDone (PADAPTER2220I padapter, ULONG result)
 728         {
 729         Scsi_Cmnd          *SCpnt = padapter->SCpnt;
 730
 731         if ( padapter->reconPhase )
 732                 {
 733                 padapter->reconPhase = 0;
 734                 if ( padapter->SCpnt )
 735                         {
 736                         Pci2220i_QueueCommand (SCpnt, SCpnt->scsi_done);
 737                         }
 738                 else
 739                         {
 740                         if ( padapter->reconOn )
 741                                 {
 742                                 ReconTimerExpiry ((unsigned long)padapter);
 743                                 }
 744                         }
 745                 }
 746         else
 747                 {
 748                 padapter->cmd = 0;
 749                 padapter->SCpnt = NULL;
 750                 padapter->pdev = NULL;
 751                 SCpnt->result = result;
 752                 SCpnt->scsi_done (SCpnt);
 753                 if ( padapter->reconOn && !padapter->reconTimer.data )
 754                         {
 755                         padapter->reconTimer.expires = jiffies + (HZ / 4);      // start in 1/4 second
 756                         padapter->reconTimer.data = (unsigned long)padapter;
 757                         add_timer (&padapter->reconTimer);
 758                         }
 759                 }
 760         }
 761 /****************************************************************
 762  *      Name:   InlineIdentify  :LOCAL
 763  *
 764  *      Description:    Do an intline inquiry on a drive.
 765  *
 766  *      Parameters:             padapter - Pointer to host data block.
 767  *                                      spigot   - Spigot select code.
 768  *                                      device   - Device byte code.
 769  *
 770  *      Returns:                Last addressable sector or zero if none.
 771  *
 772  ****************************************************************/
 773 static ULONG InlineIdentify (PADAPTER2220I padapter, UCHAR spigot, UCHAR device)
 774         {
 775         PIDENTIFY_DATA  pid = (PIDENTIFY_DATA)padapter->kBuffer;
 776
 777         SelectSpigot (padapter, spigot | SEL_IRQ_OFF);                                  // select the spigot
 778         outb_p ((device << 4) | 0xA0, padapter->regLba24);                              // select the drive
 779         if ( WaitReady (padapter) )
 780                 return 0;
 781         WriteCommand (padapter, IDE_COMMAND_IDENTIFY);
 782         if ( WaitDrq (padapter) )
 783                 return 0;
 784         insw (padapter->regData, padapter->kBuffer, sizeof (IDENTIFY_DATA) >> 1);
 785         return (pid->LBATotalSectors - 1);
 786         }
 787 /****************************************************************
 788  *      Name:   AtapiIdentify   :LOCAL
 789  *
 790  *      Description:    Do an intline inquiry on a drive.
 791  *
 792  *      Parameters:             padapter - Pointer to host data block.
 793  *                                      pdev     - Pointer to device table.
 794  *
 795  *      Returns:                TRUE on error.
 796  *
 797  ****************************************************************/
 798 static ULONG AtapiIdentify (PADAPTER2220I padapter, POUR_DEVICE pdev)
 799         {
 800         ATAPI_GENERAL_0         ag0;
 801         USHORT                          zs;
 802         int                                     z;
 803
 804         AtapiDevice (padapter, pdev->byte6);
 805         WriteCommand (padapter, IDE_COMMAND_ATAPI_IDENTIFY);
 806         if ( AtapiWaitDrq (padapter, 3000) )
 807                 return TRUE;
 808
 809         *(USHORT *)&ag0 = inw_p (padapter->regData);
 810         for ( z = 0;  z < 255;  z++ )
 811                 zs = inw_p (padapter->regData);
 812
 813         if ( ag0.ProtocolType == 2 )
 814                 {
 815                 if ( ag0.CmdDrqType == 1 )
 816                         pdev->cmdDrqInt = TRUE;
 817                 switch ( ag0.CmdPacketSize )
 818                         {
 819                         case 0:
 820                                 pdev->packet = 6;
 821                                 break;
 822                         case 1:
 823                                 pdev->packet = 8;
 824                                 break;
 825                         default:
 826                                 pdev->packet = 6;
 827                                 break;
 828                         }
 829                 return FALSE;
 830                 }
 831         return TRUE;
 832         }
 833 /****************************************************************
 834  *      Name:   Atapi2Scsi
 835  *
 836  *      Description:    Convert ATAPI data to SCSI data.
 837  *
 838  *      Parameters:             padapter - Pointer adapter data structure.
 839  *                                      SCpnt    - Pointer to SCSI command structure.
 840  *
 841  *      Returns:                Nothing.
 842  *
 843  ****************************************************************/
 844 void Atapi2Scsi (PADAPTER2220I padapter, Scsi_Cmnd *SCpnt)
 845         {
 846         UCHAR   *buff = padapter->currentSgBuffer;
 847
 848         switch ( SCpnt->cmnd[0] )
 849                 {
 850                 case SCSIOP_MODE_SENSE:
 851                         buff[0] = padapter->kBuffer[1];
 852                         buff[1] = padapter->kBuffer[2];
 853                         buff[2] = padapter->kBuffer[3];
 854                         buff[3] = padapter->kBuffer[7];
 855                         memcpy (&buff[4], &padapter->kBuffer[8], padapter->atapiCdb[8] - 8);
 856                         break;
 857                 case SCSIOP_INQUIRY:
 858                         padapter->kBuffer[2] = 2;
 859                         memcpy (buff, padapter->kBuffer, padapter->currentSgCount);
 860                         break;
 861                 default:
 862                         if ( padapter->readCount )
 863                                 WalkScatGath (padapter, TRUE, padapter->readCount);
 864                         break;
 865                 }
 866         }
 867 /****************************************************************
 868  *      Name:   Scsi2Atapi
 869  *
 870  *      Description:    Convert SCSI packet command to Atapi packet command.
 871  *
 872  *      Parameters:             padapter - Pointer adapter data structure.
 873  *                                      SCpnt    - Pointer to SCSI command structure.
 874  *
 875  *      Returns:                Nothing.
 876  *
 877  ****************************************************************/
 878 static void Scsi2Atapi (PADAPTER2220I padapter, Scsi_Cmnd *SCpnt)
 879         {
 880         UCHAR   *cdb = SCpnt->cmnd;
 881         UCHAR   *buff = padapter->currentSgBuffer;
 882
 883         switch (cdb[0])
 884                 {
 885                 case SCSIOP_READ6:
 886             padapter->atapiCdb[0] = SCSIOP_READ;
 887                         padapter->atapiCdb[1] = cdb[1] & 0xE0;
 888             padapter->atapiCdb[3] = cdb[1] & 0x1F;
 889                         padapter->atapiCdb[4] = cdb[2];
 890                         padapter->atapiCdb[5] = cdb[3];
 891                         padapter->atapiCdb[8] = cdb[4];
 892                         padapter->atapiCdb[9] = cdb[5];
 893                         break;
 894                 case SCSIOP_WRITE6:
 895             padapter->atapiCdb[0] = SCSIOP_WRITE;
 896                         padapter->atapiCdb[1] = cdb[1] & 0xE0;
 897             padapter->atapiCdb[3] = cdb[1] & 0x1F;
 898                         padapter->atapiCdb[4] = cdb[2];
 899                         padapter->atapiCdb[5] = cdb[3];
 900                         padapter->atapiCdb[8] = cdb[4];
 901                         padapter->atapiCdb[9] = cdb[5];
 902                         break;
 903         case SCSIOP_MODE_SENSE:
 904             padapter->atapiCdb[0] = SCSIOP_MODE_SENSE10;
 905                         padapter->atapiCdb[2] = cdb[2];
 906                         padapter->atapiCdb[8] = cdb[4] + 4;
 907             break;
 908
 909         case SCSIOP_MODE_SELECT:
 910                         padapter->atapiSpecial = TRUE;
 911                         padapter->atapiCdb[0] = SCSIOP_MODE_SELECT10;
 912                         padapter->atapiCdb[1] = cdb[1] | 0x10;
 913                         memcpy (padapter->kBuffer, buff, 4);
 914                         padapter->kBuffer[4] = padapter->kBuffer[5] = 0;
 915                         padapter->kBuffer[6] = padapter->kBuffer[7] = 0;
 916                         memcpy (&padapter->kBuffer[8], &buff[4], cdb[4] - 4);
 917                         padapter->atapiCdb[8] = cdb[4] + 4;
 918                         break;
 919             }
 920         }
 921 /****************************************************************
 922  *      Name:   AtapiSendCdb
 923  *
 924  *      Description:    Send the CDB packet to the device.
 925  *
 926  *      Parameters:             padapter - Pointer adapter data structure.
 927  *                                      pdev     - Pointer to device.
 928  *                                      cdb              - Pointer to 16 byte SCSI cdb.
 929  *
 930  *      Returns:                Nothing.
 931  *
 932  ****************************************************************/
 933 static void AtapiSendCdb (PADAPTER2220I padapter, POUR_DEVICE pdev, CHAR *cdb)
 934         {
 935         DEB (printk ("\nPCI2242I: CDB: %X %X %X %X %X %X %X %X %X %X %X %X", cdb[0], cdb[1], cdb[2], cdb[3], cdb[4], cdb[5], cdb[6], cdb[7], cdb[8], cdb[9], cdb[10], cdb[11]));
 936         outsw (padapter->regData, cdb, pdev->packet);
 937         }
 938 /****************************************************************
 939  *      Name:   AtapiRequestSense
 940  *
 941  *      Description:    Send the CDB packet to the device.
 942  *
 943  *      Parameters:             padapter - Pointer adapter data structure.
 944  *                                      pdev     - Pointer to device.
 945  *                                      SCpnt    - Pointer to SCSI command structure.
 946  *                                      pass     - If true then this is the second pass to send cdb.
 947  *
 948  *      Returns:                TRUE on error.
 949  *
 950  ****************************************************************/
 951 static int AtapiRequestSense (PADAPTER2220I padapter, POUR_DEVICE pdev, Scsi_Cmnd *SCpnt, UCHAR pass)
 952         {
 953         UCHAR   cdb[16] = {SCSIOP_REQUEST_SENSE,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0};
 954
 955         DEB (printk ("\nPCI2242I: AUTO REQUEST SENSE"));
 956         cdb[4] = (UCHAR)(sizeof (SCpnt->sense_buffer));
 957         if ( !pass )
 958                 {
 959                 padapter->reqSense = TRUE;
 960                 AtapiCountLo (padapter, cdb[4]);
 961                 AtapiCountHi (padapter, 0);
 962                 outb_p (0, padapter->regError);
 963                 WriteCommand (padapter, IDE_COMMAND_ATAPI_PACKET);
 964                 if ( pdev->cmdDrqInt )
 965                         return FALSE;
 966
 967                 if ( AtapiWaitDrq (padapter, 500) )
 968                         return TRUE;
 969                 }
 970         AtapiSendCdb (padapter, pdev, cdb);
 971         return FALSE;
 972         }
 973 /****************************************************************
 974  *      Name:   InlineReadSignature     :LOCAL
 975  *
 976  *      Description:    Do an inline read RAID sigature.
 977  *
 978  *      Parameters:             padapter - Pointer adapter data structure.
 979  *                                      pdev     - Pointer to device.
 980  *                                      index    - index of data to read.
 981  *
 982  *      Returns:                Zero if no error or status register contents on error.
 983  *
 984  ****************************************************************/
 985 static UCHAR InlineReadSignature (PADAPTER2220I padapter, POUR_DEVICE pdev, int index)
 986         {
 987         UCHAR   status;
 988         ULONG   zl = pdev->lastsectorlba[index];
 989
 990         SelectSpigot (padapter, pdev->spigots[index] | SEL_IRQ_OFF);    // select the spigot without interrupts
 991         outb_p (pdev->byte6 | ((UCHAR *)&zl)[3], padapter->regLba24);
 992         status = WaitReady (padapter);
 993         if ( !status )
 994                 {
 995                 outb_p (((UCHAR *)&zl)[2], padapter->regLba16);
 996                 outb_p (((UCHAR *)&zl)[1], padapter->regLba8);
 997                 outb_p (((UCHAR *)&zl)[0], padapter->regLba0);
 998                 outb_p (1, padapter->regSectCount);
 999                 WriteCommand (padapter, IDE_COMMAND_READ);
1000                 status = WaitDrq (padapter);
1001                 if ( !status )
1002                         {
1003                         insw (padapter->regData, padapter->kBuffer, BYTES_PER_SECTOR / 2);
1004                         ((ULONG *)(&pdev->DiskMirror[index]))[0] = ((ULONG *)(&padapter->kBuffer[DISK_MIRROR_POSITION]))[0];
1005                         ((ULONG *)(&pdev->DiskMirror[index]))[1] = ((ULONG *)(&padapter->kBuffer[DISK_MIRROR_POSITION]))[1];
1006                         // some drives assert DRQ before IRQ so let's make sure we clear the IRQ
1007                         WaitReady (padapter);
1008                         return 0;
1009                         }
1010                 }
1011         return status;
1012         }
1013 /****************************************************************
1014  *      Name:   DecodeError     :LOCAL
1015  *
1016  *      Description:    Decode and process device errors.
1017  *
1018  *      Parameters:             padapter - Pointer to adapter data.
1019  *                                      status - Status register code.
1020  *
1021  *      Returns:                The driver status code.
1022  *
1023  ****************************************************************/
1024 static ULONG DecodeError (PADAPTER2220I padapter, UCHAR status)
1025         {
1026         UCHAR                   error;
1027
1028         padapter->expectingIRQ = 0;
1029         if ( status & IDE_STATUS_WRITE_FAULT )
1030                 {
1031                 return DID_PARITY << 16;
1032                 }
1033         if ( status & IDE_STATUS_BUSY )
1034                 return DID_BUS_BUSY << 16;
1035
1036         error = inb_p (padapter->regError);
1037         DEB(printk ("\npci2220i error register: %x", error));
1038         switch ( error )
1039                 {
1040                 case IDE_ERROR_AMNF:
1041                 case IDE_ERROR_TKONF:
1042                 case IDE_ERROR_ABRT:
1043                 case IDE_ERROR_IDFN:
1044                 case IDE_ERROR_UNC:
1045                 case IDE_ERROR_BBK:
1046                 default:
1047                         return DID_ERROR << 16;
1048                 }
1049         return DID_ERROR << 16;
1050         }
1051 /****************************************************************
1052  *      Name:   StartTimer      :LOCAL
1053  *
1054  *      Description:    Start the timer.
1055  *
1056  *      Parameters:             ipadapter - Pointer adapter data structure.
1057  *
1058  *      Returns:                Nothing.
1059  *
1060  ****************************************************************/
1061 static void StartTimer (PADAPTER2220I padapter)
1062         {
1063         padapter->timer.expires = jiffies + TIMEOUT_DATA;
1064         add_timer (&padapter->timer);
1065         }
1066 /****************************************************************
1067  *      Name:   WriteSignature  :LOCAL
1068  *
1069  *      Description:    Start the timer.
1070  *
1071  *      Parameters:             padapter - Pointer adapter data structure.
1072  *                                      pdev     - Pointer to our device.
1073  *                                      spigot   - Selected spigot.
1074  *                                      index    - index of mirror signature on device.
1075  *
1076  *      Returns:                TRUE on any error.
1077  *
1078  ****************************************************************/
1079 static int WriteSignature (PADAPTER2220I padapter, POUR_DEVICE pdev, UCHAR spigot, int index)
1080         {
1081         ULONG   zl;
1082
1083         SelectSpigot (padapter, spigot);
1084         zl = pdev->lastsectorlba[index];
1085         outb_p (pdev->byte6 | ((UCHAR *)&zl)[3], padapter->regLba24);
1086         outb_p (((UCHAR *)&zl)[2], padapter->regLba16);
1087         outb_p (((UCHAR *)&zl)[1], padapter->regLba8);
1088         outb_p (((UCHAR *)&zl)[0], padapter->regLba0);
1089         outb_p (1, padapter->regSectCount);
1090
1091         WriteCommand (padapter, IDE_COMMAND_WRITE);
1092         if ( WaitDrq (padapter) )
1093                 return TRUE;
1094         StartTimer (padapter);
1095         padapter->expectingIRQ = TRUE;
1096
1097         ((ULONG *)(&padapter->kBuffer[DISK_MIRROR_POSITION]))[0] = ((ULONG *)(&pdev->DiskMirror[index]))[0];
1098         ((ULONG *)(&padapter->kBuffer[DISK_MIRROR_POSITION]))[1] = ((ULONG *)(&pdev->DiskMirror[index]))[1];
1099         outsw (padapter->regData, padapter->kBuffer, BYTES_PER_SECTOR / 2);
1100         return FALSE;
1101         }
1102 /*******************************************************************************************************
1103  *      Name:                   InitFailover
1104  *
1105  *      Description:    This is the beginning of the failover routine
1106  *
1107  *      Parameters:             SCpnt    - Pointer to SCSI command structure.
1108  *                                      padapter - Pointer adapter data structure.
1109  *                                      pdev     - Pointer to our device.
1110  *
1111  *      Returns:                TRUE on error.
1112  *
1113  ******************************************************************************************************/
1114 static int InitFailover (PADAPTER2220I padapter, POUR_DEVICE pdev)
1115         {
1116         UCHAR   spigot;
1117
1118         DEB (printk ("\npci2220i:  Initialize failover process - survivor = %d", pdev->deviceID[padapter->survivor]));
1119         pdev->raid = FALSE;                                                                     //initializes system for non raid mode
1120         pdev->reconOn = FALSE;
1121         spigot = pdev->spigots[padapter->survivor];
1122
1123         if ( pdev->DiskMirror[padapter->survivor].status & UCBF_REBUILD )
1124                 {
1125                 DEB (printk ("\n         failed, is survivor"));
1126                 return (TRUE);
1127                 }
1128
1129         if ( HardReset (padapter, pdev, spigot) )
1130                 {
1131                 DEB (printk ("\n         failed, reset"));
1132                 return TRUE;
1133                 }
1134
1135         Alarm (padapter, pdev->deviceID[padapter->survivor ^ 1]);
1136         pdev->DiskMirror[padapter->survivor].status = UCBF_MIRRORED | UCBF_SURVIVOR;    //clear present status
1137
1138         if ( WriteSignature (padapter, pdev, spigot, padapter->survivor) )
1139                 {
1140                 DEB (printk ("\n         failed, write signature"));
1141                 return TRUE;
1142                 }
1143         padapter->failinprog = TRUE;
1144         return FALSE;
1145         }
1146 /****************************************************************
1147  *      Name:   TimerExpiry     :LOCAL
1148  *
1149  *      Description:    Timer expiry routine.
1150  *
1151  *      Parameters:             data - Pointer adapter data structure.
1152  *
1153  *      Returns:                Nothing.
1154  *
1155  ****************************************************************/
1156 static void TimerExpiry (unsigned long data)
1157         {
1158         PADAPTER2220I   padapter = (PADAPTER2220I)data;
1159         struct Scsi_Host *host = padapter->SCpnt->device->host;
1160         POUR_DEVICE             pdev = padapter->pdev;
1161         UCHAR                   status = IDE_STATUS_BUSY;
1162         UCHAR                   temp, temp1;
1163     unsigned long               flags;
1164
1165     /*
1166      * Disable interrupts, if they aren't already disabled and acquire
1167      * the I/O spinlock.
1168      */
1169     spin_lock_irqsave (host->host_lock, flags);
1170         DEB (printk ("\nPCI2220I: Timeout expired "));
1171
1172         if ( padapter->failinprog )
1173                 {
1174                 DEB (printk ("in failover process"));
1175                 OpDone (padapter, DecodeError (padapter, inb_p (padapter->regStatCmd)));
1176                 goto timerExpiryDone;
1177                 }
1178
1179         while ( padapter->reconPhase )
1180                 {
1181                 DEB (printk ("in recon phase %X", padapter->reconPhase));
1182                 switch ( padapter->reconPhase )
1183                         {
1184                         case RECON_PHASE_MARKING:
1185                         case RECON_PHASE_LAST:
1186                                 padapter->survivor = ( pdev->spigot == pdev->spigots[0] ) ? 1 : 0;
1187                                 DEB (printk ("\npci2220i: FAILURE 1"));
1188                                 if ( InitFailover (padapter, pdev) )
1189                                         OpDone (padapter, DID_ERROR << 16);
1190                                 goto timerExpiryDone;
1191
1192                         case RECON_PHASE_READY:
1193                                 OpDone (padapter, DID_ERROR << 16);
1194                                 goto timerExpiryDone;
1195
1196                         case RECON_PHASE_COPY:
1197                                 padapter->survivor = ( pdev->spigot == pdev->spigots[0] ) ? 0 : 1;
1198                                 DEB (printk ("\npci2220i: FAILURE 2"));
1199                                 DEB (printk ("\n       spig/stat = %X", inb_p (padapter->regStatSel));
1200                                 if ( InitFailover (padapter, pdev) )
1201                                         OpDone (padapter, DID_ERROR << 16);
1202                                 goto timerExpiryDone;
1203
1204                         case RECON_PHASE_UPDATE:
1205                                 padapter->survivor = ( pdev->spigot == pdev->spigots[0] ) ? 0 : 1;
1206                                 DEB (printk ("\npci2220i: FAILURE 3")));
1207                                 if ( InitFailover (padapter, pdev) )
1208                                         OpDone (padapter, DID_ERROR << 16);
1209                                 goto timerExpiryDone;
1210
1211                         case RECON_PHASE_END:
1212                                 padapter->survivor = ( pdev->spigot == pdev->spigots[0] ) ? 0 : 1;
1213                                 DEB (printk ("\npci2220i: FAILURE 4"));
1214                                 if ( InitFailover (padapter, pdev) )
1215                                         OpDone (padapter, DID_ERROR << 16);
1216                                 goto timerExpiryDone;
1217
1218                         default:
1219                                 goto timerExpiryDone;
1220                         }
1221                 }
1222
1223         while ( padapter->cmd )
1224                 {
1225                 outb_p (0x08, padapter->regDmaCmdStat);                                 // cancel interrupt from DMA engine
1226                 if ( pdev->raid )
1227                         {
1228                         if ( padapter->cmd == WRITE_CMD )
1229                                 {
1230                                 DEB (printk ("in RAID write operation"));
1231                                 temp = ( pdev->spigot & (SEL_1 | SEL_2) ) ? SEL_1 : SEL_3;
1232                                 if ( inb_p (padapter->regStatSel) & temp )
1233                                         {
1234                                         DEB (printk ("\npci2220i: Determined A OK"));
1235                                         SelectSpigot (padapter, temp | SEL_IRQ_OFF); // Masking the interrupt during spigot select
1236                                         temp = inb_p (padapter->regStatCmd);
1237                                         }
1238                                 else
1239                                         temp = IDE_STATUS_BUSY;
1240
1241                                 temp1 = ( pdev->spigot & (SEL_1 | SEL_2) ) ? SEL_2 : SEL_4;
1242                                 if ( inb (padapter->regStatSel) & temp1 )
1243                                         {
1244                                         DEB (printk ("\npci2220i: Determined B OK"));
1245                                         SelectSpigot (padapter, temp1 | SEL_IRQ_OFF); // Masking the interrupt during spigot select
1246                                         temp1 = inb_p (padapter->regStatCmd);
1247                                         }
1248                                 else
1249                                         temp1 = IDE_STATUS_BUSY;
1250
1251                                 if ( (temp & IDE_STATUS_BUSY) || (temp1 & IDE_STATUS_BUSY) )
1252                                         {
1253                                         DEB (printk ("\npci2220i: Status A: %X   B: %X", temp & 0xFF, temp1 & 0xFF));
1254                                         if ( (temp & IDE_STATUS_BUSY) && (temp1 & IDE_STATUS_BUSY) )
1255                                                 {
1256                                                 status = temp;
1257                                                 break;
1258                                                 }
1259                                         else
1260                                                 {
1261                                                 if ( temp & IDE_STATUS_BUSY )
1262                                                         padapter->survivor = 1;
1263                                                 else
1264                                                         padapter->survivor = 0;
1265                                                 if ( InitFailover (padapter, pdev) )
1266                                                         {
1267                                                         status = inb_p (padapter->regStatCmd);
1268                                                         break;
1269                                                         }
1270                                                 goto timerExpiryDone;
1271                                                 }
1272                                         }
1273                                 }
1274                         else
1275                                 {
1276                                 DEB (printk ("in RAID read operation"));
1277                                 padapter->survivor = ( pdev->spigot == pdev->spigots[0] ) ? 0 : 1;
1278                                 DEB (printk ("\npci2220i: FAILURE 6"));
1279                                 if ( InitFailover (padapter, pdev) )
1280                                         {
1281                                         status = inb_p (padapter->regStatCmd);
1282                                         break;
1283                                         }
1284                                 goto timerExpiryDone;
1285                                 }
1286                         }
1287                 else
1288                         {
1289                         DEB (printk ("in I/O operation"));
1290                         status = inb_p (padapter->regStatCmd);
1291                         }
1292                 break;
1293                 }
1294
1295         OpDone (padapter, DecodeError (padapter, status));
1296
1297 timerExpiryDone:;
1298     /*
1299      * Release the I/O spinlock and restore the original flags
1300      * which will enable interrupts if and only if they were
1301      * enabled on entry.
1302      */
1303     spin_unlock_irqrestore (host->host_lock, flags);
1304         }
1305 /****************************************************************
1306  *      Name:                   SetReconstruct  :LOCAL
1307  *
1308  *      Description:    Set the reconstruct up.
1309  *
1310  *      Parameters:             pdev    - Pointer to device structure.
1311  *                                      index   - Mirror index number.
1312  *
1313  *      Returns:                Number of sectors on new disk required.
1314  *
1315  ****************************************************************/
1316 static LONG SetReconstruct (POUR_DEVICE pdev, int index)
1317         {
1318         pdev->DiskMirror[index].status = UCBF_MIRRORED;                                                 // setup the flags
1319         pdev->DiskMirror[index ^ 1].status = UCBF_MIRRORED | UCBF_REBUILD;
1320         pdev->DiskMirror[index ^ 1].reconstructPoint = 0;                                               // start the reconstruct
1321         pdev->reconCount = 1990;                                                                                                // mark target drive early
1322         return pdev->DiskMirror[index].reconstructPoint;
1323         }
1324 /****************************************************************
1325  *      Name:   ReconTimerExpiry        :LOCAL
1326  *
1327  *      Description:    Reconstruct timer expiry routine.
1328  *
1329  *      Parameters:             data - Pointer adapter data structure.
1330  *
1331  *      Returns:                Nothing.
1332  *
1333  ****************************************************************/
1334 static void ReconTimerExpiry (unsigned long data)
1335         {
1336         PADAPTER2220I   padapter = (PADAPTER2220I)data;
1337         struct Scsi_Host *host = padapter->SCpnt->device->host;
1338         POUR_DEVICE             pdev;
1339         ULONG                   testsize = 0;
1340         PIDENTIFY_DATA  pid;
1341         USHORT                  minmode;
1342         ULONG                   zl;
1343         UCHAR                   zc;
1344         USHORT                  z;
1345     unsigned long       flags;
1346
1347     /*
1348      * Disable interrupts, if they aren't already disabled and acquire
1349      * the I/O spinlock.
1350      */
1351     spin_lock_irqsave(host->host_lock, flags);
1352
1353         if ( padapter->SCpnt )
1354                 goto reconTimerExpiry;
1355
1356         padapter->reconTimer.data = 0;
1357         for ( z = padapter->devInReconIndex + 1;  z < BIGD_MAXDRIVES;  z++ )
1358                 {
1359                 if ( padapter->device[z].reconOn )
1360                         break;
1361                 }
1362         if ( z < BIGD_MAXDRIVES )
1363                 pdev = &padapter->device[z];
1364         else
1365                 {
1366                 for ( z = 0;  z < BIGD_MAXDRIVES;  z++ )
1367                         {
1368                         if ( padapter->device[z].reconOn )
1369                                 break;
1370                         }
1371                 if ( z < BIGD_MAXDRIVES )
1372                         pdev = &padapter->device[z];
1373                 else
1374                         {
1375                         padapter->reconOn = FALSE;
1376                         goto reconTimerExpiry;
1377                         }
1378                 }
1379
1380         padapter->devInReconIndex = z;
1381         pid = (PIDENTIFY_DATA)padapter->kBuffer;
1382         padapter->pdev = pdev;
1383         if ( pdev->reconIsStarting )
1384                 {
1385                 pdev->reconIsStarting = FALSE;
1386                 pdev->reconOn = FALSE;
1387
1388                 while ( (pdev->DiskMirror[0].signature == SIGNATURE) && (pdev->DiskMirror[1].signature == SIGNATURE) &&
1389                          (pdev->DiskMirror[0].pairIdentifier == (pdev->DiskMirror[1].pairIdentifier ^ 1)) )
1390                         {
1391                         if ( (pdev->DiskMirror[0].status & UCBF_MATCHED) && (pdev->DiskMirror[1].status & UCBF_MATCHED) )
1392                                 break;
1393
1394                         if ( pdev->DiskMirror[0].status & UCBF_SURVIVOR )                               // is first drive survivor?
1395                                 testsize = SetReconstruct (pdev, 0);
1396                         else
1397                                 if ( pdev->DiskMirror[1].status & UCBF_SURVIVOR )                       // is second drive survivor?
1398                                         testsize = SetReconstruct (pdev, 1);
1399
1400                         if ( (pdev->DiskMirror[0].status & UCBF_REBUILD) || (pdev->DiskMirror[1].status & UCBF_REBUILD) )
1401                                 {
1402                                 if ( pdev->DiskMirror[0].status & UCBF_REBUILD )
1403                                         pdev->mirrorRecon = 0;
1404                                 else
1405                                         pdev->mirrorRecon = 1;
1406                                 pdev->reconOn = TRUE;
1407                                 }
1408                         break;
1409                         }
1410
1411                 if ( !pdev->reconOn )
1412                         goto reconTimerExpiry;
1413
1414                 if ( padapter->bigD )
1415                         {
1416                         padapter->failRegister = 0;
1417                         outb_p (~padapter->failRegister, padapter->regFail);
1418                         }
1419                 else
1420                         {
1421                         zc = ((inb_p (padapter->regStatSel) >> 3) | inb_p (padapter->regStatSel)) & 0x83;               // mute the alarm
1422                         outb_p (0xFF, padapter->regFail);
1423                         }
1424
1425                 while ( 1 )
1426                         {
1427                         DEB (printk ("\npci2220i: hard reset issue"));
1428                         if ( HardReset (padapter, pdev, pdev->spigots[pdev->mirrorRecon]) )
1429                                 {
1430                                 DEB (printk ("\npci2220i: sub 1"));
1431                                 break;
1432                                 }
1433
1434                         pdev->lastsectorlba[pdev->mirrorRecon] = InlineIdentify (padapter, pdev->spigots[pdev->mirrorRecon], pdev->deviceID[pdev->mirrorRecon] & 1);
1435
1436                         if ( pdev->lastsectorlba[pdev->mirrorRecon] < testsize )
1437                                 {
1438                                 DEB (printk ("\npci2220i: sub 2 %ld %ld", pdev->lastsectorlba[pdev->mirrorRecon], testsize));
1439                                 break;
1440                                 }
1441
1442                 // test LBA and multiper sector transfer compatibility
1443                         if (!pid->SupportLBA || (pid->NumSectorsPerInt < SECTORSXFER) || !pid->Valid_64_70 )
1444                                 {
1445                                 DEB (printk ("\npci2220i: sub 3"));
1446                                 break;
1447                                 }
1448
1449                 // test PIO/bus matering mode compatibility
1450                         if ( (pid->MinPIOCycleWithoutFlow > 240) && !pid->SupportIORDYDisable && !padapter->timingPIO )
1451                                 {
1452                                 DEB (printk ("\npci2220i: sub 4"));
1453                                 break;
1454                                 }
1455
1456                         if ( pid->MinPIOCycleWithoutFlow <= 120 )       // setup timing mode of drive
1457                                 minmode = 5;
1458                         else
1459                                 {
1460                                 if ( pid->MinPIOCylceWithFlow <= 150 )
1461                                         minmode = 4;
1462                                 else
1463                                         {
1464                                         if ( pid->MinPIOCylceWithFlow <= 180 )
1465                                                 minmode = 3;
1466                                         else
1467                                                 {
1468                                                 if ( pid->MinPIOCylceWithFlow <= 240 )
1469                                                         minmode = 2;
1470                                                 else
1471                                                         {
1472                                                         DEB (printk ("\npci2220i: sub 5"));
1473                                                         break;
1474                                                         }
1475                                                 }
1476                                         }
1477                                 }
1478
1479                         if ( padapter->timingMode > minmode )                                                                   // set minimum timing mode
1480                                 padapter->timingMode = minmode;
1481                         if ( padapter->timingMode >= 2 )
1482                                 padapter->timingAddress = ModeArray[padapter->timingMode - 2];
1483                         else
1484                                 padapter->timingPIO = TRUE;
1485
1486                         padapter->reconOn = TRUE;
1487                         break;
1488                         }
1489
1490                 if ( !pdev->reconOn )
1491                         {
1492                         padapter->survivor = pdev->mirrorRecon ^ 1;
1493                         padapter->reconPhase = RECON_PHASE_FAILOVER;
1494                         DEB (printk ("\npci2220i: FAILURE 7"));
1495                         InitFailover (padapter, pdev);
1496                         goto reconTimerExpiry;
1497                         }
1498
1499                 pdev->raid = TRUE;
1500
1501                 if ( WriteSignature (padapter, pdev, pdev->spigot, pdev->mirrorRecon ^ 1) )
1502                         goto reconTimerExpiry;
1503                 padapter->reconPhase = RECON_PHASE_MARKING;
1504                 goto reconTimerExpiry;
1505                 }
1506
1507         //**********************************
1508         // reconstruct copy starts here
1509         //**********************************
1510         if ( pdev->reconCount++ > 2000 )
1511                 {
1512                 pdev->reconCount = 0;
1513                 if ( WriteSignature (padapter, pdev, pdev->spigots[pdev->mirrorRecon], pdev->mirrorRecon) )
1514                         {
1515                         padapter->survivor = pdev->mirrorRecon ^ 1;
1516                         padapter->reconPhase = RECON_PHASE_FAILOVER;
1517                         DEB (printk ("\npci2220i: FAILURE 8"));
1518                         InitFailover (padapter, pdev);
1519                         goto reconTimerExpiry;
1520                         }
1521                 padapter->reconPhase = RECON_PHASE_UPDATE;
1522                 goto reconTimerExpiry;
1523                 }
1524
1525         zl = pdev->DiskMirror[pdev->mirrorRecon].reconstructPoint;
1526         padapter->reconSize = pdev->DiskMirror[pdev->mirrorRecon ^ 1].reconstructPoint - zl;
1527         if ( padapter->reconSize > MAX_BUS_MASTER_BLOCKS )
1528                 padapter->reconSize = MAX_BUS_MASTER_BLOCKS;
1529
1530         if ( padapter->reconSize )
1531                 {
1532                 SelectSpigot (padapter, pdev->spigots[0] | pdev->spigots[1]);   // select the spigots
1533                 outb_p (pdev->byte6 | ((UCHAR *)(&zl))[3], padapter->regLba24); // select the drive
1534                 SelectSpigot (padapter, pdev->spigot);
1535                 if ( WaitReady (padapter) )
1536                         goto reconTimerExpiry;
1537
1538                 SelectSpigot (padapter, pdev->spigots[pdev->mirrorRecon]);
1539                 if ( WaitReady (padapter) )
1540                         {
1541                         padapter->survivor = pdev->mirrorRecon ^ 1;
1542                         padapter->reconPhase = RECON_PHASE_FAILOVER;
1543                         DEB (printk ("\npci2220i: FAILURE 9"));
1544                         InitFailover (padapter, pdev);
1545                         goto reconTimerExpiry;
1546                         }
1547
1548                 SelectSpigot (padapter, pdev->spigots[0] | pdev->spigots[1]);
1549                 outb_p (padapter->reconSize & 0xFF, padapter->regSectCount);
1550                 outb_p (((UCHAR *)(&zl))[0], padapter->regLba0);
1551                 outb_p (((UCHAR *)(&zl))[1], padapter->regLba8);
1552                 outb_p (((UCHAR *)(&zl))[2], padapter->regLba16);
1553                 padapter->expectingIRQ = TRUE;
1554                 padapter->reconPhase = RECON_PHASE_READY;
1555                 SelectSpigot (padapter, pdev->spigots[pdev->mirrorRecon]);
1556                 WriteCommand (padapter, WRITE_CMD);
1557                 StartTimer (padapter);
1558                 SelectSpigot (padapter, pdev->spigot);
1559                 WriteCommand (padapter, READ_CMD);
1560                 goto reconTimerExpiry;
1561                 }
1562
1563         pdev->DiskMirror[pdev->mirrorRecon].status = UCBF_MIRRORED | UCBF_MATCHED;
1564         pdev->DiskMirror[pdev->mirrorRecon ^ 1].status = UCBF_MIRRORED | UCBF_MATCHED;
1565         if ( WriteSignature (padapter, pdev, pdev->spigot, pdev->mirrorRecon ^ 1) )
1566                 goto reconTimerExpiry;
1567         padapter->reconPhase = RECON_PHASE_LAST;
1568
1569 reconTimerExpiry:;
1570     /*
1571      * Release the I/O spinlock and restore the original flags
1572      * which will enable interrupts if and only if they were
1573      * enabled on entry.
1574      */
1575     spin_unlock_irqrestore(host->host_lock, flags);
1576         }
1577 /****************************************************************
1578  *      Name:   Irq_Handler     :LOCAL
1579  *
1580  *      Description:    Interrupt handler.
1581  *
1582  *      Parameters:             irq             - Hardware IRQ number.
1583  *                                      dev_id  -
1584  *                                      regs    -
1585  *
1586  *      Returns:                TRUE if drive is not ready in time.
1587  *
1588  ****************************************************************/
1589 static irqreturn_t Irq_Handler (int irq, void *dev_id, struct pt_regs *regs)
1590         {
1591         struct Scsi_Host   *shost = NULL;       // Pointer to host data block
1592         PADAPTER2220I           padapter;               // Pointer to adapter control structure
1593         POUR_DEVICE                     pdev;
1594         Scsi_Cmnd                  *SCpnt;
1595         UCHAR                           status;
1596         UCHAR                           status1;
1597         ATAPI_STATUS            statusa;
1598         ATAPI_REASON            reasona;
1599         ATAPI_ERROR                     errora;
1600         int                                     z;
1601         ULONG                           zl;
1602     unsigned long               flags;
1603     int handled = 0;
1604
1605 //      DEB (printk ("\npci2220i received interrupt\n"));
1606
1607         for ( z = 0; z < NumAdapters;  z++ )                                                            // scan for interrupt to process
1608                 {
1609                 if ( PsiHost[z]->irq == (UCHAR)(irq & 0xFF) )
1610                         {
1611                         if ( inw_p (HOSTDATA(PsiHost[z])->regIrqControl) & 0x8000 )
1612                                 {
1613                                 shost = PsiHost[z];
1614                                 break;
1615                                 }
1616                         }
1617                 }
1618
1619         if ( !shost )
1620                 {
1621                 DEB (printk ("\npci2220i: not my interrupt"));
1622                 goto out;
1623                 }
1624
1625         handled = 1;
1626         spin_lock_irqsave(shost->host_lock, flags);
1627         padapter = HOSTDATA(shost);
1628         pdev = padapter->pdev;
1629         SCpnt = padapter->SCpnt;
1630         outb_p (0x08, padapter->regDmaCmdStat);                                                                 // cancel interrupt from DMA engine
1631
1632         if ( padapter->atapi && SCpnt )
1633                 {
1634                 *(char *)&statusa = inb_p (padapter->regStatCmd);                                               // read the device status
1635                 *(char *)&reasona = inb_p (padapter->regSectCount);                                             // read the device interrupt reason
1636
1637                 if ( !statusa.bsy )
1638                         {
1639                         if ( statusa.drq )                                                                                                      // test for transfer phase
1640                                 {
1641                                 if ( !reasona.cod )                                                                                             // test for data phase
1642                                         {
1643                                         z = (ULONG)inb_p (padapter->regLba8) | (ULONG)(inb_p (padapter->regLba16) << 8);
1644                                         if ( padapter->reqSense )
1645                                                 insw (padapter->regData, SCpnt->sense_buffer, z / 2);
1646                                         else
1647                                                 AtapiBusMaster (padapter, reasona.io, z);
1648                                         goto irq_return;
1649                                         }
1650                                 if ( reasona.cod && !reasona.io )                                                               // test for command packet phase
1651                                         {
1652                                         if ( padapter->reqSense )
1653                                                 AtapiRequestSense (padapter, pdev, SCpnt, TRUE);
1654                                         else
1655                                                 AtapiSendCdb (padapter, pdev, padapter->atapiCdb);
1656                                         goto irq_return;
1657                                         }
1658                                 }
1659                         else
1660                                 {
1661                                 if ( reasona.io && statusa.drdy )                                                               // test for status phase
1662                                         {
1663                                         Atapi2Scsi (padapter, SCpnt);
1664                                         if ( statusa.check )
1665                                                 {
1666                                                 *(UCHAR *)&errora = inb_p (padapter->regError);                 // read the device error
1667                                                 if ( errora.senseKey )
1668                                                         {
1669                                                         if ( padapter->reqSense || AtapiRequestSense (padapter, pdev, SCpnt, FALSE) )
1670                                                                 OpDone (padapter, DID_ERROR << 16);
1671                                                         }
1672                                                 else
1673                                                         {
1674                                                         if ( errora.ili || errora.abort )
1675                                                                 OpDone (padapter, DID_ERROR << 16);
1676                                                         else
1677                                                                 OpDone (padapter, DID_OK << 16);
1678                                                         }
1679                                                 }
1680                                         else
1681                                                 if ( padapter->reqSense )
1682                                                         {
1683                                                         DEB (printk ("PCI2242I: Sense codes - %X %X %X ", ((UCHAR *)SCpnt->sense_buffer)[0], ((UCHAR *)SCpnt->sense_buffer)[12], ((UCHAR *)SCpnt->sense_buffer)[13]));
1684                                                         OpDone (padapter, (DRIVER_SENSE << 24) | (DID_OK << 16) | 2);
1685                                                         }
1686                                                 else
1687                                                         OpDone (padapter, DID_OK << 16);
1688                                         }
1689                                 }
1690                         }
1691                 goto irq_return;
1692                 }
1693
1694         if ( !padapter->expectingIRQ || !(SCpnt || padapter->reconPhase) )
1695                 {
1696                 DEB(printk ("\npci2220i Unsolicited interrupt\n"));
1697                 STOP_HERE ();
1698                 goto irq_return;
1699                 }
1700         padapter->expectingIRQ = 0;
1701
1702         if ( padapter->failinprog )
1703                 {
1704                 DEB (printk ("\npci2220i interrupt failover complete"));
1705                 padapter->failinprog = FALSE;
1706                 status = inb_p (padapter->regStatCmd);                                                          // read the device status
1707                 if ( status & (IDE_STATUS_ERROR | IDE_STATUS_WRITE_FAULT) )
1708                         {
1709                         DEB (printk ("\npci2220i: interrupt failover error from drive %X", status));
1710                         padapter->cmd = 0;
1711                         }
1712                 else
1713                         {
1714                         DEB (printk ("\npci2220i: restarting failed opertation."));
1715                         pdev->spigot = (padapter->survivor) ? pdev->spigots[1] : pdev->spigots[0];
1716                         del_timer (&padapter->timer);
1717                         if ( padapter->reconPhase )
1718                                 OpDone (padapter, DID_OK << 16);
1719                         else
1720                                 Pci2220i_QueueCommand (SCpnt, SCpnt->scsi_done);
1721                         goto irq_return;
1722                         }
1723                 }
1724
1725         if ( padapter->reconPhase )
1726                 {
1727                 switch ( padapter->reconPhase )
1728                         {
1729                         case RECON_PHASE_MARKING:
1730                         case RECON_PHASE_LAST:
1731                                 status = inb_p (padapter->regStatCmd);                                          // read the device status
1732                                 del_timer (&padapter->timer);
1733                                 if ( padapter->reconPhase == RECON_PHASE_LAST )
1734                                         {
1735                                         if ( status & (IDE_STATUS_ERROR | IDE_STATUS_WRITE_FAULT) )
1736                                                 {
1737                                                 padapter->survivor = ( pdev->spigot == pdev->spigots[0] ) ? 1 : 0;
1738                                                 DEB (printk ("\npci2220i: FAILURE 10"));
1739                                                 if ( InitFailover (padapter, pdev) )
1740                                                         OpDone (padapter, DecodeError (padapter, status));
1741                                                 goto irq_return;
1742                                                 }
1743                                         if ( WriteSignature (padapter, pdev, pdev->spigots[pdev->mirrorRecon], pdev->mirrorRecon) )
1744                                                 {
1745                                                 padapter->survivor = ( pdev->spigot == pdev->spigots[0] ) ? 0 : 1;
1746                                                 DEB (printk ("\npci2220i: FAILURE 11"));
1747                                                 if ( InitFailover (padapter, pdev) )
1748                                                         OpDone (padapter, DecodeError (padapter, status));
1749                                                 goto irq_return;
1750                                                 }
1751                                         padapter->reconPhase = RECON_PHASE_END;
1752                                         goto irq_return;
1753                                         }
1754                                 OpDone (padapter, DID_OK << 16);
1755                                 goto irq_return;
1756
1757                         case RECON_PHASE_READY:
1758                                 status = inb_p (padapter->regStatCmd);                                          // read the device status
1759                                 if ( status & (IDE_STATUS_ERROR | IDE_STATUS_WRITE_FAULT) )
1760                                         {
1761                                         del_timer (&padapter->timer);
1762                                         OpDone (padapter, DecodeError (padapter, status));
1763                                         goto irq_return;
1764                                         }
1765                                 SelectSpigot (padapter, pdev->spigots[pdev->mirrorRecon]);
1766                                 if ( WaitDrq (padapter) )
1767                                         {
1768                                         del_timer (&padapter->timer);
1769                                         padapter->survivor = ( pdev->spigot == pdev->spigots[0] ) ? 0 : 1;
1770                                         DEB (printk ("\npci2220i: FAILURE 12"));
1771                                         if ( InitFailover (padapter, pdev) )
1772                                                 OpDone (padapter, DecodeError (padapter, status));
1773                                         goto irq_return;
1774                                         }
1775                                 SelectSpigot (padapter, pdev->spigot | SEL_COPY | padapter->bigD);
1776                                 padapter->reconPhase = RECON_PHASE_COPY;
1777                                 padapter->expectingIRQ = TRUE;
1778                                 if ( padapter->timingPIO )
1779                                         {
1780                                         insw (padapter->regData, padapter->kBuffer, padapter->reconSize * (BYTES_PER_SECTOR / 2));
1781                                         }
1782                                 else
1783                                         {
1784                                         if ( (padapter->timingMode > 3) )
1785                                                 {
1786                                                 if ( padapter->bigD )
1787                                                         outl (BIGD_DATA_MODE3, padapter->regDmaAddrLoc);
1788                                                 else
1789                                                         outl (DALE_DATA_MODE3, padapter->regDmaAddrLoc);
1790                                                 }
1791                                         else
1792                                                 outl (padapter->timingAddress, padapter->regDmaAddrLoc);
1793                                         outl (padapter->kBufferDma, padapter->regDmaAddrPci);
1794                                         outl (padapter->reconSize * BYTES_PER_SECTOR, padapter->regDmaCount);
1795                                         outb_p (8, padapter->regDmaDesc);                                               // read operation
1796                                         if ( padapter->bigD )
1797                                                 outb_p (8, padapter->regDmaMode);                                       // no interrupt
1798                                         else
1799                                                 outb_p (1, padapter->regDmaMode);                                       // no interrupt
1800                                         outb_p (0x03, padapter->regDmaCmdStat);                                 // kick the DMA engine in gear
1801                                         }
1802                                 goto irq_return;
1803
1804                         case RECON_PHASE_COPY:
1805                                 pdev->DiskMirror[pdev->mirrorRecon].reconstructPoint += padapter->reconSize;
1806
1807                         case RECON_PHASE_UPDATE:
1808                                 SelectSpigot (padapter, pdev->spigots[pdev->mirrorRecon] | SEL_IRQ_OFF);
1809                                 status = inb_p (padapter->regStatCmd);                                          // read the device status
1810                                 del_timer (&padapter->timer);
1811                                 if ( status & (IDE_STATUS_ERROR | IDE_STATUS_WRITE_FAULT) )
1812                                         {
1813                                         padapter->survivor = ( pdev->spigot == pdev->spigots[0] ) ? 0 : 1;
1814                                         DEB (printk ("\npci2220i: FAILURE 13"));
1815                                         DEB (printk ("\n  status register = %X   error = %X", status, inb_p (padapter->regError)));
1816                                         if ( InitFailover (padapter, pdev) )
1817                                                 OpDone (padapter, DecodeError (padapter, status));
1818                                         goto irq_return;
1819                                         }
1820                                 OpDone (padapter, DID_OK << 16);
1821                                 goto irq_return;
1822
1823                         case RECON_PHASE_END:
1824                                 status = inb_p (padapter->regStatCmd);                                          // read the device status
1825                                 del_timer (&padapter->timer);
1826                                 if ( status & (IDE_STATUS_ERROR | IDE_STATUS_WRITE_FAULT) )
1827                                         {
1828                                         padapter->survivor = ( pdev->spigot == pdev->spigots[0] ) ? 0 : 1;
1829                                         DEB (printk ("\npci2220i: FAILURE 14"));
1830                                         if ( InitFailover (padapter, pdev) )
1831                                                 OpDone (padapter, DecodeError (padapter, status));
1832                                         goto irq_return;
1833                                         }
1834                                 pdev->reconOn = 0;
1835                                 if ( padapter->bigD )
1836                                         {
1837                                         for ( z = 0;  z < padapter->numberOfDrives;  z++ )
1838                                                 {
1839                                                 if ( padapter->device[z].DiskMirror[0].status & UCBF_SURVIVOR )
1840                                                         {
1841                                                         Alarm (padapter, padapter->device[z].deviceID[0] ^ 2);
1842                                                         MuteAlarm (padapter);
1843                                                         }
1844                                                 if ( padapter->device[z].DiskMirror[1].status & UCBF_SURVIVOR )
1845                                                         {
1846                                                         Alarm (padapter, padapter->device[z].deviceID[1] ^ 2);
1847                                                         MuteAlarm (padapter);
1848                                                         }
1849                                                 }
1850                                         }
1851                                 OpDone (padapter, DID_OK << 16);
1852                                 goto irq_return;
1853
1854                         default:
1855                                 goto irq_return;
1856                         }
1857                 }
1858
1859         switch ( padapter->cmd )                                                                                                // decide how to handle the interrupt
1860                 {
1861                 case READ_CMD:
1862                         if ( padapter->sectorCount )
1863                                 {
1864                                 status = inb_p (padapter->regStatCmd);                                          // read the device status
1865                                 if ( status & (IDE_STATUS_ERROR | IDE_STATUS_WRITE_FAULT) )
1866                                         {
1867                                         if ( pdev->raid )
1868                                                 {
1869                                                 padapter->survivor = ( pdev->spigot == pdev->spigots[0] ) ? 1 : 0;
1870                                                 del_timer (&padapter->timer);
1871                                                 DEB (printk ("\npci2220i: FAILURE 15"));
1872                                                 if ( !InitFailover (padapter, pdev) )
1873                                                         goto irq_return;
1874                                                 }
1875                                         break;
1876                                         }
1877                                 if ( padapter->timingPIO )
1878                                         {
1879                                         insw (padapter->regData, padapter->kBuffer, padapter->readCount / 2);
1880                                         padapter->sectorCount -= padapter->readCount / BYTES_PER_SECTOR;
1881                                         WalkScatGath (padapter, TRUE, padapter->readCount);
1882                                         if ( !padapter->sectorCount )
1883                                                 {
1884                                                 status = 0;
1885                                                 break;
1886                                                 }
1887                                         }
1888                                 else
1889                                         {
1890                                         if ( padapter->readCount )
1891                                                 WalkScatGath (padapter, TRUE, padapter->readCount);
1892                                         BusMaster (padapter, 1, 1);
1893                                         }
1894                                 padapter->expectingIRQ = TRUE;
1895                                 goto irq_return;
1896                                 }
1897                         if ( padapter->readCount && !padapter->timingPIO )
1898                                 WalkScatGath (padapter, TRUE, padapter->readCount);
1899                         status = 0;
1900                         break;
1901
1902                 case WRITE_CMD:
1903                         if ( pdev->raid )
1904                                 {
1905                                 SelectSpigot (padapter, pdev->spigots[0] | SEL_IRQ_OFF);
1906                                 status = inb_p (padapter->regStatCmd);                                                          // read the device status
1907                                 SelectSpigot (padapter, pdev->spigots[1] | SEL_IRQ_OFF);
1908                                 status1 = inb_p (padapter->regStatCmd);                                                         // read the device status
1909                                 }
1910                         else
1911                                 SelectSpigot (padapter, pdev->spigot | SEL_IRQ_OFF);
1912                                 status = inb_p (padapter->regStatCmd);                                                          // read the device status
1913                                 status1 = 0;
1914
1915                         if ( status & (IDE_STATUS_ERROR | IDE_STATUS_WRITE_FAULT) )
1916                                 {
1917                                 if ( pdev->raid && !(status1 & (IDE_STATUS_ERROR | IDE_STATUS_WRITE_FAULT)) )
1918                                         {
1919                                         padapter->survivor = 1;
1920                                         del_timer (&padapter->timer);
1921                                         SelectSpigot (padapter, pdev->spigot | SEL_IRQ_OFF);
1922                                         DEB (printk ("\npci2220i: FAILURE 16  status = %X  error = %X", status, inb_p (padapter->regError)));
1923                                         if ( !InitFailover (padapter, pdev) )
1924                                                 goto irq_return;
1925                                         }
1926                                 break;
1927                                 }
1928                         if ( pdev->raid )
1929                                 {
1930                                 if ( status1 & (IDE_STATUS_ERROR | IDE_STATUS_WRITE_FAULT) )
1931                                         {
1932                                         padapter->survivor = 0;
1933                                         del_timer (&padapter->timer);
1934                                         DEB (printk ("\npci2220i: FAILURE 17  status = %X  error = %X", status1, inb_p (padapter->regError)));
1935                                         if ( !InitFailover (padapter, pdev) )
1936                                                 goto irq_return;
1937                                         status = status1;
1938                                         break;
1939                                         }
1940                                 if ( padapter->sectorCount )
1941                                         {
1942                                         status = WriteDataBoth (padapter, pdev);
1943                                         if ( status )
1944                                                 {
1945                                                 padapter->survivor = status >> 1;
1946                                                 del_timer (&padapter->timer);
1947                                                 DEB (printk ("\npci2220i: FAILURE 18"));
1948                                                 if ( !InitFailover (padapter, pdev) )
1949                                                         goto irq_return;
1950                                                 SelectSpigot (padapter, pdev->spigots[status] | SEL_IRQ_OFF);
1951                                                 status = inb_p (padapter->regStatCmd);                                                          // read the device status
1952                                                 break;
1953                                                 }
1954                                         padapter->expectingIRQ = TRUE;
1955                                         goto irq_return;
1956                                         }
1957                                 status = 0;
1958                                 break;
1959                                 }
1960                         if ( padapter->sectorCount )
1961                                 {
1962                                 SelectSpigot (padapter, pdev->spigot | padapter->bigD);
1963                                 status = WriteData (padapter);
1964                                 if ( status )
1965                                         break;
1966                                 padapter->expectingIRQ = TRUE;
1967                                 goto irq_return;
1968                                 }
1969                         status = 0;
1970                         break;
1971
1972                 case IDE_COMMAND_IDENTIFY:
1973                         {
1974                         PINQUIRYDATA    pinquiryData  = SCpnt->request_buffer;
1975                         PIDENTIFY_DATA  pid = (PIDENTIFY_DATA)padapter->kBuffer;
1976
1977                         status = inb_p (padapter->regStatCmd);
1978                         if ( status & IDE_STATUS_DRQ )
1979                                 {
1980                                 insw (padapter->regData, pid, sizeof (IDENTIFY_DATA) >> 1);
1981
1982                                 memset (pinquiryData, 0, SCpnt->request_bufflen);               // Zero INQUIRY data structure.
1983                                 pinquiryData->DeviceType = 0;
1984                                 pinquiryData->Versions = 2;
1985                                 pinquiryData->AdditionalLength = 35 - 4;
1986
1987                                 // Fill in vendor identification fields.
1988                                 for ( z = 0;  z < 20;  z += 2 )
1989                                         {
1990                                         pinquiryData->VendorId[z]         = ((UCHAR *)pid->ModelNumber)[z + 1];
1991                                         pinquiryData->VendorId[z + 1] = ((UCHAR *)pid->ModelNumber)[z];
1992                                         }
1993
1994                                 // Initialize unused portion of product id.
1995                                 for ( z = 0;  z < 4;  z++ )
1996                                         pinquiryData->ProductId[12 + z] = ' ';
1997
1998                                 // Move firmware revision from IDENTIFY data to
1999                                 // product revision in INQUIRY data.
2000                                 for ( z = 0;  z < 4;  z += 2 )
2001                                         {
2002                                         pinquiryData->ProductRevisionLevel[z]    = ((UCHAR *)pid->FirmwareRevision)[z + 1];
2003                                         pinquiryData->ProductRevisionLevel[z + 1] = ((UCHAR *)pid->FirmwareRevision)[z];
2004                                         }
2005                                 if ( pdev == padapter->device )
2006                                         *((USHORT *)(&pinquiryData->VendorSpecific)) = DEVICE_DALE_1;
2007
2008                                 status = 0;
2009                                 }
2010                         break;
2011                         }
2012
2013                 default:
2014                         status = 0;
2015                         break;
2016                 }
2017
2018         del_timer (&padapter->timer);
2019         if ( status )
2020                 {
2021                 DEB (printk ("\npci2220i Interrupt handler return error"));
2022                 zl = DecodeError (padapter, status);
2023                 }
2024         else
2025                 zl = DID_OK << 16;
2026
2027         OpDone (padapter, zl);
2028 irq_return:
2029     spin_unlock_irqrestore(shost->host_lock, flags);
2030 out:
2031         return IRQ_RETVAL(handled);
2032 }
2033
2034 /****************************************************************
2035  *      Name:   Pci2220i_QueueCommand
2036  *
2037  *      Description:    Process a queued command from the SCSI manager.
2038  *
2039  *      Parameters:             SCpnt - Pointer to SCSI command structure.
2040  *                                      done  - Pointer to done function to call.
2041  *
2042  *      Returns:                Status code.
2043  *
2044  ****************************************************************/
2045 int Pci2220i_QueueCommand (Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
2046         {
2047         UCHAR              *cdb = (UCHAR *)SCpnt->cmnd;                                 // Pointer to SCSI CDB
2048         PADAPTER2220I   padapter = HOSTDATA(SCpnt->device->host);                       // Pointer to adapter control structure
2049         POUR_DEVICE             pdev     = &padapter->device[SCpnt->device->id];// Pointer to device information
2050         UCHAR                   rc;                                                                                     // command return code
2051         int                             z;
2052         PDEVICE_RAID1   pdr;
2053
2054         SCpnt->scsi_done = done;
2055         padapter->SCpnt = SCpnt;                                                                        // Save this command data
2056         padapter->readCount = 0;
2057
2058         if ( SCpnt->use_sg )
2059                 {
2060                 padapter->currentSgBuffer = ((struct scatterlist *)SCpnt->request_buffer)[0].address;
2061                 padapter->currentSgCount = ((struct scatterlist *)SCpnt->request_buffer)[0].length;
2062                 }
2063         else
2064                 {
2065                 padapter->currentSgBuffer = SCpnt->request_buffer;
2066                 padapter->currentSgCount = SCpnt->request_bufflen;
2067                 }
2068         padapter->nextSg = 1;
2069
2070         if ( !done )
2071                 {
2072                 printk("pci2220i_queuecommand: %02X: done can't be NULL\n", *cdb);
2073                 return 0;
2074                 }
2075
2076         if ( padapter->atapi )
2077                 {
2078                 UCHAR                   zlo, zhi;
2079
2080                 DEB (printk ("\nPCI2242I: ID %d, LUN %d opcode %X ", SCpnt->device->id, SCpnt->device->lun, *cdb));
2081                 padapter->pdev = pdev;
2082                 if ( !pdev->byte6 || SCpnt->device->lun )
2083                         {
2084                         OpDone (padapter, DID_BAD_TARGET << 16);
2085                         return 0;
2086                         }
2087
2088                 padapter->atapiSpecial = FALSE;
2089                 padapter->reqSense = FALSE;
2090                 memset (padapter->atapiCdb, 0, 16);
2091                 SelectSpigot (padapter, pdev->spigot);                                                                  // select the spigot
2092                 AtapiDevice (padapter, pdev->byte6);                                                                    // select the drive
2093                 if ( AtapiWaitReady (padapter, 100) )
2094                         {
2095                         OpDone (padapter, DID_NO_CONNECT << 16);
2096                         return 0;
2097                         }
2098
2099                 switch ( cdb[0] )
2100                         {
2101                         case SCSIOP_MODE_SENSE:
2102                         case SCSIOP_MODE_SELECT:
2103                                 Scsi2Atapi (padapter, SCpnt);
2104                                 z = SCpnt->request_bufflen + 4;
2105                                 break;
2106                         case SCSIOP_READ6:
2107                         case SCSIOP_WRITE6:
2108                                 Scsi2Atapi (padapter, SCpnt);
2109                                 z = SCpnt->request_bufflen;
2110                                 break;
2111                         default:
2112                                 memcpy (padapter->atapiCdb, cdb, SCpnt->cmd_len);
2113                                 z = SCpnt->request_bufflen;
2114                                 break;
2115                         }
2116                 if ( z > ATAPI_TRANSFER )
2117                         z = ATAPI_TRANSFER;
2118             zlo = (UCHAR)(z & 0xFF);
2119             zhi = (UCHAR)(z >> 8);
2120
2121                 AtapiCountLo (padapter, zlo);
2122                 AtapiCountHi (padapter, zhi);
2123                 outb_p (0, padapter->regError);
2124                 WriteCommand (padapter, IDE_COMMAND_ATAPI_PACKET);
2125                 if ( pdev->cmdDrqInt )
2126                         return 0;
2127
2128                 if ( AtapiWaitDrq (padapter, 500) )
2129                         {
2130                         OpDone (padapter, DID_ERROR << 16);
2131                         return 0;
2132                         }
2133                 AtapiSendCdb (padapter, pdev, padapter->atapiCdb);
2134                 return 0;
2135                 }
2136
2137         if ( padapter->reconPhase )
2138                 return 0;
2139         if ( padapter->reconTimer.data )
2140                 {
2141                 del_timer (&padapter->reconTimer);
2142                 padapter->reconTimer.data = 0;
2143                 }
2144
2145         if ( (SCpnt->device->id >= padapter->numberOfDrives) || SCpnt->device->lun )
2146                 {
2147                 OpDone (padapter, DID_BAD_TARGET << 16);
2148                 return 0;
2149                 }
2150
2151         switch ( *cdb )
2152                 {
2153                 case SCSIOP_INQUIRY:                                    // inquiry CDB
2154                         {
2155                         if ( cdb[2] == SC_MY_RAID )
2156                                 {
2157                                 switch ( cdb[3] )
2158                                         {
2159                                         case MY_SCSI_REBUILD:
2160                                                 for ( z = 0;  z < padapter->numberOfDrives;  z++ )
2161                                                         {
2162                                                         pdev = &padapter->device[z];
2163                                                         if ( ((pdev->DiskMirror[0].status & UCBF_SURVIVOR) && (pdev->DiskMirror[1].status & UCBF_MIRRORED)) ||
2164                                                                  ((pdev->DiskMirror[1].status & UCBF_SURVIVOR) && (pdev->DiskMirror[0].status & UCBF_MIRRORED)) )
2165                                                                 {
2166                                                                 padapter->reconOn = pdev->reconOn = pdev->reconIsStarting = TRUE;
2167                                                                 }
2168                                                         }
2169                                                 OpDone (padapter, DID_OK << 16);
2170                                                 break;
2171                                         case MY_SCSI_ALARMMUTE:
2172                                                 MuteAlarm (padapter);
2173                                                 OpDone (padapter, DID_OK << 16);
2174                                                 break;
2175                                         case MY_SCSI_DEMOFAIL:
2176                                                 padapter->demoFail = TRUE;
2177                                                 OpDone (padapter, DID_OK << 16);
2178                                                 break;
2179                                         default:
2180                                                 z = cdb[5];                             // get index
2181                                                 pdr = (PDEVICE_RAID1)SCpnt->request_buffer;
2182                                                 if ( padapter->raidData[z] )
2183                                                         {
2184                                                         memcpy (&pdr->DiskRaid1, padapter->raidData[z], sizeof (DISK_MIRROR));
2185                                                         if ( padapter->raidData[z]->reconstructPoint > padapter->raidData[z ^ 2]->reconstructPoint )
2186                                                                 pdr->TotalSectors = padapter->raidData[z]->reconstructPoint;
2187                                                         else
2188                                                                 pdr->TotalSectors = padapter->raidData[z ^ 2]->reconstructPoint;
2189                                                         }
2190                                                 else
2191                                                         memset (pdr, 0, sizeof (DEVICE_RAID1));
2192                                                 OpDone (padapter, DID_OK << 16);
2193                                                 break;
2194                                         }
2195                                 return 0;
2196                                 }
2197                         padapter->cmd = IDE_COMMAND_IDENTIFY;
2198                         break;
2199                         }
2200
2201                 case SCSIOP_TEST_UNIT_READY:                    // test unit ready CDB
2202                         OpDone (padapter, DID_OK << 16);
2203                         return 0;
2204                 case SCSIOP_READ_CAPACITY:                              // read capctiy CDB
2205                         {
2206                         PREAD_CAPACITY_DATA     pdata = (PREAD_CAPACITY_DATA)SCpnt->request_buffer;
2207
2208                         pdata->blksiz = 0x20000;
2209                         XANY2SCSI ((UCHAR *)&pdata->blks, pdev->blocks);
2210                         OpDone (padapter, DID_OK << 16);
2211                         return 0;
2212                         }
2213                 case SCSIOP_VERIFY:                                             // verify CDB
2214                         padapter->startSector = XSCSI2LONG (&cdb[2]);
2215                         padapter->sectorCount = (UCHAR)((USHORT)cdb[8] | ((USHORT)cdb[7] << 8));
2216                         padapter->cmd = IDE_COMMAND_VERIFY;
2217                         break;
2218                 case SCSIOP_READ:                                               // read10 CDB
2219                         padapter->startSector = XSCSI2LONG (&cdb[2]);
2220                         padapter->sectorCount = (USHORT)cdb[8] | ((USHORT)cdb[7] << 8);
2221                         padapter->cmd = READ_CMD;
2222                         break;
2223                 case SCSIOP_READ6:                                              // read6  CDB
2224                         padapter->startSector = SCSI2LONG (&cdb[1]);
2225                         padapter->sectorCount = cdb[4];
2226                         padapter->cmd = READ_CMD;
2227                         break;
2228                 case SCSIOP_WRITE:                                              // write10 CDB
2229                         padapter->startSector = XSCSI2LONG (&cdb[2]);
2230                         padapter->sectorCount = (USHORT)cdb[8] | ((USHORT)cdb[7] << 8);
2231                         padapter->cmd = WRITE_CMD;
2232                         break;
2233                 case SCSIOP_WRITE6:                                             // write6  CDB
2234                         padapter->startSector = SCSI2LONG (&cdb[1]);
2235                         padapter->sectorCount = cdb[4];
2236                         padapter->cmd = WRITE_CMD;
2237                         break;
2238                 default:
2239                         DEB (printk ("pci2220i_queuecommand: Unsupported command %02X\n", *cdb));
2240                         OpDone (padapter, DID_ERROR << 16);
2241                         return 0;
2242                 }
2243
2244         if ( padapter->reconPhase )
2245                 return 0;
2246
2247         padapter->pdev = pdev;
2248
2249         while ( padapter->demoFail )
2250                 {
2251                 pdev = padapter->pdev = &padapter->device[0];
2252                 padapter->demoFail = FALSE;
2253                 if ( !pdev->raid ||
2254                          (pdev->DiskMirror[0].status & UCBF_SURVIVOR) ||
2255                          (pdev->DiskMirror[1].status & UCBF_SURVIVOR) )
2256                         {
2257                         break;
2258                         }
2259                 if ( pdev->DiskMirror[0].status & UCBF_REBUILD )
2260                         padapter->survivor = 1;
2261                 else
2262                         padapter->survivor = 0;
2263                                 DEB (printk ("\npci2220i: FAILURE 19"));
2264                 if ( InitFailover (padapter, pdev) )
2265                         break;
2266                 return 0;
2267                 }
2268
2269         StartTimer (padapter);
2270         if ( pdev->raid && (padapter->cmd == WRITE_CMD) )
2271                 {
2272                 rc = IdeCmdBoth (padapter, pdev);
2273                 if ( !rc )
2274                         rc = WriteDataBoth (padapter, pdev);
2275                 if ( rc )
2276                         {
2277                         del_timer (&padapter->timer);
2278                         padapter->expectingIRQ = 0;
2279                         padapter->survivor = rc >> 1;
2280                                 DEB (printk ("\npci2220i: FAILURE 20"));
2281                         if ( InitFailover (padapter, pdev) )
2282                                 {
2283                                 OpDone (padapter, DID_ERROR << 16);
2284                                 return 0;
2285                                 }
2286                         }
2287                 }
2288         else
2289                 {
2290                 rc = IdeCmd (padapter, pdev);
2291                 if ( (padapter->cmd == WRITE_CMD) && !rc )
2292                         rc = WriteData (padapter);
2293                 if ( rc )
2294                         {
2295                         del_timer (&padapter->timer);
2296                         padapter->expectingIRQ = 0;
2297                         if ( pdev->raid )
2298                                 {
2299                                 padapter->survivor = (pdev->spigot ^ 3) >> 1;
2300                                 DEB (printk ("\npci2220i: FAILURE 21"));
2301                                 if ( !InitFailover (padapter, pdev) )
2302                                         return 0;
2303                                 }
2304                         OpDone (padapter, DID_ERROR << 16);
2305                         return 0;
2306                         }
2307                 }
2308         return 0;
2309         }
2310 /****************************************************************
2311  *      Name:                   ReadFlash
2312  *
2313  *      Description:    Read information from controller Flash memory.
2314  *
2315  *      Parameters:             padapter - Pointer to host interface data structure.
2316  *                                      pdata    - Pointer to data structures.
2317  *                                      base     - base address in Flash.
2318  *                                      length   - lenght of data space in bytes.
2319  *
2320  *      Returns:                Nothing.
2321  *
2322  ****************************************************************/
2323 static VOID ReadFlash (PADAPTER2220I padapter, VOID *pdata, ULONG base, ULONG length)
2324         {
2325         ULONG    oldremap;
2326         UCHAR    olddesc;
2327         ULONG    z;
2328         UCHAR   *pd = (UCHAR *)pdata;
2329
2330         oldremap = inl (padapter->regRemap);                                                    // save values to restore later
2331         olddesc  = inb_p (padapter->regDesc);
2332
2333         outl (base | 1, padapter->regRemap);                                                    // remap to Flash space as specified
2334         outb_p (0x40, padapter->regDesc);                                                               // describe remap region as 8 bit
2335         for ( z = 0;  z < length;  z++)                                                                 // get "length" data count
2336                 *pd++ = inb_p (padapter->regBase + z);                                          // read in the data
2337
2338         outl (oldremap, padapter->regRemap);                                                    // restore remap register values
2339         outb_p (olddesc, padapter->regDesc);
2340         }
2341 /****************************************************************
2342  *      Name:                   GetRegs
2343  *
2344  *      Description:    Initialize the regester information.
2345  *
2346  *      Parameters:             pshost            - Pointer to SCSI host data structure.
2347  *                                      bigd              - PCI-2240I identifier
2348  *                                      pcidev            - Pointer to device data structure.
2349  *
2350  *      Returns:                TRUE if failure to install.
2351  *
2352  ****************************************************************/
2353 static USHORT GetRegs (struct Scsi_Host *pshost, BOOL bigd, struct pci_dev *pcidev)
2354         {
2355         PADAPTER2220I   padapter;
2356         int                             setirq;
2357         int                             z;
2358         USHORT                  zr, zl;
2359         UCHAR              *consistent;
2360         dma_addr_t              consistentDma;
2361
2362         padapter = HOSTDATA(pshost);
2363         memset (padapter, 0, sizeof (ADAPTER2220I));
2364         memset (&DaleSetup, 0, sizeof (DaleSetup));
2365         memset (DiskMirror, 0, sizeof (DiskMirror));
2366
2367         zr = pci_resource_start (pcidev, 1);
2368         zl = pci_resource_start (pcidev, 2);
2369
2370         padapter->basePort = zr;
2371         padapter->regRemap              = zr + RTR_LOCAL_REMAP;                                 // 32 bit local space remap
2372         padapter->regDesc               = zr + RTR_REGIONS;                                             // 32 bit local region descriptor
2373         padapter->regRange              = zr + RTR_LOCAL_RANGE;                                 // 32 bit local range
2374         padapter->regIrqControl = zr + RTR_INT_CONTROL_STATUS;                  // 16 bit interrupt control and status
2375         padapter->regScratchPad = zr + RTR_MAILBOX;                                             // 16 byte scratchpad I/O base address
2376
2377         padapter->regBase               = zl;
2378         padapter->regData               = zl + REG_DATA;                                                // data register I/O address
2379         padapter->regError              = zl + REG_ERROR;                                               // error register I/O address
2380         padapter->regSectCount  = zl + REG_SECTOR_COUNT;                                // sector count register I/O address
2381         padapter->regLba0               = zl + REG_LBA_0;                                               // least significant byte of LBA
2382         padapter->regLba8               = zl + REG_LBA_8;                                               // next least significant byte of LBA
2383         padapter->regLba16              = zl + REG_LBA_16;                                              // next most significan byte of LBA
2384         padapter->regLba24              = zl + REG_LBA_24;                                              // head and most 4 significant bits of LBA
2385         padapter->regStatCmd    = zl + REG_STAT_CMD;                                    // status on read and command on write register
2386         padapter->regStatSel    = zl + REG_STAT_SEL;                                    // board status on read and spigot select on write register
2387         padapter->regFail               = zl + REG_FAIL;
2388         padapter->regAltStat    = zl + REG_ALT_STAT;
2389         padapter->pcidev                = pcidev;
2390
2391         if ( bigd )
2392                 {
2393                 padapter->regDmaDesc    = zr + RTR_DMA0_DESC_PTR;                       // address of the DMA discriptor register for direction of transfer
2394                 padapter->regDmaCmdStat = zr + RTR_DMA_COMMAND_STATUS;          // Byte #0 of DMA command status register
2395                 padapter->regDmaAddrPci = zr + RTR_DMA0_PCI_ADDR;                       // 32 bit register for PCI address of DMA
2396                 padapter->regDmaAddrLoc = zr + RTR_DMA0_LOCAL_ADDR;                     // 32 bit register for local bus address of DMA
2397                 padapter->regDmaCount   = zr + RTR_DMA0_COUNT;                          // 32 bit register for DMA transfer count
2398                 padapter->regDmaMode    = zr + RTR_DMA0_MODE + 1;                       // 32 bit register for DMA mode control
2399                 padapter->bigD                  = SEL_NEW_SPEED_1;                                      // set spigot speed control bit
2400                 }
2401         else
2402                 {
2403                 padapter->regDmaDesc    = zl + RTL_DMA1_DESC_PTR;                       // address of the DMA discriptor register for direction of transfer
2404                 padapter->regDmaCmdStat = zl + RTL_DMA_COMMAND_STATUS + 1;      // Byte #1 of DMA command status register
2405                 padapter->regDmaAddrPci = zl + RTL_DMA1_PCI_ADDR;                       // 32 bit register for PCI address of DMA
2406                 padapter->regDmaAddrLoc = zl + RTL_DMA1_LOCAL_ADDR;                     // 32 bit register for local bus address of DMA
2407                 padapter->regDmaCount   = zl + RTL_DMA1_COUNT;                          // 32 bit register for DMA transfer count
2408                 padapter->regDmaMode    = zl + RTL_DMA1_MODE + 1;                       // 32 bit register for DMA mode control
2409                 }
2410
2411         padapter->numberOfDrives = inb_p (padapter->regScratchPad + BIGD_NUM_DRIVES);
2412         if ( !bigd && !padapter->numberOfDrives )                                               // if no devices on this board
2413                 return TRUE;
2414
2415         pshost->irq = pcidev->irq;
2416         setirq = 1;
2417         for ( z = 0;  z < Installed;  z++ )                                                             // scan for shared interrupts
2418                 {
2419                 if ( PsiHost[z]->irq == pshost->irq )                                           // if shared then, don't posses
2420                         setirq = 0;
2421                 }
2422         if ( setirq )                                                                                                   // if not shared, posses
2423                 {
2424                 if ( request_irq (pshost->irq, Irq_Handler, SA_SHIRQ, "pci2220i", padapter) < 0 )
2425                         {
2426                         if ( request_irq (pshost->irq, Irq_Handler, SA_INTERRUPT | SA_SHIRQ, "pci2220i", padapter) < 0 )
2427                                 {
2428                                 printk ("Unable to allocate IRQ for PCI-2220I controller.\n");
2429                                 return TRUE;
2430                                 }
2431                         }
2432                 padapter->irqOwned = pshost->irq;                                                       // set IRQ as owned
2433                 }
2434
2435         if ( padapter->numberOfDrives )
2436                 consistent = pci_alloc_consistent (pcidev, SECTORSXFER * BYTES_PER_SECTOR, &consistentDma);
2437         else
2438                 consistent = pci_alloc_consistent (pcidev, ATAPI_TRANSFER, &consistentDma);
2439         if ( !consistent )
2440                 {
2441                 printk ("Unable to allocate DMA buffer for PCI-2220I controller.\n");
2442                 free_irq (pshost->irq, padapter);
2443                 return TRUE;
2444                 }
2445         padapter->kBuffer = consistent;
2446         padapter->kBufferDma = consistentDma;
2447
2448         PsiHost[Installed]      = pshost;                                                                       // save SCSI_HOST pointer
2449         pshost->io_port         = padapter->basePort;
2450         pshost->n_io_port       = 0xFF;
2451         pshost->unique_id       = padapter->regBase;
2452
2453         outb_p (0x01, padapter->regRange);                                                              // fix our range register because other drivers want to tromp on it
2454
2455         padapter->timingMode = inb_p (padapter->regScratchPad + DALE_TIMING_MODE);
2456         if ( padapter->timingMode >= 2 )
2457                 {
2458                 if ( bigd )
2459                         padapter->timingAddress = ModeArray2[padapter->timingMode - 2];
2460                 else
2461                         padapter->timingAddress = ModeArray[padapter->timingMode - 2];
2462                 }
2463         else
2464                 padapter->timingPIO = TRUE;
2465
2466         ReadFlash (padapter, &DaleSetup, DALE_FLASH_SETUP, sizeof (SETUP));
2467         ReadFlash (padapter, &DiskMirror, DALE_FLASH_RAID, sizeof (DiskMirror));
2468
2469         return FALSE;
2470         }
2471 /****************************************************************
2472  *      Name:                   SetupFinish
2473  *
2474  *      Description:    Complete the driver initialization process for a card
2475  *
2476  *      Parameters:             padapter  - Pointer to SCSI host data structure.
2477  *                                      str               - Pointer to board type string.
2478  *
2479  *      Returns:                Nothing.
2480  *
2481  ****************************************************************/
2482 VOID SetupFinish (PADAPTER2220I padapter, char *str, int irq)
2483         {
2484         init_timer (&padapter->timer);
2485         padapter->timer.function = TimerExpiry;
2486         padapter->timer.data = (unsigned long)padapter;
2487         init_timer (&padapter->reconTimer);
2488         padapter->reconTimer.function = ReconTimerExpiry;
2489         padapter->reconTimer.data = (unsigned long)padapter;
2490         printk("\nPCI-%sI EIDE CONTROLLER: at I/O = %lX/%lX  IRQ = %d\n", str, padapter->basePort, padapter->regBase, irq);
2491         printk("Version %s, Compiled %s %s\n\n", PCI2220I_VERSION, __DATE__, __TIME__);
2492         }
2493 /****************************************************************
2494  *      Name:   Pci2220i_Detect
2495  *
2496  *      Description:    Detect and initialize our boards.
2497  *
2498  *      Parameters:             tpnt - Pointer to SCSI host template structure.
2499  *
2500  *      Returns:                Number of adapters installed.
2501  *
2502  ****************************************************************/
2503 int Pci2220i_Detect (Scsi_Host_Template *tpnt)
2504         {
2505         struct Scsi_Host   *pshost;
2506         PADAPTER2220I       padapter;
2507         POUR_DEVICE                     pdev;
2508         int                                     unit;
2509         int                                     z;
2510         USHORT                          raidon;
2511         UCHAR                           spigot1, spigot2;
2512         UCHAR                           device;
2513         struct pci_dev     *pcidev = NULL;
2514
2515         while ( (pcidev = pci_find_device (VENDOR_PSI, DEVICE_DALE_1, pcidev)) != NULL )
2516                 {
2517                 if (pci_enable_device(pcidev))
2518                         continue;
2519                 pshost = scsi_register (tpnt, sizeof(ADAPTER2220I));
2520                 if(pshost==NULL)
2521                         continue;
2522
2523                 padapter = HOSTDATA(pshost);
2524
2525                 if ( GetRegs (pshost, FALSE, pcidev) )
2526                         goto unregister;
2527
2528                 scsi_set_device(pshost, &pcidev->dev);
2529                 pshost->max_id = padapter->numberOfDrives;
2530                 for ( z = 0;  z < padapter->numberOfDrives;  z++ )
2531                         {
2532                         unit = inb_p (padapter->regScratchPad + DALE_CHANNEL_DEVICE_0 + z) & 0x0F;
2533                         pdev = &padapter->device[z];
2534                         pdev->byte6             = (UCHAR)(((unit & 1) << 4) | 0xE0);
2535                         pdev->spigot    = (UCHAR)(1 << (unit >> 1));
2536                         pdev->sectors   = DaleSetup.setupDevice[unit].sectors;
2537                         pdev->heads             = DaleSetup.setupDevice[unit].heads;
2538                         pdev->cylinders = DaleSetup.setupDevice[unit].cylinders;
2539                         pdev->blocks    = DaleSetup.setupDevice[unit].blocks;
2540
2541                         if ( !z )
2542                                 {
2543                                 DiskMirror[0].status = inb_p (padapter->regScratchPad + DALE_RAID_0_STATUS);
2544                                 DiskMirror[1].status = inb_p (padapter->regScratchPad + DALE_RAID_1_STATUS);
2545                                 if ( (DiskMirror[0].signature == SIGNATURE) && (DiskMirror[1].signature == SIGNATURE) &&
2546                                      (DiskMirror[0].pairIdentifier == (DiskMirror[1].pairIdentifier ^ 1)) )
2547                                         {
2548                                         raidon = TRUE;
2549                                         if ( unit > (unit ^ 2) )
2550                                                 unit = unit ^ 2;
2551                                         }
2552                                 else
2553                                         raidon = FALSE;
2554
2555                                 memcpy (pdev->DiskMirror, DiskMirror, sizeof (DiskMirror));
2556                                 padapter->raidData[0] = &pdev->DiskMirror[0];
2557                                 padapter->raidData[2] = &pdev->DiskMirror[1];
2558
2559                                 spigot1 = spigot2 = FALSE;
2560                                 pdev->spigots[0] = 1;
2561                                 pdev->spigots[1] = 2;
2562                                 pdev->lastsectorlba[0] = InlineIdentify (padapter, 1, 0);
2563                                 pdev->lastsectorlba[1] = InlineIdentify (padapter, 2, 0);
2564
2565                                 if ( !(pdev->DiskMirror[1].status & UCBF_SURVIVOR) && pdev->lastsectorlba[0] )
2566                                         spigot1 = TRUE;
2567                                 if ( !(pdev->DiskMirror[0].status & UCBF_SURVIVOR) && pdev->lastsectorlba[1] )
2568                                         spigot2 = TRUE;
2569                                 if ( pdev->DiskMirror[0].status & DiskMirror[1].status & UCBF_SURVIVOR )
2570                                         spigot1 = TRUE;
2571
2572                                 if ( spigot1 && (pdev->DiskMirror[0].status & UCBF_REBUILD) )
2573                                         InlineReadSignature (padapter, pdev, 0);
2574                                 if ( spigot2 && (pdev->DiskMirror[1].status & UCBF_REBUILD) )
2575                                         InlineReadSignature (padapter, pdev, 1);
2576
2577                                 if ( spigot1 && spigot2 && raidon )
2578                                         {
2579                                         pdev->raid = 1;
2580                                         if ( pdev->DiskMirror[0].status & UCBF_REBUILD )
2581                                                 pdev->spigot = 2;
2582                                         else
2583                                                 pdev->spigot = 1;
2584                                         if ( (pdev->DiskMirror[0].status & UCBF_REBUILD) || (pdev->DiskMirror[1].status & UCBF_REBUILD) )
2585                                                 padapter->reconOn = pdev->reconOn = pdev->reconIsStarting = TRUE;
2586                                         }
2587                                 else
2588                                         {
2589                                         if ( spigot1 )
2590                                                 {
2591                                                 if ( pdev->DiskMirror[0].status & UCBF_REBUILD )
2592                                                         goto unregister;
2593                                                 pdev->DiskMirror[0].status = UCBF_MIRRORED | UCBF_SURVIVOR;
2594                                                 pdev->spigot = 1;
2595                                                 }
2596                                         else
2597                                                 {
2598                                                 if ( pdev->DiskMirror[1].status & UCBF_REBUILD )
2599                                                         goto unregister;
2600                                                 pdev->DiskMirror[1].status = UCBF_MIRRORED | UCBF_SURVIVOR;
2601                                                 pdev->spigot = 2;
2602                                                 }
2603                                         if ( DaleSetup.rebootRebuild && raidon )
2604                                                 padapter->reconOn = pdev->reconOn = pdev->reconIsStarting = TRUE;
2605                                         }
2606
2607                                 if ( raidon )
2608                                         break;
2609                                 }
2610                         }
2611
2612                 SetupFinish (padapter, "2220", pshost->irq);
2613
2614                 if ( ++Installed < MAXADAPTER )
2615                         continue;
2616                 break;
2617 unregister:;
2618                 scsi_unregister (pshost);
2619                 }
2620
2621         while ( (pcidev = pci_find_device (VENDOR_PSI, DEVICE_BIGD_1, pcidev)) != NULL )
2622                 {
2623                 pshost = scsi_register (tpnt, sizeof(ADAPTER2220I));
2624                 padapter = HOSTDATA(pshost);
2625
2626                 if ( GetRegs (pshost, TRUE, pcidev) )
2627                         goto unregister1;
2628
2629                 for ( z = 0;  z < BIGD_MAXDRIVES;  z++ )
2630                         DiskMirror[z].status = inb_p (padapter->regScratchPad + BIGD_RAID_0_STATUS + z);
2631
2632                 scsi_set_pci_device(pshost, pcidev);
2633                 pshost->max_id = padapter->numberOfDrives;
2634                 padapter->failRegister = inb_p (padapter->regScratchPad + BIGD_ALARM_IMAGE);
2635                 for ( z = 0;  z < padapter->numberOfDrives;  z++ )
2636                         {
2637                         unit = inb_p (padapter->regScratchPad + BIGD_DEVICE_0 + z);
2638                         pdev = &padapter->device[z];
2639                         pdev->byte6             = (UCHAR)(((unit & 1) << 4) | 0xE0);
2640                         pdev->spigot    = (UCHAR)(1 << (unit >> 1));
2641                         pdev->sectors   = DaleSetup.setupDevice[unit].sectors;
2642                         pdev->heads             = DaleSetup.setupDevice[unit].heads;
2643                         pdev->cylinders = DaleSetup.setupDevice[unit].cylinders;
2644                         pdev->blocks    = DaleSetup.setupDevice[unit].blocks;
2645
2646                         if ( (DiskMirror[unit].signature == SIGNATURE) && (DiskMirror[unit ^ 2].signature == SIGNATURE) &&
2647                              (DiskMirror[unit].pairIdentifier == (DiskMirror[unit ^ 2].pairIdentifier ^ 1)) )
2648                                 {
2649                                 raidon = TRUE;
2650                                 if ( unit > (unit ^ 2) )
2651                                         unit = unit ^ 2;
2652                                 }
2653                         else
2654                                 raidon = FALSE;
2655
2656                         spigot1 = spigot2 = FALSE;
2657                         memcpy (&pdev->DiskMirror[0], &DiskMirror[unit], sizeof (DISK_MIRROR));
2658                         memcpy (&pdev->DiskMirror[1], &DiskMirror[unit ^ 2], sizeof (DISK_MIRROR));
2659                         padapter->raidData[unit]         = &pdev->DiskMirror[0];
2660                         padapter->raidData[unit ^ 2] = &pdev->DiskMirror[1];
2661                         pdev->spigots[0] = 1 << (unit >> 1);
2662                         pdev->spigots[1] = 1 << ((unit ^ 2) >> 1);
2663                         pdev->deviceID[0] = unit;
2664                         pdev->deviceID[1] = unit ^ 2;
2665                         pdev->lastsectorlba[0] = InlineIdentify (padapter, pdev->spigots[0], unit & 1);
2666                         pdev->lastsectorlba[1] = InlineIdentify (padapter, pdev->spigots[1], unit & 1);
2667
2668                         if ( !(pdev->DiskMirror[1].status & UCBF_SURVIVOR) && pdev->lastsectorlba[0] )
2669                                 spigot1 = TRUE;
2670                         if ( !(pdev->DiskMirror[0].status & UCBF_SURVIVOR) && pdev->lastsectorlba[1] )
2671                                 spigot2 = TRUE;
2672                         if ( pdev->DiskMirror[0].status & pdev->DiskMirror[1].status & UCBF_SURVIVOR )
2673                                 spigot1 = TRUE;
2674
2675                         if ( spigot1 && (pdev->DiskMirror[0].status & UCBF_REBUILD) )
2676                                 InlineReadSignature (padapter, pdev, 0);
2677                         if ( spigot2 && (pdev->DiskMirror[1].status & UCBF_REBUILD) )
2678                                 InlineReadSignature (padapter, pdev, 1);
2679
2680                         if ( spigot1 && spigot2 && raidon )
2681                                 {
2682                                 pdev->raid = 1;
2683                                 if ( pdev->DiskMirror[0].status & UCBF_REBUILD )
2684                                         pdev->spigot = pdev->spigots[1];
2685                                 else
2686                                         pdev->spigot = pdev->spigots[0];
2687                                 if ( (pdev->DiskMirror[0].status & UCBF_REBUILD) || (pdev->DiskMirror[1].status & UCBF_REBUILD) )
2688                                         padapter->reconOn = pdev->reconOn = pdev->reconIsStarting = TRUE;
2689                                 }
2690                         else
2691                                 {
2692                                 if ( spigot1 )
2693                                         {
2694                                         if ( pdev->DiskMirror[0].status & UCBF_REBUILD )
2695                                                 goto unregister1;
2696                                         pdev->DiskMirror[0].status = UCBF_MIRRORED | UCBF_SURVIVOR;
2697                                         pdev->spigot = pdev->spigots[0];
2698                                         }
2699                                 else
2700                                         {
2701                                         if ( pdev->DiskMirror[1].status & UCBF_REBUILD )
2702                                                 goto unregister;
2703                                         pdev->DiskMirror[1].status = UCBF_MIRRORED | UCBF_SURVIVOR;
2704                                         pdev->spigot = pdev->spigots[1];
2705                                         }
2706                                 if ( DaleSetup.rebootRebuild && raidon )
2707                                         padapter->reconOn = pdev->reconOn = pdev->reconIsStarting = TRUE;
2708                                 }
2709                         }
2710
2711                 if ( !padapter->numberOfDrives )                                                                        // If no ATA devices then scan ATAPI
2712                         {
2713                         unit = 0;
2714                         for ( spigot1 = 0;  spigot1 < 4;  spigot1++ )
2715                                 {
2716                                 for ( device = 0;  device < 2;  device++ )
2717                                         {
2718                                         DEB (printk ("\nPCI2242I: scanning for ID %d ", (spigot1 * 2) + device));
2719                                         pdev = &(padapter->device[(spigot1 * 2) + device]);
2720                                         pdev->byte6 = 0x0A | (device << 4);
2721                                         pdev->spigot = 1 << spigot1;
2722                                         if ( !AtapiReset (padapter, pdev) )
2723                                                 {
2724                                                 DEB (printk (" Device found "));
2725                                                 if ( !AtapiIdentify (padapter, pdev) )
2726                                                         {
2727                                                         DEB (printk (" Device verified"));
2728                                                         unit++;
2729                                                         continue;
2730                                                         }
2731                                                 }
2732                                         pdev->spigot = pdev->byte6 = 0;
2733                                         }
2734                                 }
2735
2736                         if ( unit )
2737                                 {
2738                                 padapter->atapi = TRUE;
2739                                 padapter->timingAddress = DALE_DATA_MODE3;
2740                                 outw_p (0x0900, padapter->regIrqControl);                                       // Turn our interrupts on
2741                                 outw_p (0x0C41, padapter->regDmaMode - 1);                                      // setup for 16 bits, ready enabled, done IRQ enabled, no incriment
2742                                 outb_p (0xFF, padapter->regFail);                                                       // all fail lights and alarm off
2743                                 pshost->max_id = 8;
2744                                 }
2745                         }
2746                 SetupFinish (padapter, "2240", pshost->irq);
2747
2748                 if ( ++Installed < MAXADAPTER )
2749                         continue;
2750                 break;
2751 unregister1:;
2752                 scsi_unregister (pshost);
2753                 }
2754
2755         NumAdapters = Installed;
2756         return Installed;
2757         }
2758 /****************************************************************
2759  *      Name:   Pci2220i_Abort
2760  *
2761  *      Description:    Process the Abort command from the SCSI manager.
2762  *
2763  *      Parameters:             SCpnt - Pointer to SCSI command structure.
2764  *
2765  *      Returns:                Allways snooze.
2766  *
2767  ****************************************************************/
2768 int Pci2220i_Abort (Scsi_Cmnd *SCpnt)
2769         {
2770         PADAPTER2220I   padapter = HOSTDATA(SCpnt->device->host);                       // Pointer to adapter control structure
2771         POUR_DEVICE             pdev     = &padapter->device[SCpnt->device->id];// Pointer to device information
2772
2773         if ( !padapter->SCpnt )
2774                 return SCSI_ABORT_NOT_RUNNING;
2775
2776         if ( padapter->atapi )
2777                 {
2778                 if ( AtapiReset (padapter, pdev) )
2779                         return SCSI_ABORT_ERROR;
2780                 OpDone (padapter, DID_ABORT << 16);
2781                 return SCSI_ABORT_SUCCESS;
2782                 }
2783         return SCSI_ABORT_SNOOZE;
2784         }
2785 /****************************************************************
2786  *      Name:   Pci2220i_Reset
2787  *
2788  *      Description:    Process the Reset command from the SCSI manager.
2789  *
2790  *      Parameters:             SCpnt - Pointer to SCSI command structure.
2791  *                                      flags - Flags about the reset command
2792  *
2793  *      Returns:                No active command at this time, so this means
2794  *                                      that each time we got some kind of response the
2795  *                                      last time through.  Tell the mid-level code to
2796  *                                      request sense information in order to decide what
2797  *                                      to do next.
2798  *
2799  ****************************************************************/
2800 int Pci2220i_Reset (Scsi_Cmnd *SCpnt, unsigned int reset_flags)
2801         {
2802         PADAPTER2220I   padapter = HOSTDATA(SCpnt->device->host);                       // Pointer to adapter control structure
2803         POUR_DEVICE             pdev     = &padapter->device[SCpnt->device->id];// Pointer to device information
2804
2805         if ( padapter->atapi )
2806                 {
2807                 if ( AtapiReset (padapter, pdev) )
2808                         return SCSI_RESET_ERROR;
2809                 return SCSI_RESET_SUCCESS;
2810                 }
2811         return SCSI_RESET_PUNT;
2812         }
2813 /****************************************************************
2814  *      Name:   Pci2220i_Release
2815  *
2816  *      Description:    Release resources allocated for a single each adapter.
2817  *
2818  *      Parameters:             pshost - Pointer to SCSI command structure.
2819  *
2820  *      Returns:                zero.
2821  *
2822  ****************************************************************/
2823 int Pci2220i_Release (struct Scsi_Host *pshost)
2824         {
2825     PADAPTER2220I       padapter = HOSTDATA (pshost);
2826         USHORT                  z;
2827
2828         if ( padapter->reconOn )
2829                 {
2830                 padapter->reconOn = FALSE;                                              // shut down the hot reconstruct
2831                 if ( padapter->reconPhase )
2832                         mdelay (300);
2833                 if ( padapter->reconTimer.data )                                // is the timer running?
2834                         {
2835                         del_timer (&padapter->reconTimer);
2836                         padapter->reconTimer.data = 0;
2837                         }
2838                 }
2839
2840         // save RAID status on the board
2841         if ( padapter->bigD )
2842                 {
2843                 outb_p (padapter->failRegister, padapter->regScratchPad + BIGD_ALARM_IMAGE);
2844                 for ( z = 0;  z < BIGD_MAXDRIVES;  z++ )
2845                         {
2846                         if ( padapter->raidData )
2847                                 outb_p (padapter->raidData[z]->status, padapter->regScratchPad + BIGD_RAID_0_STATUS + z);
2848                         else
2849                                 outb_p (0, padapter->regScratchPad + BIGD_RAID_0_STATUS);
2850                         }
2851                 }
2852         else
2853                 {
2854                 outb_p (padapter->device[0].DiskMirror[0].status, padapter->regScratchPad + DALE_RAID_0_STATUS);
2855                 outb_p (padapter->device[0].DiskMirror[1].status, padapter->regScratchPad + DALE_RAID_1_STATUS);
2856                 }
2857
2858         if ( padapter->irqOwned )
2859                 free_irq (pshost->irq, padapter);
2860     release_region (pshost->io_port, pshost->n_io_port);
2861         if ( padapter->numberOfDrives )
2862                 pci_free_consistent (padapter->pcidev, SECTORSXFER * BYTES_PER_SECTOR, padapter->kBuffer, padapter->kBufferDma);
2863         else
2864                 pci_free_consistent (padapter->pcidev, ATAPI_TRANSFER, padapter->kBuffer, padapter->kBufferDma);
2865     scsi_unregister(pshost);
2866     return 0;
2867         }
2868
2869 /****************************************************************
2870  *      Name:   Pci2220i_BiosParam
2871  *
2872  *      Description:    Process the biosparam request from the SCSI manager to
2873  *                                      return C/H/S data.
2874  *
2875  *      Parameters:             disk - Pointer to SCSI disk structure.
2876  *                                      dev      - Major/minor number from kernel.
2877  *                                      geom - Pointer to integer array to place geometry data.
2878  *
2879  *      Returns:                zero.
2880  *
2881  ****************************************************************/
2882 int Pci2220i_BiosParam (struct scsi_device *sdev, struct block_device *dev,
2883                 sector_t capacity, int geom[])
2884         {
2885         POUR_DEVICE     pdev;
2886
2887         if ( !(HOSTDATA(sdev->host))->atapi )
2888                 {
2889                 pdev = &(HOSTDATA(sdev->host)->device[sdev->id]);
2890
2891                 geom[0] = pdev->heads;
2892                 geom[1] = pdev->sectors;
2893                 geom[2] = pdev->cylinders;
2894                 }
2895         return 0;
2896         }
2897
2898 MODULE_LICENSE("Dual BSD/GPL");
2899
2900 static Scsi_Host_Template driver_template = {
2901         .proc_name              = "pci2220i",
2902         .name                   = "PCI-2220I/PCI-2240I",
2903         .detect                 = Pci2220i_Detect,
2904         .release                = Pci2220i_Release,
2905         .queuecommand           = Pci2220i_QueueCommand,
2906         .abort                  = Pci2220i_Abort,
2907         .reset                  = Pci2220i_Reset,
2908         .bios_param             = Pci2220i_BiosParam,
2909         .can_queue              = 1,
2910         .this_id                = -1,
2911         .sg_tablesize           = SG_ALL,
2912         .cmd_per_lun            = 1,
2913         .use_clustering         = DISABLE_CLUSTERING,
2914 };
2915 #include "scsi_module.c"