diff options
author | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
commit | 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch) | |
tree | 0bba044c4ce775e45a88a51686b5d9f90697ea9d /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.c | 834 |
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 | |||
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, 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 | ********************************************************************/ | ||
244 | static 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 | ****************************************************************/ | ||
265 | static 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 | |||
325 | unmapProceed:; | ||
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 | |||
350 | irqProceed:; | ||
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 | |||
393 | irq_return: | ||
394 | spin_unlock_irqrestore(shost->host_lock, flags); | ||
395 | out: | ||
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 | ****************************************************************/ | ||
409 | int 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; | ||
609 | finished:; | ||
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 | ****************************************************************/ | ||
624 | int 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; | ||
720 | unregister:; | ||
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 | ****************************************************************/ | ||
737 | int 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 | ****************************************************************/ | ||
757 | int 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 | ****************************************************************/ | ||
771 | int 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 | ****************************************************************/ | ||
796 | int 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 | |||
817 | MODULE_LICENSE("Dual BSD/GPL"); | ||
818 | |||
819 | static 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" | ||