?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- pre3:
[davej-history.git] / drivers / scsi / pci2000.c
blob3b9b0e2271b7aeb7f3f67d6d8c11a26f6fd6fa3f
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/module.h>
39
40 #include <linux/kernel.h>
41 #include <linux/types.h>
42 #include <linux/string.h>
43 #include <linux/pci.h>
44 #include <linux/ioport.h>
45 #include <linux/delay.h>
46 #include <linux/sched.h>
47 #include <linux/proc_fs.h>
48 #include <asm/dma.h>
49 #include <asm/system.h>
50 #include <asm/io.h>
51 #include <linux/blk.h>
52 #include "scsi.h"
53 #include "hosts.h"
54 #include <linux/stat.h>
55 #include <linux/spinlock.h>
56
57 #include "pci2000.h"
58 #include "psi_roy.h"
59
60
61 //#define DEBUG 1
62
63 #ifdef DEBUG
64 #define DEB(x) x
65 #define STOP_HERE {int st;for(st=0;st<100;st++){st=1;}}
66 #else
67 #define DEB(x)
68 #define STOP_HERE
69 #endif
70
71 typedef struct
72 {
73 unsigned int address;
74 unsigned int length;
75 } SCATGATH, *PSCATGATH;
76
77 typedef struct
78 {
79 Scsi_Cmnd *SCpnt;
80 PSCATGATH scatGath;
81 dma_addr_t scatGathDma;
82 UCHAR *cdb;
83 dma_addr_t cdbDma;
84 UCHAR tag;
85 } DEV2000, *PDEV2000;
86
87 typedef struct
88 {
89 ULONG basePort;
90 ULONG mb0;
91 ULONG mb1;
92 ULONG mb2;
93 ULONG mb3;
94 ULONG mb4;
95 ULONG cmd;
96 ULONG tag;
97 ULONG irqOwned;
98 struct pci_dev *pdev;
99 DEV2000 dev[MAX_BUS][MAX_UNITS];
100 } ADAPTER2000, *PADAPTER2000;
101
102 #define HOSTDATA(host) ((PADAPTER2000)&host->hostdata)
103 #define consistentLen (MAX_BUS * MAX_UNITS * (16 * sizeof (SCATGATH) + MAX_COMMAND_SIZE))
104
105
106 static struct Scsi_Host *PsiHost[MAXADAPTER] = {NULL,}; // One for each adapter
107 static int NumAdapters = 0;
108 /****************************************************************
109 * Name: WaitReady :LOCAL
110 *
111 * Description: Wait for controller ready.
112 *
113 * Parameters: padapter - Pointer adapter data structure.
114 *
115 * Returns: TRUE on not ready.
116 *
117 ****************************************************************/
118 static int WaitReady (PADAPTER2000 padapter)
119 {
120 ULONG z;
121
122 for ( z = 0; z < (TIMEOUT_COMMAND * 4); z++ )
123 {
124 if ( !inb_p (padapter->cmd) )
125 return FALSE;
126 udelay (250);
127 };
128 return TRUE;
129 }
130 /****************************************************************
131 * Name: WaitReadyLong :LOCAL
132 *
133 * Description: Wait for controller ready.
134 *
135 * Parameters: padapter - Pointer adapter data structure.
136 *
137 * Returns: TRUE on not ready.
138 *
139 ****************************************************************/
140 static int WaitReadyLong (PADAPTER2000 padapter)
141 {
142 ULONG z;
143
144 for ( z = 0; z < (5000 * 4); z++ )
145 {
146 if ( !inb_p (padapter->cmd) )
147 return FALSE;
148 udelay (250);
149 };
150 return TRUE;
151 }
152 /****************************************************************
153 * Name: OpDone :LOCAL
154 *
155 * Description: Clean up operation and issue done to caller.
156 *
157 * Parameters: SCpnt - Pointer to SCSI command structure.
158 * status - Caller status.
159 *
160 * Returns: Nothing.
161 *
162 ****************************************************************/
163 static void OpDone (Scsi_Cmnd *SCpnt, ULONG status)
164 {
165 SCpnt->result = status;
166 SCpnt->scsi_done (SCpnt);
167 }
168 /****************************************************************
169 * Name: Command :LOCAL
170 *
171 * Description: Issue queued command to the PCI-2000.
172 *
173 * Parameters: padapter - Pointer to adapter information structure.
174 * cmd - PCI-2000 command byte.
175 *
176 * Returns: Non-zero command tag if operation is accepted.
177 *
178 ****************************************************************/
179 static UCHAR Command (PADAPTER2000 padapter, UCHAR cmd)
180 {
181 outb_p (cmd, padapter->cmd);
182 if ( WaitReady (padapter) )
183 return 0;
184
185 if ( inw_p (padapter->mb0) )
186 return 0;
187
188 return inb_p (padapter->mb1);
189 }
190 /****************************************************************
191 * Name: BuildSgList :LOCAL
192 *
193 * Description: Build the scatter gather list for controller.
194 *
195 * Parameters: SCpnt - Pointer to SCSI command structure.
196 * padapter - Pointer to adapter information structure.
197 * pdev - Pointer to adapter device structure.
198 *
199 * Returns: Non-zero in not scatter gather.
200 *
201 ****************************************************************/
202 static int BuildSgList (Scsi_Cmnd *SCpnt, PADAPTER2000 padapter, PDEV2000 pdev)
203 {
204 int z;
205 int zc;
206 struct scatterlist *sg;
207
208 if ( SCpnt->use_sg )
209 {
210 sg = (struct scatterlist *)SCpnt->request_buffer;
211 zc = pci_map_sg (padapter->pdev, sg, SCpnt->use_sg, scsi_to_pci_dma_dir (SCpnt->sc_data_direction));
212 for ( z = 0; z < zc; z++ )
213 {
214 pdev->scatGath[z].address = cpu_to_le32 (sg_dma_address (sg));
215 pdev->scatGath[z].length = cpu_to_le32 (sg_dma_len (sg++));
216 }
217 outl (pdev->scatGathDma, padapter->mb2);
218 outl ((zc << 24) | SCpnt->request_bufflen, padapter->mb3);
219 return FALSE;
220 }
221 if ( !SCpnt->request_bufflen)
222 {
223 outl (0, padapter->mb2);
224 outl (0, padapter->mb3);
225 return TRUE;
226 }
227 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));
228 outl (SCpnt->SCp.have_data_in, padapter->mb2);
229 outl (SCpnt->request_bufflen, padapter->mb3);
230 return TRUE;
231 }
232 /*********************************************************************
233 * Name: PsiRaidCmd
234 *
235 * Description: Execute a simple command.
236 *
237 * Parameters: padapter - Pointer to adapter control structure.
238 * cmd - Roy command byte.
239 *
240 * Returns: Return error status.
241 *
242 ********************************************************************/
243 static int PsiRaidCmd (PADAPTER2000 padapter, char cmd)
244 {
245 if ( WaitReady (padapter) ) // test for command register ready
246 return DID_TIME_OUT;
247 outb_p (cmd, padapter->cmd); // issue command
248 if ( WaitReadyLong (padapter) ) // wait for adapter ready
249 return DID_TIME_OUT;
250 return DID_OK;
251 }
252 /****************************************************************
253 * Name: Irq_Handler :LOCAL
254 *
255 * Description: Interrupt handler.
256 *
257 * Parameters: irq - Hardware IRQ number.
258 * dev_id -
259 * regs -
260 *
261 * Returns: TRUE if drive is not ready in time.
262 *
263 ****************************************************************/
264 static void Irq_Handler (int irq, void *dev_id, struct pt_regs *regs)
265 {
266 struct Scsi_Host *shost = NULL; // Pointer to host data block
267 PADAPTER2000 padapter; // Pointer to adapter control structure
268 PDEV2000 pdev;
269 Scsi_Cmnd *SCpnt;
270 UCHAR tag = 0;
271 UCHAR tag0;
272 ULONG error;
273 int pun;
274 int bus;
275 int z;
276 unsigned long flags;
277
278 /*
279 * Disable interrupts, if they aren't already disabled and acquire
280 * the I/O spinlock.
281 */
282 spin_lock_irqsave (&io_request_lock, flags);
283
284 DEB(printk ("\npci2000 recieved interrupt "));
285 for ( z = 0; z < NumAdapters; z++ ) // scan for interrupt to process
286 {
287 if ( PsiHost[z]->irq == (UCHAR)(irq & 0xFF) )
288 {
289 tag = inb_p (HOSTDATA(PsiHost[z])->tag);
290 if ( tag )
291 {
292 shost = PsiHost[z];
293 break;
294 }
295 }
296 }
297
298 if ( !shost )
299 {
300 DEB (printk ("\npci2000: not my interrupt"));
301 goto irq_return;
302 }
303
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, scsi_to_pci_dma_dir(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, scsi_to_pci_dma_dir(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 /*
397 * Release the I/O spinlock and restore the original flags
398 * which will enable interrupts if and only if they were
399 * enabled on entry.
400 */
401 spin_unlock_irqrestore (&io_request_lock, flags);
402 }
403 /****************************************************************
404 * Name: Pci2000_QueueCommand
405 *
406 * Description: Process a queued command from the SCSI manager.
407 *
408 * Parameters: SCpnt - Pointer to SCSI command structure.
409 * done - Pointer to done function to call.
410 *
411 * Returns: Status code.
412 *
413 ****************************************************************/
414 int Pci2000_QueueCommand (Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
415 {
416 UCHAR *cdb = (UCHAR *)SCpnt->cmnd; // Pointer to SCSI CDB
417 PADAPTER2000 padapter = HOSTDATA(SCpnt->host); // Pointer to adapter control structure
418 int rc = -1; // command return code
419 UCHAR bus = SCpnt->channel;
420 UCHAR pun = SCpnt->target;
421 UCHAR lun = SCpnt->lun;
422 UCHAR cmd;
423 PDEV2000 pdev = &padapter->dev[bus][pun];
424
425 if ( !done )
426 {
427 printk("pci2000_queuecommand: %02X: done can't be NULL\n", *cdb);
428 return 0;
429 }
430
431 SCpnt->scsi_done = done;
432 SCpnt->SCp.have_data_in = 0;
433 pdev->SCpnt = SCpnt; // Save this command data
434
435 if ( WaitReady (padapter) )
436 {
437 rc = DID_ERROR;
438 goto finished;
439 }
440
441 outw_p (pun | (lun << 8), padapter->mb0);
442
443 if ( bus )
444 {
445 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]));
446 DEB (if(*cdb) printk ("\ntimeout_per_command: %d, timeout_total: %d, timeout: %d, internal_timout: %d", SCpnt->timeout_per_command,
447 SCpnt->timeout_total, SCpnt->timeout, SCpnt->internal_timeout));
448 outl (SCpnt->timeout_per_command, padapter->mb1);
449 outb_p (CMD_SCSI_TIMEOUT, padapter->cmd);
450 if ( WaitReady (padapter) )
451 {
452 rc = DID_ERROR;
453 goto finished;
454 }
455
456 outw_p (pun | (lun << 8), padapter->mb0);
457 outw_p (SCpnt->cmd_len << 8, padapter->mb0 + 2);
458 memcpy (pdev->cdb, cdb, MAX_COMMAND_SIZE);
459
460 outl (pdev->cdbDma, padapter->mb1);
461 if ( BuildSgList (SCpnt, padapter, pdev) )
462 cmd = CMD_SCSI_THRU;
463 else
464 cmd = CMD_SCSI_THRU_SG;
465 if ( (pdev->tag = Command (padapter, cmd)) == 0 )
466 rc = DID_TIME_OUT;
467 goto finished;
468 }
469 else
470 {
471 if ( lun )
472 {
473 rc = DID_BAD_TARGET;
474 goto finished;
475 }
476 }
477
478 switch ( *cdb )
479 {
480 case SCSIOP_INQUIRY: // inquiry CDB
481 if ( cdb[2] == SC_MY_RAID )
482 {
483 switch ( cdb[3] )
484 {
485 case MY_SCSI_REBUILD:
486 OpDone (SCpnt, PsiRaidCmd (padapter, CMD_RAID_REBUILD) << 16);
487 return 0;
488 case MY_SCSI_ALARMMUTE:
489 OpDone (SCpnt, PsiRaidCmd (padapter, CMD_RAID_MUTE) << 16);
490 return 0;
491 case MY_SCSI_DEMOFAIL:
492 OpDone (SCpnt, PsiRaidCmd (padapter, CMD_RAID_FAIL) << 16);
493 return 0;
494 default:
495 if ( SCpnt->use_sg )
496 {
497 rc = DID_ERROR;
498 goto finished;
499 }
500 else
501 {
502 SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, SCpnt->request_buffer, SCpnt->request_bufflen,
503 scsi_to_pci_dma_dir(SCpnt->sc_data_direction));
504 outl (SCpnt->SCp.have_data_in, padapter->mb2);
505 }
506 outl (cdb[5], padapter->mb0);
507 outl (cdb[3], padapter->mb3);
508 cmd = CMD_DASD_RAID_RQ;
509 break;
510 }
511 break;
512 }
513
514 if ( SCpnt->use_sg )
515 {
516 SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, ((struct scatterlist *)SCpnt->request_buffer)->address,
517 SCpnt->request_bufflen, scsi_to_pci_dma_dir (SCpnt->sc_data_direction));
518 }
519 else
520 {
521 SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, SCpnt->request_buffer,
522 SCpnt->request_bufflen, scsi_to_pci_dma_dir (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: internal_done :LOCAL
618 *
619 * Description: Done handler for non-queued commands
620 *
621 * Parameters: SCpnt - Pointer to SCSI command structure.
622 *
623 * Returns: Nothing.
624 *
625 ****************************************************************/
626 static void internal_done (Scsi_Cmnd * SCpnt)
627 {
628 SCpnt->SCp.Status++;
629 }
630 /****************************************************************
631 * Name: Pci2000_Command
632 *
633 * Description: Process a command from the SCSI manager.
634 *
635 * Parameters: SCpnt - Pointer to SCSI command structure.
636 *
637 * Returns: Status code.
638 *
639 ****************************************************************/
640 int Pci2000_Command (Scsi_Cmnd *SCpnt)
641 {
642 DEB(printk("pci2000_command: ..calling pci2000_queuecommand\n"));
643
644 Pci2000_QueueCommand (SCpnt, internal_done);
645
646 SCpnt->SCp.Status = 0;
647 while (!SCpnt->SCp.Status)
648 barrier ();
649 return SCpnt->result;
650 }
651 /****************************************************************
652 * Name: Pci2000_Detect
653 *
654 * Description: Detect and initialize our boards.
655 *
656 * Parameters: tpnt - Pointer to SCSI host template structure.
657 *
658 * Returns: Number of adapters installed.
659 *
660 ****************************************************************/
661 int Pci2000_Detect (Scsi_Host_Template *tpnt)
662 {
663 int found = 0;
664 int installed = 0;
665 struct Scsi_Host *pshost;
666 PADAPTER2000 padapter;
667 int z, zz;
668 int setirq;
669 struct pci_dev *pdev = NULL;
670 UCHAR *consistent;
671 dma_addr_t consistentDma;
672
673
674 if ( !pci_present () )
675 {
676 printk ("pci2000: PCI BIOS not present\n");
677 return 0;
678 }
679
680 while ( (pdev = pci_find_device (VENDOR_PSI, DEVICE_ROY_1, pdev)) != NULL )
681 {
682 if (pci_enable_device(pdev))
683 continue;
684 pshost = scsi_register (tpnt, sizeof(ADAPTER2000));
685 if(pshost == NULL)
686 continue;
687 padapter = HOSTDATA(pshost);
688
689 padapter->basePort = pci_resource_start (pdev, 1);
690 DEB (printk ("\nBase Regs = %#04X", padapter->basePort)); // get the base I/O port address
691 padapter->mb0 = padapter->basePort + RTR_MAILBOX; // get the 32 bit mail boxes
692 padapter->mb1 = padapter->basePort + RTR_MAILBOX + 4;
693 padapter->mb2 = padapter->basePort + RTR_MAILBOX + 8;
694 padapter->mb3 = padapter->basePort + RTR_MAILBOX + 12;
695 padapter->mb4 = padapter->basePort + RTR_MAILBOX + 16;
696 padapter->cmd = padapter->basePort + RTR_LOCAL_DOORBELL; // command register
697 padapter->tag = padapter->basePort + RTR_PCI_DOORBELL; // tag/response register
698 padapter->pdev = pdev;
699
700 if ( WaitReady (padapter) )
701 goto unregister;
702 outb_p (0x84, padapter->mb0);
703 outb_p (CMD_SPECIFY, padapter->cmd);
704 if ( WaitReady (padapter) )
705 goto unregister;
706
707 consistent = pci_alloc_consistent (pdev, consistentLen, &consistentDma);
708 if ( !consistent )
709 {
710 printk ("Unable to allocate DMA memory for PCI-2000 controller.\n");
711 goto unregister;
712 }
713
714 pshost->irq = pdev->irq;
715 setirq = 1;
716 padapter->irqOwned = 0;
717 for ( z = 0; z < installed; z++ ) // scan for shared interrupts
718 {
719 if ( PsiHost[z]->irq == pshost->irq ) // if shared then, don't posses
720 setirq = 0;
721 }
722 if ( setirq ) // if not shared, posses
723 {
724 if ( request_irq (pshost->irq, Irq_Handler, SA_SHIRQ, "pci2000", padapter) < 0 )
725 {
726 if ( request_irq (pshost->irq, Irq_Handler, SA_INTERRUPT | SA_SHIRQ, "pci2000", padapter) < 0 )
727 {
728 printk ("Unable to allocate IRQ for PCI-2000 controller.\n");
729 pci_free_consistent (pdev, consistentLen, consistent, consistentDma);
730 goto unregister;
731 }
732 }
733 padapter->irqOwned = pshost->irq; // set IRQ as owned
734 }
735 PsiHost[installed] = pshost; // save SCSI_HOST pointer
736
737 pshost->io_port = padapter->basePort;
738 pshost->n_io_port = 0xFF;
739 pshost->unique_id = padapter->basePort;
740 pshost->max_id = 16;
741 pshost->max_channel = 1;
742
743 for ( zz = 0; zz < MAX_BUS; zz++ )
744 for ( z = 0; z < MAX_UNITS; z++ )
745 {
746 padapter->dev[zz][z].tag = 0;
747 padapter->dev[zz][z].scatGath = (PSCATGATH)consistent;
748 padapter->dev[zz][z].scatGathDma = consistentDma;
749 consistent += 16 * sizeof (SCATGATH);
750 consistentDma += 16 * sizeof (SCATGATH);
751 padapter->dev[zz][z].cdb = (UCHAR *)consistent;
752 padapter->dev[zz][z].cdbDma = consistentDma;
753 consistent += MAX_COMMAND_SIZE;
754 consistentDma += MAX_COMMAND_SIZE;
755 }
756
757 printk("\nPSI-2000 Intelligent Storage SCSI CONTROLLER: at I/O = %lX IRQ = %d\n", padapter->basePort, pshost->irq);
758 printk("Version %s, Compiled %s %s\n\n", PCI2000_VERSION, __DATE__, __TIME__);
759 found++;
760 if ( ++installed < MAXADAPTER )
761 continue;
762 break;
763 unregister:;
764 scsi_unregister (pshost);
765 found++;
766 }
767 NumAdapters = installed;
768 return installed;
769 }
770 /****************************************************************
771 * Name: Pci2000_Abort
772 *
773 * Description: Process the Abort command from the SCSI manager.
774 *
775 * Parameters: SCpnt - Pointer to SCSI command structure.
776 *
777 * Returns: Allways snooze.
778 *
779 ****************************************************************/
780 int Pci2000_Abort (Scsi_Cmnd *SCpnt)
781 {
782 DEB (printk ("pci2000_abort\n"));
783 return SCSI_ABORT_SNOOZE;
784 }
785 /****************************************************************
786 * Name: Pci2000_Reset
787 *
788 * Description: Process the Reset command from the SCSI manager.
789 *
790 * Parameters: SCpnt - Pointer to SCSI command structure.
791 * flags - Flags about the reset command
792 *
793 * Returns: No active command at this time, so this means
794 * that each time we got some kind of response the
795 * last time through. Tell the mid-level code to
796 * request sense information in order to decide what
797 * to do next.
798 *
799 ****************************************************************/
800 int Pci2000_Reset (Scsi_Cmnd *SCpnt, unsigned int reset_flags)
801 {
802 return SCSI_RESET_PUNT;
803 }
804 /****************************************************************
805 * Name: Pci2000_Release
806 *
807 * Description: Release resources allocated for a single each adapter.
808 *
809 * Parameters: pshost - Pointer to SCSI command structure.
810 *
811 * Returns: zero.
812 *
813 ****************************************************************/
814 int Pci2000_Release (struct Scsi_Host *pshost)
815 {
816 PADAPTER2000 padapter = HOSTDATA (pshost);
817
818 if ( padapter->irqOwned )
819 free_irq (pshost->irq, padapter);
820 pci_free_consistent (padapter->pdev, consistentLen, padapter->dev[0][0].scatGath, padapter->dev[0][0].scatGathDma);
821 release_region (pshost->io_port, pshost->n_io_port);
822 scsi_unregister(pshost);
823 return 0;
824 }
825
826 #include "sd.h"
827 /****************************************************************
828 * Name: Pci2000_BiosParam
829 *
830 * Description: Process the biosparam request from the SCSI manager to
831 * return C/H/S data.
832 *
833 * Parameters: disk - Pointer to SCSI disk structure.
834 * dev - Major/minor number from kernel.
835 * geom - Pointer to integer array to place geometry data.
836 *
837 * Returns: zero.
838 *
839 ****************************************************************/
840 int Pci2000_BiosParam (Scsi_Disk *disk, kdev_t dev, int geom[])
841 {
842 PADAPTER2000 padapter;
843
844 padapter = HOSTDATA(disk->device->host);
845
846 if ( WaitReady (padapter) )
847 return 0;
848 outb_p (disk->device->id, padapter->mb0);
849 outb_p (CMD_GET_PARMS, padapter->cmd);
850 if ( WaitReady (padapter) )
851 return 0;
852
853 geom[0] = inb_p (padapter->mb2 + 3);
854 geom[1] = inb_p (padapter->mb2 + 2);
855 geom[2] = inw_p (padapter->mb2);
856 return 0;
857 }
858
859
860 /* Eventually this will go into an include file, but this will be later */
861 static Scsi_Host_Template driver_template = PCI2000;
862
863 #include "scsi_module.c"
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux