aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/scsi/pci2000.c
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
committerLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
commit1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch)
tree0bba044c4ce775e45a88a51686b5d9f90697ea9d /drivers/scsi/pci2000.c
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
Diffstat (limited to 'drivers/scsi/pci2000.c')
-rw-r--r--drivers/scsi/pci2000.c834
1 files changed, 834 insertions, 0 deletions
diff --git a/drivers/scsi/pci2000.c b/drivers/scsi/pci2000.c
new file mode 100644
index 000000000000..60ce1cce9497
--- /dev/null
+++ b/drivers/scsi/pci2000.c
@@ -0,0 +1,834 @@
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
72typedef struct
73 {
74 unsigned int address;
75 unsigned int length;
76 } SCATGATH, *PSCATGATH;
77
78typedef 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
88typedef 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
107static struct Scsi_Host *PsiHost[MAXADAPTER] = {NULL,}; // One for each adapter
108static 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 ****************************************************************/
119static 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 ****************************************************************/
141static 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 ****************************************************************/
164static 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 ****************************************************************/
180static 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 ****************************************************************/
203static 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, scsi_to_pci_dma_dir (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, SCpnt->request_buffer, SCpnt->request_bufflen, scsi_to_pci_dma_dir (SCpnt->sc_data_direction));
229 outl (SCpnt->SCp.have_data_in, padapter->mb2);
230 outl (SCpnt->request_bufflen, padapter->mb3);
231 return TRUE;
232 }
233/*********************************************************************
234 * Name: PsiRaidCmd
235 *
236 * Description: Execute a simple command.
237 *
238 * Parameters: padapter - Pointer to adapter control structure.
239 * cmd - Roy command byte.
240 *
241 * Returns: Return error status.
242 *
243 ********************************************************************/
244static int PsiRaidCmd (PADAPTER2000 padapter, char cmd)
245 {
246 if ( WaitReady (padapter) ) // test for command register ready
247 return DID_TIME_OUT;
248 outb_p (cmd, padapter->cmd); // issue command
249 if ( WaitReadyLong (padapter) ) // wait for adapter ready
250 return DID_TIME_OUT;
251 return DID_OK;
252 }
253/****************************************************************
254 * Name: Irq_Handler :LOCAL
255 *
256 * Description: Interrupt handler.
257 *
258 * Parameters: irq - Hardware IRQ number.
259 * dev_id -
260 * regs -
261 *
262 * Returns: TRUE if drive is not ready in time.
263 *
264 ****************************************************************/
265static irqreturn_t Irq_Handler (int irq, void *dev_id, struct pt_regs *regs)
266 {
267 struct Scsi_Host *shost = NULL; // Pointer to host data block
268 PADAPTER2000 padapter; // Pointer to adapter control structure
269 PDEV2000 pdev;
270 Scsi_Cmnd *SCpnt;
271 UCHAR tag = 0;
272 UCHAR tag0;
273 ULONG error;
274 int pun;
275 int bus;
276 int z;
277 unsigned long flags;
278 int handled = 0;
279
280 DEB(printk ("\npci2000 received interrupt "));
281 for ( z = 0; z < NumAdapters; z++ ) // scan for interrupt to process
282 {
283 if ( PsiHost[z]->irq == (UCHAR)(irq & 0xFF) )
284 {
285 tag = inb_p (HOSTDATA(PsiHost[z])->tag);
286 if ( tag )
287 {
288 shost = PsiHost[z];
289 break;
290 }
291 }
292 }
293
294 if ( !shost )
295 {
296 DEB (printk ("\npci2000: not my interrupt"));
297 goto out;
298 }
299
300 handled = 1;
301 spin_lock_irqsave(shost->host_lock, flags);
302 padapter = HOSTDATA(shost);
303
304 tag0 = tag & 0x7F; // mask off the error bit
305 for ( bus = 0; bus < MAX_BUS; bus++ ) // scan the busses
306 {
307 for ( pun = 0; pun < MAX_UNITS; pun++ ) // scan the targets
308 {
309 pdev = &padapter->dev[bus][pun];
310 if ( !pdev->tag )
311 continue;
312 if ( pdev->tag == tag0 ) // is this it?
313 {
314 pdev->tag = 0;
315 SCpnt = pdev->SCpnt;
316 goto unmapProceed;
317 }
318 }
319 }
320
321 outb_p (0xFF, padapter->tag); // clear the op interrupt
322 outb_p (CMD_DONE, padapter->cmd); // complete the op
323 goto irq_return; // done, but, with what?
324
325unmapProceed:;
326 if ( !bus )
327 {
328 switch ( SCpnt->cmnd[0] )
329 {
330 case SCSIOP_TEST_UNIT_READY:
331 pci_unmap_single (padapter->pdev, SCpnt->SCp.have_data_in, sizeof (SCpnt->sense_buffer), PCI_DMA_FROMDEVICE);
332 goto irqProceed;
333 case SCSIOP_READ_CAPACITY:
334 pci_unmap_single (padapter->pdev, SCpnt->SCp.have_data_in, 8, PCI_DMA_FROMDEVICE);
335 goto irqProceed;
336 case SCSIOP_VERIFY:
337 case SCSIOP_START_STOP_UNIT:
338 case SCSIOP_MEDIUM_REMOVAL:
339 goto irqProceed;
340 }
341 }
342 if ( SCpnt->SCp.have_data_in )
343 pci_unmap_single (padapter->pdev, SCpnt->SCp.have_data_in, SCpnt->request_bufflen, scsi_to_pci_dma_dir(SCpnt->sc_data_direction));
344 else
345 {
346 if ( SCpnt->use_sg )
347 pci_unmap_sg (padapter->pdev, (struct scatterlist *)SCpnt->request_buffer, SCpnt->use_sg, scsi_to_pci_dma_dir(SCpnt->sc_data_direction));
348 }
349
350irqProceed:;
351 if ( tag & ERR08_TAGGED ) // is there an error here?
352 {
353 if ( WaitReady (padapter) )
354 {
355 OpDone (SCpnt, DID_TIME_OUT << 16);
356 goto irq_return;
357 }
358
359 outb_p (tag0, padapter->mb0); // get real error code
360 outb_p (CMD_ERROR, padapter->cmd);
361 if ( WaitReady (padapter) ) // wait for controller to suck up the op
362 {
363 OpDone (SCpnt, DID_TIME_OUT << 16);
364 goto irq_return;
365 }
366
367 error = inl (padapter->mb0); // get error data
368 outb_p (0xFF, padapter->tag); // clear the op interrupt
369 outb_p (CMD_DONE, padapter->cmd); // complete the op
370
371 DEB (printk ("status: %lX ", error));
372 if ( error == 0x00020002 ) // is this error a check condition?
373 {
374 if ( bus ) // are we doint SCSI commands?
375 {
376 OpDone (SCpnt, (DID_OK << 16) | 2);
377 goto irq_return;
378 }
379 if ( *SCpnt->cmnd == SCSIOP_TEST_UNIT_READY )
380 OpDone (SCpnt, (DRIVER_SENSE << 24) | (DID_OK << 16) | 2); // test caller we have sense data too
381 else
382 OpDone (SCpnt, DID_ERROR << 16);
383 goto irq_return;
384 }
385 OpDone (SCpnt, DID_ERROR << 16);
386 goto irq_return;
387 }
388
389 outb_p (0xFF, padapter->tag); // clear the op interrupt
390 outb_p (CMD_DONE, padapter->cmd); // complete the op
391 OpDone (SCpnt, DID_OK << 16);
392
393irq_return:
394 spin_unlock_irqrestore(shost->host_lock, flags);
395out:
396 return IRQ_RETVAL(handled);
397}
398/****************************************************************
399 * Name: Pci2000_QueueCommand
400 *
401 * Description: Process a queued command from the SCSI manager.
402 *
403 * Parameters: SCpnt - Pointer to SCSI command structure.
404 * done - Pointer to done function to call.
405 *
406 * Returns: Status code.
407 *
408 ****************************************************************/
409int Pci2000_QueueCommand (Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
410 {
411 UCHAR *cdb = (UCHAR *)SCpnt->cmnd; // Pointer to SCSI CDB
412 PADAPTER2000 padapter = HOSTDATA(SCpnt->device->host); // Pointer to adapter control structure
413 int rc = -1; // command return code
414 UCHAR bus = SCpnt->device->channel;
415 UCHAR pun = SCpnt->device->id;
416 UCHAR lun = SCpnt->device->lun;
417 UCHAR cmd;
418 PDEV2000 pdev = &padapter->dev[bus][pun];
419
420 if ( !done )
421 {
422 printk("pci2000_queuecommand: %02X: done can't be NULL\n", *cdb);
423 return 0;
424 }
425
426 SCpnt->scsi_done = done;
427 SCpnt->SCp.have_data_in = 0;
428 pdev->SCpnt = SCpnt; // Save this command data
429
430 if ( WaitReady (padapter) )
431 {
432 rc = DID_ERROR;
433 goto finished;
434 }
435
436 outw_p (pun | (lun << 8), padapter->mb0);
437
438 if ( bus )
439 {
440 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]));
441 DEB (if(*cdb) printk ("\ntimeout_per_command: %d, timeout_total: %d, timeout: %d, internal_timout: %d", SCpnt->timeout_per_command,
442 SCpnt->timeout_total, SCpnt->timeout, SCpnt->internal_timeout));
443 outl (SCpnt->timeout_per_command, padapter->mb1);
444 outb_p (CMD_SCSI_TIMEOUT, padapter->cmd);
445 if ( WaitReady (padapter) )
446 {
447 rc = DID_ERROR;
448 goto finished;
449 }
450
451 outw_p (pun | (lun << 8), padapter->mb0);
452 outw_p (SCpnt->cmd_len << 8, padapter->mb0 + 2);
453 memcpy (pdev->cdb, cdb, MAX_COMMAND_SIZE);
454
455 outl (pdev->cdbDma, padapter->mb1);
456 if ( BuildSgList (SCpnt, padapter, pdev) )
457 cmd = CMD_SCSI_THRU;
458 else
459 cmd = CMD_SCSI_THRU_SG;
460 if ( (pdev->tag = Command (padapter, cmd)) == 0 )
461 rc = DID_TIME_OUT;
462 goto finished;
463 }
464 else
465 {
466 if ( lun )
467 {
468 rc = DID_BAD_TARGET;
469 goto finished;
470 }
471 }
472
473 switch ( *cdb )
474 {
475 case SCSIOP_INQUIRY: // inquiry CDB
476 if ( cdb[2] == SC_MY_RAID )
477 {
478 switch ( cdb[3] )
479 {
480 case MY_SCSI_REBUILD:
481 OpDone (SCpnt, PsiRaidCmd (padapter, CMD_RAID_REBUILD) << 16);
482 return 0;
483 case MY_SCSI_ALARMMUTE:
484 OpDone (SCpnt, PsiRaidCmd (padapter, CMD_RAID_MUTE) << 16);
485 return 0;
486 case MY_SCSI_DEMOFAIL:
487 OpDone (SCpnt, PsiRaidCmd (padapter, CMD_RAID_FAIL) << 16);
488 return 0;
489 default:
490 if ( SCpnt->use_sg )
491 {
492 rc = DID_ERROR;
493 goto finished;
494 }
495 else
496 {
497 SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, SCpnt->request_buffer, SCpnt->request_bufflen,
498 scsi_to_pci_dma_dir(SCpnt->sc_data_direction));
499 outl (SCpnt->SCp.have_data_in, padapter->mb2);
500 }
501 outl (cdb[5], padapter->mb0);
502 outl (cdb[3], padapter->mb3);
503 cmd = CMD_DASD_RAID_RQ;
504 break;
505 }
506 break;
507 }
508
509 if ( SCpnt->use_sg )
510 {
511 SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev,
512 ((struct scatterlist *)SCpnt->request_buffer)->address,
513 SCpnt->request_bufflen,
514 scsi_to_pci_dma_dir (SCpnt->sc_data_direction));
515 }
516 else
517 {
518 SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, SCpnt->request_buffer,
519 SCpnt->request_bufflen,
520 scsi_to_pci_dma_dir (SCpnt->sc_data_direction));
521 }
522 outl (SCpnt->SCp.have_data_in, padapter->mb2);
523 outl (SCpnt->request_bufflen, padapter->mb3);
524 cmd = CMD_DASD_SCSI_INQ;
525 break;
526
527 case SCSIOP_TEST_UNIT_READY: // test unit ready CDB
528 SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, SCpnt->sense_buffer, sizeof (SCpnt->sense_buffer), PCI_DMA_FROMDEVICE);
529 outl (SCpnt->SCp.have_data_in, padapter->mb2);
530 outl (sizeof (SCpnt->sense_buffer), padapter->mb3);
531 cmd = CMD_TEST_READY;
532 break;
533
534 case SCSIOP_READ_CAPACITY: // read capacity CDB
535 if ( SCpnt->use_sg )
536 {
537 SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, ((struct scatterlist *)(SCpnt->request_buffer))->address,
538 8, PCI_DMA_FROMDEVICE);
539 }
540 else
541 SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, SCpnt->request_buffer, 8, PCI_DMA_FROMDEVICE);
542 outl (SCpnt->SCp.have_data_in, padapter->mb2);
543 outl (8, padapter->mb3);
544 cmd = CMD_DASD_CAP;
545 break;
546 case SCSIOP_VERIFY: // verify CDB
547 outw_p ((USHORT)cdb[8] | ((USHORT)cdb[7] << 8), padapter->mb0 + 2);
548 outl (XSCSI2LONG (&cdb[2]), padapter->mb1);
549 cmd = CMD_READ_SG;
550 break;
551 case SCSIOP_READ: // read10 CDB
552 outw_p ((USHORT)cdb[8] | ((USHORT)cdb[7] << 8), padapter->mb0 + 2);
553 outl (XSCSI2LONG (&cdb[2]), padapter->mb1);
554 if ( BuildSgList (SCpnt, padapter, pdev) )
555 cmd = CMD_READ;
556 else
557 cmd = CMD_READ_SG;
558 break;
559 case SCSIOP_READ6: // read6 CDB
560 outw_p (cdb[4], padapter->mb0 + 2);
561 outl ((SCSI2LONG (&cdb[1])) & 0x001FFFFF, padapter->mb1);
562 if ( BuildSgList (SCpnt, padapter, pdev) )
563 cmd = CMD_READ;
564 else
565 cmd = CMD_READ_SG;
566 break;
567 case SCSIOP_WRITE: // write10 CDB
568 outw_p ((USHORT)cdb[8] | ((USHORT)cdb[7] << 8), padapter->mb0 + 2);
569 outl (XSCSI2LONG (&cdb[2]), padapter->mb1);
570 if ( BuildSgList (SCpnt, padapter, pdev) )
571 cmd = CMD_WRITE;
572 else
573 cmd = CMD_WRITE_SG;
574 break;
575 case SCSIOP_WRITE6: // write6 CDB
576 outw_p (cdb[4], padapter->mb0 + 2);
577 outl ((SCSI2LONG (&cdb[1])) & 0x001FFFFF, padapter->mb1);
578 if ( BuildSgList (SCpnt, padapter, pdev) )
579 cmd = CMD_WRITE;
580 else
581 cmd = CMD_WRITE_SG;
582 break;
583 case SCSIOP_START_STOP_UNIT:
584 cmd = CMD_EJECT_MEDIA;
585 break;
586 case SCSIOP_MEDIUM_REMOVAL:
587 switch ( cdb[4] )
588 {
589 case 0:
590 cmd = CMD_UNLOCK_DOOR;
591 break;
592 case 1:
593 cmd = CMD_LOCK_DOOR;
594 break;
595 default:
596 cmd = 0;
597 break;
598 }
599 if ( cmd )
600 break;
601 default:
602 DEB (printk ("pci2000_queuecommand: Unsupported command %02X\n", *cdb));
603 OpDone (SCpnt, DID_ERROR << 16);
604 return 0;
605 }
606
607 if ( (pdev->tag = Command (padapter, cmd)) == 0 )
608 rc = DID_TIME_OUT;
609finished:;
610 if ( rc != -1 )
611 OpDone (SCpnt, rc << 16);
612 return 0;
613 }
614/****************************************************************
615 * Name: Pci2000_Detect
616 *
617 * Description: Detect and initialize our boards.
618 *
619 * Parameters: tpnt - Pointer to SCSI host template structure.
620 *
621 * Returns: Number of adapters installed.
622 *
623 ****************************************************************/
624int Pci2000_Detect (Scsi_Host_Template *tpnt)
625 {
626 int found = 0;
627 int installed = 0;
628 struct Scsi_Host *pshost;
629 PADAPTER2000 padapter;
630 int z, zz;
631 int setirq;
632 struct pci_dev *pdev = NULL;
633 UCHAR *consistent;
634 dma_addr_t consistentDma;
635
636 while ( (pdev = pci_find_device (VENDOR_PSI, DEVICE_ROY_1, pdev)) != NULL )
637 {
638 if (pci_enable_device(pdev))
639 continue;
640 pshost = scsi_register (tpnt, sizeof(ADAPTER2000));
641 if(pshost == NULL)
642 continue;
643 padapter = HOSTDATA(pshost);
644
645 padapter->basePort = pci_resource_start (pdev, 1);
646 DEB (printk ("\nBase Regs = %#04X", padapter->basePort)); // get the base I/O port address
647 padapter->mb0 = padapter->basePort + RTR_MAILBOX; // get the 32 bit mail boxes
648 padapter->mb1 = padapter->basePort + RTR_MAILBOX + 4;
649 padapter->mb2 = padapter->basePort + RTR_MAILBOX + 8;
650 padapter->mb3 = padapter->basePort + RTR_MAILBOX + 12;
651 padapter->mb4 = padapter->basePort + RTR_MAILBOX + 16;
652 padapter->cmd = padapter->basePort + RTR_LOCAL_DOORBELL; // command register
653 padapter->tag = padapter->basePort + RTR_PCI_DOORBELL; // tag/response register
654 padapter->pdev = pdev;
655
656 if ( WaitReady (padapter) )
657 goto unregister;
658 outb_p (0x84, padapter->mb0);
659 outb_p (CMD_SPECIFY, padapter->cmd);
660 if ( WaitReady (padapter) )
661 goto unregister;
662
663 consistent = pci_alloc_consistent (pdev, consistentLen, &consistentDma);
664 if ( !consistent )
665 {
666 printk ("Unable to allocate DMA memory for PCI-2000 controller.\n");
667 goto unregister;
668 }
669
670 scsi_set_device(pshost, &pdev->dev);
671 pshost->irq = pdev->irq;
672 setirq = 1;
673 padapter->irqOwned = 0;
674 for ( z = 0; z < installed; z++ ) // scan for shared interrupts
675 {
676 if ( PsiHost[z]->irq == pshost->irq ) // if shared then, don't posses
677 setirq = 0;
678 }
679 if ( setirq ) // if not shared, posses
680 {
681 if ( request_irq (pshost->irq, Irq_Handler, SA_SHIRQ, "pci2000", padapter) < 0 )
682 {
683 if ( request_irq (pshost->irq, Irq_Handler, SA_INTERRUPT | SA_SHIRQ, "pci2000", padapter) < 0 )
684 {
685 printk ("Unable to allocate IRQ for PCI-2000 controller.\n");
686 pci_free_consistent (pdev, consistentLen, consistent, consistentDma);
687 goto unregister;
688 }
689 }
690 padapter->irqOwned = pshost->irq; // set IRQ as owned
691 }
692 PsiHost[installed] = pshost; // save SCSI_HOST pointer
693
694 pshost->io_port = padapter->basePort;
695 pshost->n_io_port = 0xFF;
696 pshost->unique_id = padapter->basePort;
697 pshost->max_id = 16;
698 pshost->max_channel = 1;
699
700 for ( zz = 0; zz < MAX_BUS; zz++ )
701 for ( z = 0; z < MAX_UNITS; z++ )
702 {
703 padapter->dev[zz][z].tag = 0;
704 padapter->dev[zz][z].scatGath = (PSCATGATH)consistent;
705 padapter->dev[zz][z].scatGathDma = consistentDma;
706 consistent += 16 * sizeof (SCATGATH);
707 consistentDma += 16 * sizeof (SCATGATH);
708 padapter->dev[zz][z].cdb = (UCHAR *)consistent;
709 padapter->dev[zz][z].cdbDma = consistentDma;
710 consistent += MAX_COMMAND_SIZE;
711 consistentDma += MAX_COMMAND_SIZE;
712 }
713
714 printk("\nPSI-2000 Intelligent Storage SCSI CONTROLLER: at I/O = %lX IRQ = %d\n", padapter->basePort, pshost->irq);
715 printk("Version %s, Compiled %s %s\n\n", PCI2000_VERSION, __DATE__, __TIME__);
716 found++;
717 if ( ++installed < MAXADAPTER )
718 continue;
719 break;
720unregister:;
721 scsi_unregister (pshost);
722 found++;
723 }
724 NumAdapters = installed;
725 return installed;
726 }
727/****************************************************************
728 * Name: Pci2000_Abort
729 *
730 * Description: Process the Abort command from the SCSI manager.
731 *
732 * Parameters: SCpnt - Pointer to SCSI command structure.
733 *
734 * Returns: Allways snooze.
735 *
736 ****************************************************************/
737int Pci2000_Abort (Scsi_Cmnd *SCpnt)
738 {
739 DEB (printk ("pci2000_abort\n"));
740 return SCSI_ABORT_SNOOZE;
741 }
742/****************************************************************
743 * Name: Pci2000_Reset
744 *
745 * Description: Process the Reset command from the SCSI manager.
746 *
747 * Parameters: SCpnt - Pointer to SCSI command structure.
748 * flags - Flags about the reset command
749 *
750 * Returns: No active command at this time, so this means
751 * that each time we got some kind of response the
752 * last time through. Tell the mid-level code to
753 * request sense information in order to decide what
754 * to do next.
755 *
756 ****************************************************************/
757int Pci2000_Reset (Scsi_Cmnd *SCpnt, unsigned int reset_flags)
758 {
759 return SCSI_RESET_PUNT;
760 }
761/****************************************************************
762 * Name: Pci2000_Release
763 *
764 * Description: Release resources allocated for a single each adapter.
765 *
766 * Parameters: pshost - Pointer to SCSI command structure.
767 *
768 * Returns: zero.
769 *
770 ****************************************************************/
771int Pci2000_Release (struct Scsi_Host *pshost)
772 {
773 PADAPTER2000 padapter = HOSTDATA (pshost);
774
775 if ( padapter->irqOwned )
776 free_irq (pshost->irq, padapter);
777 pci_free_consistent (padapter->pdev, consistentLen, padapter->dev[0][0].scatGath, padapter->dev[0][0].scatGathDma);
778 release_region (pshost->io_port, pshost->n_io_port);
779 scsi_unregister(pshost);
780 return 0;
781 }
782
783/****************************************************************
784 * Name: Pci2000_BiosParam
785 *
786 * Description: Process the biosparam request from the SCSI manager to
787 * return C/H/S data.
788 *
789 * Parameters: disk - Pointer to SCSI disk structure.
790 * dev - Major/minor number from kernel.
791 * geom - Pointer to integer array to place geometry data.
792 *
793 * Returns: zero.
794 *
795 ****************************************************************/
796int Pci2000_BiosParam (struct scsi_device *sdev, struct block_device *dev,
797 sector_t capacity, int geom[])
798 {
799 PADAPTER2000 padapter;
800
801 padapter = HOSTDATA(sdev->host);
802
803 if ( WaitReady (padapter) )
804 return 0;
805 outb_p (sdev->id, padapter->mb0);
806 outb_p (CMD_GET_PARMS, padapter->cmd);
807 if ( WaitReady (padapter) )
808 return 0;
809
810 geom[0] = inb_p (padapter->mb2 + 3);
811 geom[1] = inb_p (padapter->mb2 + 2);
812 geom[2] = inw_p (padapter->mb2);
813 return 0;
814 }
815
816
817MODULE_LICENSE("Dual BSD/GPL");
818
819static Scsi_Host_Template driver_template = {
820 .proc_name = "pci2000",
821 .name = "PCI-2000 SCSI Intelligent Disk Controller",
822 .detect = Pci2000_Detect,
823 .release = Pci2000_Release,
824 .queuecommand = Pci2000_QueueCommand,
825 .abort = Pci2000_Abort,
826 .reset = Pci2000_Reset,
827 .bios_param = Pci2000_BiosParam,
828 .can_queue = 16,
829 .this_id = -1,
830 .sg_tablesize = 16,
831 .cmd_per_lun = 1,
832 .use_clustering = DISABLE_CLUSTERING,
833};
834#include "scsi_module.c"