?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] fix semaphore handling in __unregister_chrdev_region
[linux/fpc-iii.git] / drivers / scsi / pci2000.c
blob377a4666b56834ad9be2125ed97727e6f499ed57
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"
Linux with added FPC-III support