Automatic merge of 'for-linus' branch from
[linux-2.6] / 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"