Automatic merge of rsync://rsync.kernel.org/pub/scm/linux/kernel/git/torvalds/linux...
[linux-2.6] / drivers / scsi / pci2000.c
1 /****************************************************************************
2  * Perceptive Solutions, Inc. PCI-2000 device driver for Linux.
3  *
4  * pci2000.c - Linux Host Driver for PCI-2000 IntelliCache SCSI 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    Jan-21-1999
22  *              - Fixed sign on message to reflect proper controller name.
23  *              - Added support for RAID status monitoring and control.
24  *
25  *  Revisions   1.11    Mar-22-1999
26  *              - Fixed control timeout to not lock up the entire system if
27  *                controller goes offline completely.
28  *
29  *      Revisions 1.12          Mar-26-1999
30  *              - Fixed spinlock and PCI configuration.
31  *
32  *      Revisions 1.20          Mar-27-2000
33  *              - Added support for dynamic DMA
34  *
35  ****************************************************************************/
36 #define PCI2000_VERSION         "1.20"
37
38 #include <linux/blkdev.h>
39 #include <linux/interrupt.h>
40 #include <linux/module.h>
41 #include <linux/kernel.h>
42 #include <linux/types.h>
43 #include <linux/string.h>
44 #include <linux/pci.h>
45 #include <linux/ioport.h>
46 #include <linux/delay.h>
47 #include <linux/sched.h>
48 #include <linux/proc_fs.h>
49 #include <linux/stat.h>
50 #include <linux/spinlock.h>
51
52 #include <asm/dma.h>
53 #include <asm/system.h>
54 #include <asm/io.h>
55
56 #include "scsi.h"
57 #include <scsi/scsi_host.h>
58 #include "pci2000.h"
59 #include "psi_roy.h"
60
61
62 //#define DEBUG 1
63
64 #ifdef DEBUG
65 #define DEB(x) x
66 #define STOP_HERE       {int st;for(st=0;st<100;st++){st=1;}}
67 #else
68 #define DEB(x)
69 #define STOP_HERE
70 #endif
71
72 typedef struct
73         {
74         unsigned int    address;
75         unsigned int    length;
76         }       SCATGATH, *PSCATGATH;
77
78 typedef struct
79         {
80         Scsi_Cmnd               *SCpnt;
81         PSCATGATH                scatGath;
82         dma_addr_t               scatGathDma;
83         UCHAR                   *cdb;
84         dma_addr_t               cdbDma; 
85         UCHAR                    tag;
86         }       DEV2000, *PDEV2000;
87
88 typedef struct
89         {
90         ULONG                    basePort;
91         ULONG                    mb0;
92         ULONG                    mb1;
93         ULONG                    mb2;
94         ULONG                    mb3;
95         ULONG                    mb4;
96         ULONG                    cmd;
97         ULONG                    tag;
98         ULONG                    irqOwned;
99         struct pci_dev  *pdev;
100         DEV2000                  dev[MAX_BUS][MAX_UNITS];
101         }       ADAPTER2000, *PADAPTER2000;
102
103 #define HOSTDATA(host) ((PADAPTER2000)&host->hostdata)
104 #define consistentLen (MAX_BUS * MAX_UNITS * (16 * sizeof (SCATGATH) + MAX_COMMAND_SIZE))
105
106
107 static struct   Scsi_Host          *PsiHost[MAXADAPTER] = {NULL,};  // One for each adapter
108 static                  int                             NumAdapters = 0;
109 /****************************************************************
110  *      Name:                   WaitReady       :LOCAL
111  *
112  *      Description:    Wait for controller ready.
113  *
114  *      Parameters:             padapter - Pointer adapter data structure.
115  *
116  *      Returns:                TRUE on not ready.
117  *
118  ****************************************************************/
119 static int WaitReady (PADAPTER2000 padapter)
120         {
121         ULONG   z;
122
123         for ( z = 0;  z < (TIMEOUT_COMMAND * 4);  z++ )
124                 {
125                 if ( !inb_p (padapter->cmd) )
126                         return FALSE;
127                 udelay (250);
128                 };                                                              
129         return TRUE;
130         }
131 /****************************************************************
132  *      Name:                   WaitReadyLong   :LOCAL
133  *
134  *      Description:    Wait for controller ready.
135  *
136  *      Parameters:             padapter - Pointer adapter data structure.
137  *
138  *      Returns:                TRUE on not ready.
139  *
140  ****************************************************************/
141 static int WaitReadyLong (PADAPTER2000 padapter)
142         {
143         ULONG   z;
144
145         for ( z = 0;  z < (5000 * 4);  z++ )
146                 {
147                 if ( !inb_p (padapter->cmd) )
148                         return FALSE;
149                 udelay (250);
150                 };                                                              
151         return TRUE;
152         }
153 /****************************************************************
154  *      Name:   OpDone  :LOCAL
155  *
156  *      Description:    Clean up operation and issue done to caller.
157  *
158  *      Parameters:             SCpnt   - Pointer to SCSI command structure.
159  *                                      status  - Caller status.
160  *
161  *      Returns:                Nothing.
162  *
163  ****************************************************************/
164 static void OpDone (Scsi_Cmnd *SCpnt, ULONG status)
165         {
166         SCpnt->result = status;
167         SCpnt->scsi_done (SCpnt);
168         }
169 /****************************************************************
170  *      Name:   Command         :LOCAL
171  *
172  *      Description:    Issue queued command to the PCI-2000.
173  *
174  *      Parameters:             padapter - Pointer to adapter information structure.
175  *                                      cmd              - PCI-2000 command byte.
176  *
177  *      Returns:                Non-zero command tag if operation is accepted.
178  *
179  ****************************************************************/
180 static UCHAR Command (PADAPTER2000 padapter, UCHAR cmd)
181         {
182         outb_p (cmd, padapter->cmd);
183         if ( WaitReady (padapter) )
184                 return 0;
185
186         if ( inw_p (padapter->mb0) )
187                 return 0;
188
189         return inb_p (padapter->mb1);
190         }
191 /****************************************************************
192  *      Name:   BuildSgList             :LOCAL
193  *
194  *      Description:    Build the scatter gather list for controller.
195  *
196  *      Parameters:             SCpnt    - Pointer to SCSI command structure.
197  *                                      padapter - Pointer to adapter information structure.
198  *                                      pdev     - Pointer to adapter device structure.
199  *
200  *      Returns:                Non-zero in not scatter gather.
201  *
202  ****************************************************************/
203 static int BuildSgList (Scsi_Cmnd *SCpnt, PADAPTER2000 padapter, PDEV2000 pdev)
204         {
205         int                                      z;
206         int                                      zc;
207         struct scatterlist      *sg;
208
209         if ( SCpnt->use_sg )
210                 {
211                 sg = (struct scatterlist *)SCpnt->request_buffer;
212                 zc = pci_map_sg (padapter->pdev, sg, SCpnt->use_sg, SCpnt->sc_data_direction);
213                 for ( z = 0;  z < zc;  z++ )
214                         {
215                         pdev->scatGath[z].address = cpu_to_le32 (sg_dma_address (sg));
216                         pdev->scatGath[z].length = cpu_to_le32 (sg_dma_len (sg++));
217                         }
218                 outl (pdev->scatGathDma, padapter->mb2);
219                 outl ((zc << 24) | SCpnt->request_bufflen, padapter->mb3);
220                 return FALSE;
221                 }
222         if ( !SCpnt->request_bufflen)
223                 {
224                 outl (0, padapter->mb2);
225                 outl (0, padapter->mb3);
226                 return TRUE;
227                 }
228         SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev,
229                         SCpnt->request_buffer, SCpnt->request_bufflen,
230                         SCpnt->sc_data_direction);
231         outl (SCpnt->SCp.have_data_in, padapter->mb2);
232         outl (SCpnt->request_bufflen, padapter->mb3);
233         return TRUE;
234         }
235 /*********************************************************************
236  *      Name:   PsiRaidCmd
237  *
238  *      Description:    Execute a simple command.
239  *
240  *      Parameters:             padapter - Pointer to adapter control structure.
241  *                                      cmd              - Roy command byte.
242  *
243  *      Returns:                Return error status.
244  *
245  ********************************************************************/
246 static int PsiRaidCmd (PADAPTER2000 padapter, char cmd)
247         {
248         if ( WaitReady (padapter) )                                             // test for command register ready
249                 return DID_TIME_OUT;
250         outb_p (cmd, padapter->cmd);                                    // issue command
251         if ( WaitReadyLong (padapter) )                                 // wait for adapter ready
252                 return DID_TIME_OUT;
253         return DID_OK;
254         }
255 /****************************************************************
256  *      Name:   Irq_Handler     :LOCAL
257  *
258  *      Description:    Interrupt handler.
259  *
260  *      Parameters:             irq             - Hardware IRQ number.
261  *                                      dev_id  -
262  *                                      regs    -
263  *
264  *      Returns:                TRUE if drive is not ready in time.
265  *
266  ****************************************************************/
267 static irqreturn_t Irq_Handler (int irq, void *dev_id, struct pt_regs *regs)
268         {
269         struct Scsi_Host   *shost = NULL;       // Pointer to host data block
270         PADAPTER2000            padapter;               // Pointer to adapter control structure
271         PDEV2000                        pdev;
272         Scsi_Cmnd                  *SCpnt;
273         UCHAR                           tag = 0;
274         UCHAR                           tag0;
275         ULONG                           error;
276         int                                     pun;
277         int                                     bus;
278         int                                     z;
279     unsigned long               flags;
280     int handled = 0;
281
282         DEB(printk ("\npci2000 received interrupt "));
283         for ( z = 0; z < NumAdapters;  z++ )                                                                            // scan for interrupt to process
284                 {
285                 if ( PsiHost[z]->irq == (UCHAR)(irq & 0xFF) )
286                         {
287                         tag = inb_p (HOSTDATA(PsiHost[z])->tag);
288                         if (  tag )
289                                 {
290                                 shost = PsiHost[z];
291                                 break;
292                                 }
293                         }
294                 }
295
296         if ( !shost )
297                 {
298                 DEB (printk ("\npci2000: not my interrupt"));
299                 goto out;
300                 }
301
302     handled = 1;
303         spin_lock_irqsave(shost->host_lock, flags);
304         padapter = HOSTDATA(shost);
305
306         tag0 = tag & 0x7F;                                                                                                                      // mask off the error bit
307         for ( bus = 0;  bus < MAX_BUS;  bus++ )                                                                         // scan the busses
308         {
309                 for ( pun = 0;  pun < MAX_UNITS;  pun++ )                                                               // scan the targets
310                 {
311                         pdev = &padapter->dev[bus][pun];
312                         if ( !pdev->tag )
313                         continue;
314                         if ( pdev->tag == tag0 )                                                                                        // is this it?
315                                 {
316                                 pdev->tag = 0;
317                                 SCpnt = pdev->SCpnt;
318                                 goto unmapProceed;
319                         }
320                         }
321         }
322
323         outb_p (0xFF, padapter->tag);                                                                                           // clear the op interrupt
324         outb_p (CMD_DONE, padapter->cmd);                                                                                       // complete the op
325         goto irq_return;                                                                                                                        // done, but, with what?
326
327 unmapProceed:;
328         if ( !bus )
329                 {
330                 switch ( SCpnt->cmnd[0] )
331                         {
332                         case SCSIOP_TEST_UNIT_READY:
333                                 pci_unmap_single (padapter->pdev, SCpnt->SCp.have_data_in, sizeof (SCpnt->sense_buffer), PCI_DMA_FROMDEVICE);
334                                 goto irqProceed;
335                         case SCSIOP_READ_CAPACITY:
336                                 pci_unmap_single (padapter->pdev, SCpnt->SCp.have_data_in, 8, PCI_DMA_FROMDEVICE);
337                                 goto irqProceed;
338                         case SCSIOP_VERIFY:
339                         case SCSIOP_START_STOP_UNIT:
340                         case SCSIOP_MEDIUM_REMOVAL:
341                                 goto irqProceed;
342                         }
343                 }
344         if ( SCpnt->SCp.have_data_in )
345                 pci_unmap_single (padapter->pdev, SCpnt->SCp.have_data_in, SCpnt->request_bufflen, SCpnt->sc_data_direction);
346         else 
347                 {
348                 if ( SCpnt->use_sg )
349                         pci_unmap_sg (padapter->pdev, (struct scatterlist *)SCpnt->request_buffer, SCpnt->use_sg, SCpnt->sc_data_direction);
350                 }
351
352 irqProceed:;
353         if ( tag & ERR08_TAGGED )                                                                                               // is there an error here?
354                 {
355                 if ( WaitReady (padapter) )
356                         {
357                         OpDone (SCpnt, DID_TIME_OUT << 16);
358                         goto irq_return;
359                         }
360
361                 outb_p (tag0, padapter->mb0);                                                                           // get real error code
362                 outb_p (CMD_ERROR, padapter->cmd);
363                 if ( WaitReady (padapter) )                                                                                     // wait for controller to suck up the op
364                         {
365                         OpDone (SCpnt, DID_TIME_OUT << 16);
366                         goto irq_return;
367                         }
368
369                 error = inl (padapter->mb0);                                                                            // get error data
370                 outb_p (0xFF, padapter->tag);                                                                           // clear the op interrupt
371                 outb_p (CMD_DONE, padapter->cmd);                                                                       // complete the op
372
373                 DEB (printk ("status: %lX ", error));
374                 if ( error == 0x00020002 )                                                                                      // is this error a check condition?
375                         {
376                         if ( bus )                                                                                                              // are we doint SCSI commands?
377                                 {
378                                 OpDone (SCpnt, (DID_OK << 16) | 2);
379                                 goto irq_return;
380                                 }
381                         if ( *SCpnt->cmnd == SCSIOP_TEST_UNIT_READY )
382                                 OpDone (SCpnt, (DRIVER_SENSE << 24) | (DID_OK << 16) | 2);      // test caller we have sense data too
383                         else
384                                 OpDone (SCpnt, DID_ERROR << 16);
385                         goto irq_return;
386                         }
387                 OpDone (SCpnt, DID_ERROR << 16);
388                 goto irq_return;
389                 }
390
391         outb_p (0xFF, padapter->tag);                                                                                   // clear the op interrupt
392         outb_p (CMD_DONE, padapter->cmd);                                                                               // complete the op
393         OpDone (SCpnt, DID_OK << 16);
394
395 irq_return:
396     spin_unlock_irqrestore(shost->host_lock, flags);
397 out:
398     return IRQ_RETVAL(handled);
399 }
400 /****************************************************************
401  *      Name:   Pci2000_QueueCommand
402  *
403  *      Description:    Process a queued command from the SCSI manager.
404  *
405  *      Parameters:             SCpnt - Pointer to SCSI command structure.
406  *                                      done  - Pointer to done function to call.
407  *
408  *      Returns:                Status code.
409  *
410  ****************************************************************/
411 int Pci2000_QueueCommand (Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
412         {
413         UCHAR              *cdb = (UCHAR *)SCpnt->cmnd;                                 // Pointer to SCSI CDB
414         PADAPTER2000    padapter = HOSTDATA(SCpnt->device->host);                       // Pointer to adapter control structure
415         int                             rc               = -1;                                                          // command return code
416         UCHAR                   bus              = SCpnt->device->channel;
417         UCHAR                   pun              = SCpnt->device->id;
418         UCHAR                   lun              = SCpnt->device->lun;
419         UCHAR                   cmd;
420         PDEV2000                pdev     = &padapter->dev[bus][pun];
421
422         if ( !done )
423                 {
424                 printk("pci2000_queuecommand: %02X: done can't be NULL\n", *cdb);
425                 return 0;
426                 }
427
428         SCpnt->scsi_done = done;
429         SCpnt->SCp.have_data_in = 0;
430         pdev->SCpnt = SCpnt;                                                                    // Save this command data
431
432         if ( WaitReady (padapter) )
433                 {
434                 rc = DID_ERROR;
435                 goto finished;
436                 }
437
438         outw_p (pun | (lun << 8), padapter->mb0);
439
440         if ( bus )
441                 {
442                 DEB (if(*cdb) printk ("\nCDB: %X-  %X %X %X %X %X %X %X %X %X %X ", SCpnt->cmd_len, cdb[0], cdb[1], cdb[2], cdb[3], cdb[4], cdb[5], cdb[6], cdb[7], cdb[8], cdb[9]));
443                 DEB (if(*cdb) printk ("\ntimeout_per_command: %d, timeout_total: %d, timeout: %d", SCpnt->timeout_per_command,
444                                                           SCpnt->timeout_total, SCpnt->timeout));
445                 outl (SCpnt->timeout_per_command, padapter->mb1);
446                 outb_p (CMD_SCSI_TIMEOUT, padapter->cmd);
447                 if ( WaitReady (padapter) )
448                         {
449                         rc = DID_ERROR;
450                         goto finished;
451                         }
452
453                 outw_p (pun | (lun << 8), padapter->mb0);
454                 outw_p (SCpnt->cmd_len << 8, padapter->mb0 + 2);
455                 memcpy (pdev->cdb, cdb, MAX_COMMAND_SIZE);
456
457                 outl (pdev->cdbDma, padapter->mb1);
458                 if ( BuildSgList (SCpnt, padapter, pdev) )
459                         cmd = CMD_SCSI_THRU;
460                 else
461                         cmd = CMD_SCSI_THRU_SG;
462                 if ( (pdev->tag = Command (padapter, cmd)) == 0 )
463                         rc = DID_TIME_OUT;
464                 goto finished;
465                 }
466         else
467                 {
468                 if ( lun )
469                         {
470                         rc = DID_BAD_TARGET;
471                         goto finished;
472                         }
473                 }
474
475         switch ( *cdb )
476                 {
477                 case SCSIOP_INQUIRY:                                    // inquiry CDB
478                         if ( cdb[2] == SC_MY_RAID )
479                                 {
480                                 switch ( cdb[3] ) 
481                                         {
482                                         case MY_SCSI_REBUILD:
483                                                 OpDone (SCpnt, PsiRaidCmd (padapter, CMD_RAID_REBUILD) << 16);
484                                                 return 0;
485                                         case MY_SCSI_ALARMMUTE:
486                                                 OpDone (SCpnt, PsiRaidCmd (padapter, CMD_RAID_MUTE) << 16);
487                                                 return 0;
488                                         case MY_SCSI_DEMOFAIL:
489                                                 OpDone (SCpnt, PsiRaidCmd (padapter, CMD_RAID_FAIL) << 16);
490                                                 return 0;
491                                         default:
492                                                 if ( SCpnt->use_sg )
493                                                         {
494                                                         rc = DID_ERROR;
495                                                         goto finished;
496                                                         }
497                                                 else
498                                                         {
499                                                         SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, SCpnt->request_buffer, SCpnt->request_bufflen,
500                                                                                                           SCpnt->sc_data_direction);
501                                                         outl (SCpnt->SCp.have_data_in, padapter->mb2);
502                                                         }
503                                                 outl (cdb[5], padapter->mb0);
504                                                 outl (cdb[3], padapter->mb3);
505                                                 cmd = CMD_DASD_RAID_RQ;
506                                                 break;
507                                         }
508                                 break;
509                                 }
510                         
511                         if ( SCpnt->use_sg )
512                                 {
513                                 SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev,
514                                                                           ((struct scatterlist *)SCpnt->request_buffer)->address,
515                                                                           SCpnt->request_bufflen,
516                                                                           SCpnt->sc_data_direction);
517                                 }
518                         else
519                                 {
520                                 SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, SCpnt->request_buffer,
521                                                                           SCpnt->request_bufflen,
522                                                                           SCpnt->sc_data_direction);
523                                 }
524                         outl (SCpnt->SCp.have_data_in, padapter->mb2);
525                         outl (SCpnt->request_bufflen, padapter->mb3);
526                         cmd = CMD_DASD_SCSI_INQ;
527                         break;
528
529                 case SCSIOP_TEST_UNIT_READY:                    // test unit ready CDB
530                         SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, SCpnt->sense_buffer, sizeof (SCpnt->sense_buffer), PCI_DMA_FROMDEVICE);
531                         outl (SCpnt->SCp.have_data_in, padapter->mb2);
532                         outl (sizeof (SCpnt->sense_buffer), padapter->mb3);
533                         cmd = CMD_TEST_READY;
534                         break;
535
536                 case SCSIOP_READ_CAPACITY:                              // read capacity CDB
537                         if ( SCpnt->use_sg )
538                                 {
539                                 SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, ((struct scatterlist *)(SCpnt->request_buffer))->address,
540                                                                                   8, PCI_DMA_FROMDEVICE);
541                                 }
542                         else
543                                 SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, SCpnt->request_buffer, 8, PCI_DMA_FROMDEVICE);
544                         outl (SCpnt->SCp.have_data_in, padapter->mb2);
545                         outl (8, padapter->mb3);
546                         cmd = CMD_DASD_CAP;
547                         break;
548                 case SCSIOP_VERIFY:                                             // verify CDB
549                         outw_p ((USHORT)cdb[8] | ((USHORT)cdb[7] << 8), padapter->mb0 + 2);
550                         outl (XSCSI2LONG (&cdb[2]), padapter->mb1);
551                         cmd = CMD_READ_SG;
552                         break;
553                 case SCSIOP_READ:                                               // read10 CDB
554                         outw_p ((USHORT)cdb[8] | ((USHORT)cdb[7] << 8), padapter->mb0 + 2);
555                         outl (XSCSI2LONG (&cdb[2]), padapter->mb1);
556                         if ( BuildSgList (SCpnt, padapter, pdev) )
557                                 cmd = CMD_READ;
558                         else
559                                 cmd = CMD_READ_SG;
560                         break;
561                 case SCSIOP_READ6:                                              // read6  CDB
562                         outw_p (cdb[4], padapter->mb0 + 2);
563                         outl ((SCSI2LONG (&cdb[1])) & 0x001FFFFF, padapter->mb1);
564                         if ( BuildSgList (SCpnt, padapter, pdev) )
565                                 cmd = CMD_READ;
566                         else
567                                 cmd = CMD_READ_SG;
568                         break;
569                 case SCSIOP_WRITE:                                              // write10 CDB
570                         outw_p ((USHORT)cdb[8] | ((USHORT)cdb[7] << 8), padapter->mb0 + 2);
571                         outl (XSCSI2LONG (&cdb[2]), padapter->mb1);
572                         if ( BuildSgList (SCpnt, padapter, pdev) )
573                                 cmd = CMD_WRITE;
574                         else
575                                 cmd = CMD_WRITE_SG;
576                         break;
577                 case SCSIOP_WRITE6:                                             // write6  CDB
578                         outw_p (cdb[4], padapter->mb0 + 2);
579                         outl ((SCSI2LONG (&cdb[1])) & 0x001FFFFF, padapter->mb1);
580                         if ( BuildSgList (SCpnt, padapter, pdev) )
581                                 cmd = CMD_WRITE;
582                         else
583                                 cmd = CMD_WRITE_SG;
584                         break;
585                 case SCSIOP_START_STOP_UNIT:
586                         cmd = CMD_EJECT_MEDIA;
587                         break;
588                 case SCSIOP_MEDIUM_REMOVAL:
589                         switch ( cdb[4] )
590                                 {
591                                 case 0:
592                                         cmd = CMD_UNLOCK_DOOR;
593                                         break;
594                                 case 1:
595                                         cmd = CMD_LOCK_DOOR;
596                                         break;
597                                 default:
598                                         cmd = 0;
599                                         break;
600                                 }
601                         if ( cmd )
602                                 break;
603                 default:
604                         DEB (printk ("pci2000_queuecommand: Unsupported command %02X\n", *cdb));
605                         OpDone (SCpnt, DID_ERROR << 16);
606                         return 0;
607                 }
608
609         if ( (pdev->tag = Command (padapter, cmd)) == 0 )
610                 rc = DID_TIME_OUT;
611 finished:;
612         if ( rc != -1 )
613                 OpDone (SCpnt, rc << 16);
614         return 0;
615         }
616 /****************************************************************
617  *      Name:   Pci2000_Detect
618  *
619  *      Description:    Detect and initialize our boards.
620  *
621  *      Parameters:             tpnt - Pointer to SCSI host template structure.
622  *
623  *      Returns:                Number of adapters installed.
624  *
625  ****************************************************************/
626 int Pci2000_Detect (Scsi_Host_Template *tpnt)
627         {
628         int                                     found = 0;
629         int                                     installed = 0;
630         struct Scsi_Host   *pshost;
631         PADAPTER2000        padapter;
632         int                                     z, zz;
633         int                                     setirq;
634         struct pci_dev     *pdev = NULL;
635         UCHAR                      *consistent;
636         dma_addr_t                      consistentDma;
637
638         while ( (pdev = pci_find_device (VENDOR_PSI, DEVICE_ROY_1, pdev)) != NULL )
639                 {
640                 if (pci_enable_device(pdev))
641                         continue;
642                 pshost = scsi_register (tpnt, sizeof(ADAPTER2000));
643                 if(pshost == NULL)
644                         continue;
645                 padapter = HOSTDATA(pshost);
646
647                 padapter->basePort = pci_resource_start (pdev, 1);
648                 DEB (printk ("\nBase Regs = %#04X", padapter->basePort));                       // get the base I/O port address
649                 padapter->mb0   = padapter->basePort + RTR_MAILBOX;                                     // get the 32 bit mail boxes
650                 padapter->mb1   = padapter->basePort + RTR_MAILBOX + 4;
651                 padapter->mb2   = padapter->basePort + RTR_MAILBOX + 8;
652                 padapter->mb3   = padapter->basePort + RTR_MAILBOX + 12;
653                 padapter->mb4   = padapter->basePort + RTR_MAILBOX + 16;
654                 padapter->cmd   = padapter->basePort + RTR_LOCAL_DOORBELL;                      // command register
655                 padapter->tag   = padapter->basePort + RTR_PCI_DOORBELL;                        // tag/response register
656                 padapter->pdev = pdev;
657
658                 if ( WaitReady (padapter) )
659                         goto unregister;
660                 outb_p (0x84, padapter->mb0);
661                 outb_p (CMD_SPECIFY, padapter->cmd);
662                 if ( WaitReady (padapter) )
663                         goto unregister;
664
665                 consistent = pci_alloc_consistent (pdev, consistentLen, &consistentDma);
666                 if ( !consistent )
667                         {
668                         printk ("Unable to allocate DMA memory for PCI-2000 controller.\n");
669                         goto unregister;
670                         }
671                 
672                 scsi_set_device(pshost, &pdev->dev);
673                 pshost->irq = pdev->irq;
674                 setirq = 1;
675                 padapter->irqOwned = 0;
676                 for ( z = 0;  z < installed;  z++ )                                                                     // scan for shared interrupts
677                         {
678                         if ( PsiHost[z]->irq == pshost->irq )                                                   // if shared then, don't posses
679                                 setirq = 0;
680                         }
681                 if ( setirq )                                                                                           // if not shared, posses
682                         {
683                         if ( request_irq (pshost->irq, Irq_Handler, SA_SHIRQ, "pci2000", padapter) < 0 )
684                                 {
685                                 if ( request_irq (pshost->irq, Irq_Handler, SA_INTERRUPT | SA_SHIRQ, "pci2000", padapter) < 0 )
686                                         {
687                                         printk ("Unable to allocate IRQ for PCI-2000 controller.\n");
688                                         pci_free_consistent (pdev, consistentLen, consistent, consistentDma);
689                                         goto unregister;
690                                         }
691                                 }
692                         padapter->irqOwned = pshost->irq;                                               // set IRQ as owned
693                         }
694                 PsiHost[installed]      = pshost;                                                                               // save SCSI_HOST pointer
695
696                 pshost->io_port         = padapter->basePort;
697                 pshost->n_io_port       = 0xFF;
698                 pshost->unique_id       = padapter->basePort;
699                 pshost->max_id          = 16;
700                 pshost->max_channel     = 1;
701
702                 for ( zz = 0;  zz < MAX_BUS;  zz++ )
703                         for ( z = 0; z < MAX_UNITS;  z++ )
704                                 {
705                                 padapter->dev[zz][z].tag = 0;
706                                 padapter->dev[zz][z].scatGath = (PSCATGATH)consistent;
707                                 padapter->dev[zz][z].scatGathDma = consistentDma;
708                                 consistent += 16 * sizeof (SCATGATH);
709                                 consistentDma += 16 * sizeof (SCATGATH);
710                                 padapter->dev[zz][z].cdb = (UCHAR *)consistent;
711                                 padapter->dev[zz][z].cdbDma = consistentDma;
712                                 consistent += MAX_COMMAND_SIZE;
713                                 consistentDma += MAX_COMMAND_SIZE;
714                                 }
715                         
716                 printk("\nPSI-2000 Intelligent Storage SCSI CONTROLLER: at I/O = %lX  IRQ = %d\n", padapter->basePort, pshost->irq);
717                 printk("Version %s, Compiled %s %s\n\n", PCI2000_VERSION,  __DATE__, __TIME__);
718                 found++;
719                 if ( ++installed < MAXADAPTER )
720                         continue;
721                 break;
722 unregister:;
723                 scsi_unregister (pshost);
724                 found++;
725                 }
726         NumAdapters = installed;
727         return installed;
728         }
729 /****************************************************************
730  *      Name:   Pci2000_Abort
731  *
732  *      Description:    Process the Abort command from the SCSI manager.
733  *
734  *      Parameters:             SCpnt - Pointer to SCSI command structure.
735  *
736  *      Returns:                Allways snooze.
737  *
738  ****************************************************************/
739 int Pci2000_Abort (Scsi_Cmnd *SCpnt)
740         {
741         DEB (printk ("pci2000_abort\n"));
742         return SCSI_ABORT_SNOOZE;
743         }
744 /****************************************************************
745  *      Name:   Pci2000_Reset
746  *
747  *      Description:    Process the Reset command from the SCSI manager.
748  *
749  *      Parameters:             SCpnt - Pointer to SCSI command structure.
750  *                                      flags - Flags about the reset command
751  *
752  *      Returns:                No active command at this time, so this means
753  *                                      that each time we got some kind of response the
754  *                                      last time through.  Tell the mid-level code to
755  *                                      request sense information in order to decide what
756  *                                      to do next.
757  *
758  ****************************************************************/
759 int Pci2000_Reset (Scsi_Cmnd *SCpnt, unsigned int reset_flags)
760         {
761         return SCSI_RESET_PUNT;
762         }
763 /****************************************************************
764  *      Name:   Pci2000_Release
765  *
766  *      Description:    Release resources allocated for a single each adapter.
767  *
768  *      Parameters:             pshost - Pointer to SCSI command structure.
769  *
770  *      Returns:                zero.
771  *
772  ****************************************************************/
773 int Pci2000_Release (struct Scsi_Host *pshost)
774         {
775     PADAPTER2000        padapter = HOSTDATA (pshost);
776
777         if ( padapter->irqOwned )
778                 free_irq (pshost->irq, padapter);
779         pci_free_consistent (padapter->pdev, consistentLen, padapter->dev[0][0].scatGath, padapter->dev[0][0].scatGathDma);
780         release_region (pshost->io_port, pshost->n_io_port);
781     scsi_unregister(pshost);
782     return 0;
783         }
784
785 /****************************************************************
786  *      Name:   Pci2000_BiosParam
787  *
788  *      Description:    Process the biosparam request from the SCSI manager to
789  *                                      return C/H/S data.
790  *
791  *      Parameters:             disk - Pointer to SCSI disk structure.
792  *                                      dev      - Major/minor number from kernel.
793  *                                      geom - Pointer to integer array to place geometry data.
794  *
795  *      Returns:                zero.
796  *
797  ****************************************************************/
798 int Pci2000_BiosParam (struct scsi_device *sdev, struct block_device *dev,
799                 sector_t capacity, int geom[])
800         {
801         PADAPTER2000        padapter;
802
803         padapter = HOSTDATA(sdev->host);
804
805         if ( WaitReady (padapter) )
806                 return 0;
807         outb_p (sdev->id, padapter->mb0);
808         outb_p (CMD_GET_PARMS, padapter->cmd);
809         if ( WaitReady (padapter) )
810                 return 0;
811
812         geom[0] = inb_p (padapter->mb2 + 3);
813         geom[1] = inb_p (padapter->mb2 + 2);
814         geom[2] = inw_p (padapter->mb2);
815         return 0;
816         }
817
818
819 MODULE_LICENSE("Dual BSD/GPL");
820
821 static Scsi_Host_Template driver_template = {
822         .proc_name      = "pci2000",
823         .name           = "PCI-2000 SCSI Intelligent Disk Controller",
824         .detect         = Pci2000_Detect,
825         .release        = Pci2000_Release,
826         .queuecommand   = Pci2000_QueueCommand,
827         .abort          = Pci2000_Abort,
828         .reset          = Pci2000_Reset,
829         .bios_param     = Pci2000_BiosParam,
830         .can_queue      = 16,
831         .this_id        = -1,
832         .sg_tablesize   = 16,
833         .cmd_per_lun    = 1,
834         .use_clustering = DISABLE_CLUSTERING,
835 };
836 #include "scsi_module.c"