projects / deliverable / linux.git / blob
? search:


0fb5bf4c43acd4500b93bc51b1e010c17e3a70d7
[deliverable/linux.git] / drivers / scsi / dpt_i2o.c
1 /***************************************************************************
2 dpti.c - description
3 -------------------
4 begin : Thu Sep 7 2000
5 copyright : (C) 2000 by Adaptec
6
7 July 30, 2001 First version being submitted
8 for inclusion in the kernel. V2.4
9
10 See Documentation/scsi/dpti.txt for history, notes, license info
11 and credits
12 ***************************************************************************/
13
14 /***************************************************************************
15 * *
16 * This program is free software; you can redistribute it and/or modify *
17 * it under the terms of the GNU General Public License as published by *
18 * the Free Software Foundation; either version 2 of the License, or *
19 * (at your option) any later version. *
20 * *
21 ***************************************************************************/
22 /***************************************************************************
23 * Sat Dec 20 2003 Go Taniguchi <go@turbolinux.co.jp>
24 - Support 2.6 kernel and DMA-mapping
25 - ioctl fix for raid tools
26 - use schedule_timeout in long long loop
27 **************************************************************************/
28
29 /*#define DEBUG 1 */
30 /*#define UARTDELAY 1 */
31
32 #include <linux/module.h>
33
34 MODULE_AUTHOR("Deanna Bonds, with _lots_ of help from Mark Salyzyn");
35 MODULE_DESCRIPTION("Adaptec I2O RAID Driver");
36
37 ////////////////////////////////////////////////////////////////
38
39 #include <linux/ioctl.h> /* For SCSI-Passthrough */
40 #include <asm/uaccess.h>
41
42 #include <linux/stat.h>
43 #include <linux/slab.h> /* for kmalloc() */
44 #include <linux/pci.h> /* for PCI support */
45 #include <linux/proc_fs.h>
46 #include <linux/blkdev.h>
47 #include <linux/delay.h> /* for udelay */
48 #include <linux/interrupt.h>
49 #include <linux/kernel.h> /* for printk */
50 #include <linux/sched.h>
51 #include <linux/reboot.h>
52 #include <linux/spinlock.h>
53 #include <linux/dma-mapping.h>
54
55 #include <linux/timer.h>
56 #include <linux/string.h>
57 #include <linux/ioport.h>
58 #include <linux/mutex.h>
59
60 #include <asm/processor.h> /* for boot_cpu_data */
61 #include <asm/pgtable.h>
62 #include <asm/io.h> /* for virt_to_bus, etc. */
63
64 #include <scsi/scsi.h>
65 #include <scsi/scsi_cmnd.h>
66 #include <scsi/scsi_device.h>
67 #include <scsi/scsi_host.h>
68 #include <scsi/scsi_tcq.h>
69
70 #include "dpt/dptsig.h"
71 #include "dpti.h"
72
73 /*============================================================================
74 * Create a binary signature - this is read by dptsig
75 * Needed for our management apps
76 *============================================================================
77 */
78 static dpt_sig_S DPTI_sig = {
79 {'d', 'P', 't', 'S', 'i', 'G'}, SIG_VERSION,
80 #ifdef __i386__
81 PROC_INTEL, PROC_386 | PROC_486 | PROC_PENTIUM | PROC_SEXIUM,
82 #elif defined(__ia64__)
83 PROC_INTEL, PROC_IA64,
84 #elif defined(__sparc__)
85 PROC_ULTRASPARC, PROC_ULTRASPARC,
86 #elif defined(__alpha__)
87 PROC_ALPHA, PROC_ALPHA,
88 #else
89 (-1),(-1),
90 #endif
91 FT_HBADRVR, 0, OEM_DPT, OS_LINUX, CAP_OVERLAP, DEV_ALL,
92 ADF_ALL_SC5, 0, 0, DPT_VERSION, DPT_REVISION, DPT_SUBREVISION,
93 DPT_MONTH, DPT_DAY, DPT_YEAR, "Adaptec Linux I2O RAID Driver"
94 };
95
96
97
98
99 /*============================================================================
100 * Globals
101 *============================================================================
102 */
103
104 static DEFINE_MUTEX(adpt_configuration_lock);
105
106 static struct i2o_sys_tbl *sys_tbl;
107 static dma_addr_t sys_tbl_pa;
108 static int sys_tbl_ind;
109 static int sys_tbl_len;
110
111 static adpt_hba* hba_chain = NULL;
112 static int hba_count = 0;
113
114 static struct class *adpt_sysfs_class;
115
116 #ifdef CONFIG_COMPAT
117 static long compat_adpt_ioctl(struct file *, unsigned int, unsigned long);
118 #endif
119
120 static const struct file_operations adpt_fops = {
121 .ioctl = adpt_ioctl,
122 .open = adpt_open,
123 .release = adpt_close,
124 #ifdef CONFIG_COMPAT
125 .compat_ioctl = compat_adpt_ioctl,
126 #endif
127 };
128
129 /* Structures and definitions for synchronous message posting.
130 * See adpt_i2o_post_wait() for description
131 * */
132 struct adpt_i2o_post_wait_data
133 {
134 int status;
135 u32 id;
136 adpt_wait_queue_head_t *wq;
137 struct adpt_i2o_post_wait_data *next;
138 };
139
140 static struct adpt_i2o_post_wait_data *adpt_post_wait_queue = NULL;
141 static u32 adpt_post_wait_id = 0;
142 static DEFINE_SPINLOCK(adpt_post_wait_lock);
143
144
145 /*============================================================================
146 * Functions
147 *============================================================================
148 */
149
150 static inline int dpt_dma64(adpt_hba *pHba)
151 {
152 return (sizeof(dma_addr_t) > 4 && (pHba)->dma64);
153 }
154
155 static inline u32 dma_high(dma_addr_t addr)
156 {
157 return upper_32_bits(addr);
158 }
159
160 static inline u32 dma_low(dma_addr_t addr)
161 {
162 return (u32)addr;
163 }
164
165 static u8 adpt_read_blink_led(adpt_hba* host)
166 {
167 if (host->FwDebugBLEDflag_P) {
168 if( readb(host->FwDebugBLEDflag_P) == 0xbc ){
169 return readb(host->FwDebugBLEDvalue_P);
170 }
171 }
172 return 0;
173 }
174
175 /*============================================================================
176 * Scsi host template interface functions
177 *============================================================================
178 */
179
180 static struct pci_device_id dptids[] = {
181 { PCI_DPT_VENDOR_ID, PCI_DPT_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
182 { PCI_DPT_VENDOR_ID, PCI_DPT_RAPTOR_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
183 { 0, }
184 };
185 MODULE_DEVICE_TABLE(pci,dptids);
186
187 static int adpt_detect(struct scsi_host_template* sht)
188 {
189 struct pci_dev *pDev = NULL;
190 adpt_hba* pHba;
191
192 PINFO("Detecting Adaptec I2O RAID controllers...\n");
193
194 /* search for all Adatpec I2O RAID cards */
195 while ((pDev = pci_get_device( PCI_DPT_VENDOR_ID, PCI_ANY_ID, pDev))) {
196 if(pDev->device == PCI_DPT_DEVICE_ID ||
197 pDev->device == PCI_DPT_RAPTOR_DEVICE_ID){
198 if(adpt_install_hba(sht, pDev) ){
199 PERROR("Could not Init an I2O RAID device\n");
200 PERROR("Will not try to detect others.\n");
201 return hba_count-1;
202 }
203 pci_dev_get(pDev);
204 }
205 }
206
207 /* In INIT state, Activate IOPs */
208 for (pHba = hba_chain; pHba; pHba = pHba->next) {
209 // Activate does get status , init outbound, and get hrt
210 if (adpt_i2o_activate_hba(pHba) < 0) {
211 adpt_i2o_delete_hba(pHba);
212 }
213 }
214
215
216 /* Active IOPs in HOLD state */
217
218 rebuild_sys_tab:
219 if (hba_chain == NULL)
220 return 0;
221
222 /*
223 * If build_sys_table fails, we kill everything and bail
224 * as we can't init the IOPs w/o a system table
225 */
226 if (adpt_i2o_build_sys_table() < 0) {
227 adpt_i2o_sys_shutdown();
228 return 0;
229 }
230
231 PDEBUG("HBA's in HOLD state\n");
232
233 /* If IOP don't get online, we need to rebuild the System table */
234 for (pHba = hba_chain; pHba; pHba = pHba->next) {
235 if (adpt_i2o_online_hba(pHba) < 0) {
236 adpt_i2o_delete_hba(pHba);
237 goto rebuild_sys_tab;
238 }
239 }
240
241 /* Active IOPs now in OPERATIONAL state */
242 PDEBUG("HBA's in OPERATIONAL state\n");
243
244 printk("dpti: If you have a lot of devices this could take a few minutes.\n");
245 for (pHba = hba_chain; pHba; pHba = pHba->next) {
246 printk(KERN_INFO"%s: Reading the hardware resource table.\n", pHba->name);
247 if (adpt_i2o_lct_get(pHba) < 0){
248 adpt_i2o_delete_hba(pHba);
249 continue;
250 }
251
252 if (adpt_i2o_parse_lct(pHba) < 0){
253 adpt_i2o_delete_hba(pHba);
254 continue;
255 }
256 adpt_inquiry(pHba);
257 }
258
259 adpt_sysfs_class = class_create(THIS_MODULE, "dpt_i2o");
260 if (IS_ERR(adpt_sysfs_class)) {
261 printk(KERN_WARNING"dpti: unable to create dpt_i2o class\n");
262 adpt_sysfs_class = NULL;
263 }
264
265 for (pHba = hba_chain; pHba; pHba = pHba->next) {
266 if (adpt_scsi_host_alloc(pHba, sht) < 0){
267 adpt_i2o_delete_hba(pHba);
268 continue;
269 }
270 pHba->initialized = TRUE;
271 pHba->state &= ~DPTI_STATE_RESET;
272 if (adpt_sysfs_class) {
273 struct device *dev = device_create(adpt_sysfs_class,
274 NULL, MKDEV(DPTI_I2O_MAJOR, pHba->unit),
275 "dpti%d", pHba->unit);
276 if (IS_ERR(dev)) {
277 printk(KERN_WARNING"dpti%d: unable to "
278 "create device in dpt_i2o class\n",
279 pHba->unit);
280 }
281 }
282 }
283
284 // Register our control device node
285 // nodes will need to be created in /dev to access this
286 // the nodes can not be created from within the driver
287 if (hba_count && register_chrdev(DPTI_I2O_MAJOR, DPT_DRIVER, &adpt_fops)) {
288 adpt_i2o_sys_shutdown();
289 return 0;
290 }
291 return hba_count;
292 }
293
294
295 /*
296 * scsi_unregister will be called AFTER we return.
297 */
298 static int adpt_release(struct Scsi_Host *host)
299 {
300 adpt_hba* pHba = (adpt_hba*) host->hostdata[0];
301 // adpt_i2o_quiesce_hba(pHba);
302 adpt_i2o_delete_hba(pHba);
303 scsi_unregister(host);
304 return 0;
305 }
306
307
308 static void adpt_inquiry(adpt_hba* pHba)
309 {
310 u32 msg[17];
311 u32 *mptr;
312 u32 *lenptr;
313 int direction;
314 int scsidir;
315 u32 len;
316 u32 reqlen;
317 u8* buf;
318 dma_addr_t addr;
319 u8 scb[16];
320 s32 rcode;
321
322 memset(msg, 0, sizeof(msg));
323 buf = dma_alloc_coherent(&pHba->pDev->dev, 80, &addr, GFP_KERNEL);
324 if(!buf){
325 printk(KERN_ERR"%s: Could not allocate buffer\n",pHba->name);
326 return;
327 }
328 memset((void*)buf, 0, 36);
329
330 len = 36;
331 direction = 0x00000000;
332 scsidir =0x40000000; // DATA IN (iop<--dev)
333
334 if (dpt_dma64(pHba))
335 reqlen = 17; // SINGLE SGE, 64 bit
336 else
337 reqlen = 14; // SINGLE SGE, 32 bit
338 /* Stick the headers on */
339 msg[0] = reqlen<<16 | SGL_OFFSET_12;
340 msg[1] = (0xff<<24|HOST_TID<<12|ADAPTER_TID);
341 msg[2] = 0;
342 msg[3] = 0;
343 // Adaptec/DPT Private stuff
344 msg[4] = I2O_CMD_SCSI_EXEC|DPT_ORGANIZATION_ID<<16;
345 msg[5] = ADAPTER_TID | 1<<16 /* Interpret*/;
346 /* Direction, disconnect ok | sense data | simple queue , CDBLen */
347 // I2O_SCB_FLAG_ENABLE_DISCONNECT |
348 // I2O_SCB_FLAG_SIMPLE_QUEUE_TAG |
349 // I2O_SCB_FLAG_SENSE_DATA_IN_MESSAGE;
350 msg[6] = scsidir|0x20a00000| 6 /* cmd len*/;
351
352 mptr=msg+7;
353
354 memset(scb, 0, sizeof(scb));
355 // Write SCSI command into the message - always 16 byte block
356 scb[0] = INQUIRY;
357 scb[1] = 0;
358 scb[2] = 0;
359 scb[3] = 0;
360 scb[4] = 36;
361 scb[5] = 0;
362 // Don't care about the rest of scb
363
364 memcpy(mptr, scb, sizeof(scb));
365 mptr+=4;
366 lenptr=mptr++; /* Remember me - fill in when we know */
367
368 /* Now fill in the SGList and command */
369 *lenptr = len;
370 if (dpt_dma64(pHba)) {
371 *mptr++ = (0x7C<<24)+(2<<16)+0x02; /* Enable 64 bit */
372 *mptr++ = 1 << PAGE_SHIFT;
373 *mptr++ = 0xD0000000|direction|len;
374 *mptr++ = dma_low(addr);
375 *mptr++ = dma_high(addr);
376 } else {
377 *mptr++ = 0xD0000000|direction|len;
378 *mptr++ = addr;
379 }
380
381 // Send it on it's way
382 rcode = adpt_i2o_post_wait(pHba, msg, reqlen<<2, 120);
383 if (rcode != 0) {
384 sprintf(pHba->detail, "Adaptec I2O RAID");
385 printk(KERN_INFO "%s: Inquiry Error (%d)\n",pHba->name,rcode);
386 if (rcode != -ETIME && rcode != -EINTR)
387 dma_free_coherent(&pHba->pDev->dev, 80, buf, addr);
388 } else {
389 memset(pHba->detail, 0, sizeof(pHba->detail));
390 memcpy(&(pHba->detail), "Vendor: Adaptec ", 16);
391 memcpy(&(pHba->detail[16]), " Model: ", 8);
392 memcpy(&(pHba->detail[24]), (u8*) &buf[16], 16);
393 memcpy(&(pHba->detail[40]), " FW: ", 4);
394 memcpy(&(pHba->detail[44]), (u8*) &buf[32], 4);
395 pHba->detail[48] = '\0'; /* precautionary */
396 dma_free_coherent(&pHba->pDev->dev, 80, buf, addr);
397 }
398 adpt_i2o_status_get(pHba);
399 return ;
400 }
401
402
403 static int adpt_slave_configure(struct scsi_device * device)
404 {
405 struct Scsi_Host *host = device->host;
406 adpt_hba* pHba;
407
408 pHba = (adpt_hba *) host->hostdata[0];
409
410 if (host->can_queue && device->tagged_supported) {
411 scsi_adjust_queue_depth(device, MSG_SIMPLE_TAG,
412 host->can_queue - 1);
413 } else {
414 scsi_adjust_queue_depth(device, 0, 1);
415 }
416 return 0;
417 }
418
419 static int adpt_queue(struct scsi_cmnd * cmd, void (*done) (struct scsi_cmnd *))
420 {
421 adpt_hba* pHba = NULL;
422 struct adpt_device* pDev = NULL; /* dpt per device information */
423
424 cmd->scsi_done = done;
425 /*
426 * SCSI REQUEST_SENSE commands will be executed automatically by the
427 * Host Adapter for any errors, so they should not be executed
428 * explicitly unless the Sense Data is zero indicating that no error
429 * occurred.
430 */
431
432 if ((cmd->cmnd[0] == REQUEST_SENSE) && (cmd->sense_buffer[0] != 0)) {
433 cmd->result = (DID_OK << 16);
434 cmd->scsi_done(cmd);
435 return 0;
436 }
437
438 pHba = (adpt_hba*)cmd->device->host->hostdata[0];
439 if (!pHba) {
440 return FAILED;
441 }
442
443 rmb();
444 /*
445 * TODO: I need to block here if I am processing ioctl cmds
446 * but if the outstanding cmds all finish before the ioctl,
447 * the scsi-core will not know to start sending cmds to me again.
448 * I need to a way to restart the scsi-cores queues or should I block
449 * calling scsi_done on the outstanding cmds instead
450 * for now we don't set the IOCTL state
451 */
452 if(((pHba->state) & DPTI_STATE_IOCTL) || ((pHba->state) & DPTI_STATE_RESET)) {
453 pHba->host->last_reset = jiffies;
454 pHba->host->resetting = 1;
455 return 1;
456 }
457
458 // TODO if the cmd->device if offline then I may need to issue a bus rescan
459 // followed by a get_lct to see if the device is there anymore
460 if((pDev = (struct adpt_device*) (cmd->device->hostdata)) == NULL) {
461 /*
462 * First command request for this device. Set up a pointer
463 * to the device structure. This should be a TEST_UNIT_READY
464 * command from scan_scsis_single.
465 */
466 if ((pDev = adpt_find_device(pHba, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun)) == NULL) {
467 // TODO: if any luns are at this bus, scsi id then fake a TEST_UNIT_READY and INQUIRY response
468 // with type 7F (for all luns less than the max for this bus,id) so the lun scan will continue.
469 cmd->result = (DID_NO_CONNECT << 16);
470 cmd->scsi_done(cmd);
471 return 0;
472 }
473 cmd->device->hostdata = pDev;
474 }
475 pDev->pScsi_dev = cmd->device;
476
477 /*
478 * If we are being called from when the device is being reset,
479 * delay processing of the command until later.
480 */
481 if (pDev->state & DPTI_DEV_RESET ) {
482 return FAILED;
483 }
484 return adpt_scsi_to_i2o(pHba, cmd, pDev);
485 }
486
487 static int adpt_bios_param(struct scsi_device *sdev, struct block_device *dev,
488 sector_t capacity, int geom[])
489 {
490 int heads=-1;
491 int sectors=-1;
492 int cylinders=-1;
493
494 // *** First lets set the default geometry ****
495
496 // If the capacity is less than ox2000
497 if (capacity < 0x2000 ) { // floppy
498 heads = 18;
499 sectors = 2;
500 }
501 // else if between 0x2000 and 0x20000
502 else if (capacity < 0x20000) {
503 heads = 64;
504 sectors = 32;
505 }
506 // else if between 0x20000 and 0x40000
507 else if (capacity < 0x40000) {
508 heads = 65;
509 sectors = 63;
510 }
511 // else if between 0x4000 and 0x80000
512 else if (capacity < 0x80000) {
513 heads = 128;
514 sectors = 63;
515 }
516 // else if greater than 0x80000
517 else {
518 heads = 255;
519 sectors = 63;
520 }
521 cylinders = sector_div(capacity, heads * sectors);
522
523 // Special case if CDROM
524 if(sdev->type == 5) { // CDROM
525 heads = 252;
526 sectors = 63;
527 cylinders = 1111;
528 }
529
530 geom[0] = heads;
531 geom[1] = sectors;
532 geom[2] = cylinders;
533
534 PDEBUG("adpt_bios_param: exit\n");
535 return 0;
536 }
537
538
539 static const char *adpt_info(struct Scsi_Host *host)
540 {
541 adpt_hba* pHba;
542
543 pHba = (adpt_hba *) host->hostdata[0];
544 return (char *) (pHba->detail);
545 }
546
547 static int adpt_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
548 int length, int inout)
549 {
550 struct adpt_device* d;
551 int id;
552 int chan;
553 int len = 0;
554 int begin = 0;
555 int pos = 0;
556 adpt_hba* pHba;
557 int unit;
558
559 *start = buffer;
560 if (inout == TRUE) {
561 /*
562 * The user has done a write and wants us to take the
563 * data in the buffer and do something with it.
564 * proc_scsiwrite calls us with inout = 1
565 *
566 * Read data from buffer (writing to us) - NOT SUPPORTED
567 */
568 return -EINVAL;
569 }
570
571 /*
572 * inout = 0 means the user has done a read and wants information
573 * returned, so we write information about the cards into the buffer
574 * proc_scsiread() calls us with inout = 0
575 */
576
577 // Find HBA (host bus adapter) we are looking for
578 mutex_lock(&adpt_configuration_lock);
579 for (pHba = hba_chain; pHba; pHba = pHba->next) {
580 if (pHba->host == host) {
581 break; /* found adapter */
582 }
583 }
584 mutex_unlock(&adpt_configuration_lock);
585 if (pHba == NULL) {
586 return 0;
587 }
588 host = pHba->host;
589
590 len = sprintf(buffer , "Adaptec I2O RAID Driver Version: %s\n\n", DPT_I2O_VERSION);
591 len += sprintf(buffer+len, "%s\n", pHba->detail);
592 len += sprintf(buffer+len, "SCSI Host=scsi%d Control Node=/dev/%s irq=%d\n",
593 pHba->host->host_no, pHba->name, host->irq);
594 len += sprintf(buffer+len, "\tpost fifo size = %d\n\treply fifo size = %d\n\tsg table size = %d\n\n",
595 host->can_queue, (int) pHba->reply_fifo_size , host->sg_tablesize);
596
597 pos = begin + len;
598
599 /* CHECKPOINT */
600 if(pos > offset + length) {
601 goto stop_output;
602 }
603 if(pos <= offset) {
604 /*
605 * If we haven't even written to where we last left
606 * off (the last time we were called), reset the
607 * beginning pointer.
608 */
609 len = 0;
610 begin = pos;
611 }
612 len += sprintf(buffer+len, "Devices:\n");
613 for(chan = 0; chan < MAX_CHANNEL; chan++) {
614 for(id = 0; id < MAX_ID; id++) {
615 d = pHba->channel[chan].device[id];
616 while(d){
617 len += sprintf(buffer+len,"\t%-24.24s", d->pScsi_dev->vendor);
618 len += sprintf(buffer+len," Rev: %-8.8s\n", d->pScsi_dev->rev);
619 pos = begin + len;
620
621
622 /* CHECKPOINT */
623 if(pos > offset + length) {
624 goto stop_output;
625 }
626 if(pos <= offset) {
627 len = 0;
628 begin = pos;
629 }
630
631 unit = d->pI2o_dev->lct_data.tid;
632 len += sprintf(buffer+len, "\tTID=%d, (Channel=%d, Target=%d, Lun=%d) (%s)\n\n",
633 unit, (int)d->scsi_channel, (int)d->scsi_id, (int)d->scsi_lun,
634 scsi_device_online(d->pScsi_dev)? "online":"offline");
635 pos = begin + len;
636
637 /* CHECKPOINT */
638 if(pos > offset + length) {
639 goto stop_output;
640 }
641 if(pos <= offset) {
642 len = 0;
643 begin = pos;
644 }
645
646 d = d->next_lun;
647 }
648 }
649 }
650
651 /*
652 * begin is where we last checked our position with regards to offset
653 * begin is always less than offset. len is relative to begin. It
654 * is the number of bytes written past begin
655 *
656 */
657 stop_output:
658 /* stop the output and calculate the correct length */
659 *(buffer + len) = '\0';
660
661 *start = buffer + (offset - begin); /* Start of wanted data */
662 len -= (offset - begin);
663 if(len > length) {
664 len = length;
665 } else if(len < 0){
666 len = 0;
667 **start = '\0';
668 }
669 return len;
670 }
671
672 /*
673 * Turn a struct scsi_cmnd * into a unique 32 bit 'context'.
674 */
675 static u32 adpt_cmd_to_context(struct scsi_cmnd *cmd)
676 {
677 return (u32)cmd->serial_number;
678 }
679
680 /*
681 * Go from a u32 'context' to a struct scsi_cmnd * .
682 * This could probably be made more efficient.
683 */
684 static struct scsi_cmnd *
685 adpt_cmd_from_context(adpt_hba * pHba, u32 context)
686 {
687 struct scsi_cmnd * cmd;
688 struct scsi_device * d;
689
690 if (context == 0)
691 return NULL;
692
693 spin_unlock(pHba->host->host_lock);
694 shost_for_each_device(d, pHba->host) {
695 unsigned long flags;
696 spin_lock_irqsave(&d->list_lock, flags);
697 list_for_each_entry(cmd, &d->cmd_list, list) {
698 if (((u32)cmd->serial_number == context)) {
699 spin_unlock_irqrestore(&d->list_lock, flags);
700 scsi_device_put(d);
701 spin_lock(pHba->host->host_lock);
702 return cmd;
703 }
704 }
705 spin_unlock_irqrestore(&d->list_lock, flags);
706 }
707 spin_lock(pHba->host->host_lock);
708
709 return NULL;
710 }
711
712 /*
713 * Turn a pointer to ioctl reply data into an u32 'context'
714 */
715 static u32 adpt_ioctl_to_context(adpt_hba * pHba, void *reply)
716 {
717 #if BITS_PER_LONG == 32
718 return (u32)(unsigned long)reply;
719 #else
720 ulong flags = 0;
721 u32 nr, i;
722
723 spin_lock_irqsave(pHba->host->host_lock, flags);
724 nr = ARRAY_SIZE(pHba->ioctl_reply_context);
725 for (i = 0; i < nr; i++) {
726 if (pHba->ioctl_reply_context[i] == NULL) {
727 pHba->ioctl_reply_context[i] = reply;
728 break;
729 }
730 }
731 spin_unlock_irqrestore(pHba->host->host_lock, flags);
732 if (i >= nr) {
733 kfree (reply);
734 printk(KERN_WARNING"%s: Too many outstanding "
735 "ioctl commands\n", pHba->name);
736 return (u32)-1;
737 }
738
739 return i;
740 #endif
741 }
742
743 /*
744 * Go from an u32 'context' to a pointer to ioctl reply data.
745 */
746 static void *adpt_ioctl_from_context(adpt_hba *pHba, u32 context)
747 {
748 #if BITS_PER_LONG == 32
749 return (void *)(unsigned long)context;
750 #else
751 void *p = pHba->ioctl_reply_context[context];
752 pHba->ioctl_reply_context[context] = NULL;
753
754 return p;
755 #endif
756 }
757
758 /*===========================================================================
759 * Error Handling routines
760 *===========================================================================
761 */
762
763 static int adpt_abort(struct scsi_cmnd * cmd)
764 {
765 adpt_hba* pHba = NULL; /* host bus adapter structure */
766 struct adpt_device* dptdevice; /* dpt per device information */
767 u32 msg[5];
768 int rcode;
769
770 if(cmd->serial_number == 0){
771 return FAILED;
772 }
773 pHba = (adpt_hba*) cmd->device->host->hostdata[0];
774 printk(KERN_INFO"%s: Trying to Abort cmd=%ld\n",pHba->name, cmd->serial_number);
775 if ((dptdevice = (void*) (cmd->device->hostdata)) == NULL) {
776 printk(KERN_ERR "%s: Unable to abort: No device in cmnd\n",pHba->name);
777 return FAILED;
778 }
779
780 memset(msg, 0, sizeof(msg));
781 msg[0] = FIVE_WORD_MSG_SIZE|SGL_OFFSET_0;
782 msg[1] = I2O_CMD_SCSI_ABORT<<24|HOST_TID<<12|dptdevice->tid;
783 msg[2] = 0;
784 msg[3]= 0;
785 msg[4] = adpt_cmd_to_context(cmd);
786 if (pHba->host)
787 spin_lock_irq(pHba->host->host_lock);
788 rcode = adpt_i2o_post_wait(pHba, msg, sizeof(msg), FOREVER);
789 if (pHba->host)
790 spin_unlock_irq(pHba->host->host_lock);
791 if (rcode != 0) {
792 if(rcode == -EOPNOTSUPP ){
793 printk(KERN_INFO"%s: Abort cmd not supported\n",pHba->name);
794 return FAILED;
795 }
796 printk(KERN_INFO"%s: Abort cmd=%ld failed.\n",pHba->name, cmd->serial_number);
797 return FAILED;
798 }
799 printk(KERN_INFO"%s: Abort cmd=%ld complete.\n",pHba->name, cmd->serial_number);
800 return SUCCESS;
801 }
802
803
804 #define I2O_DEVICE_RESET 0x27
805 // This is the same for BLK and SCSI devices
806 // NOTE this is wrong in the i2o.h definitions
807 // This is not currently supported by our adapter but we issue it anyway
808 static int adpt_device_reset(struct scsi_cmnd* cmd)
809 {
810 adpt_hba* pHba;
811 u32 msg[4];
812 u32 rcode;
813 int old_state;
814 struct adpt_device* d = cmd->device->hostdata;
815
816 pHba = (void*) cmd->device->host->hostdata[0];
817 printk(KERN_INFO"%s: Trying to reset device\n",pHba->name);
818 if (!d) {
819 printk(KERN_INFO"%s: Reset Device: Device Not found\n",pHba->name);
820 return FAILED;
821 }
822 memset(msg, 0, sizeof(msg));
823 msg[0] = FOUR_WORD_MSG_SIZE|SGL_OFFSET_0;
824 msg[1] = (I2O_DEVICE_RESET<<24|HOST_TID<<12|d->tid);
825 msg[2] = 0;
826 msg[3] = 0;
827
828 if (pHba->host)
829 spin_lock_irq(pHba->host->host_lock);
830 old_state = d->state;
831 d->state |= DPTI_DEV_RESET;
832 rcode = adpt_i2o_post_wait(pHba, msg,sizeof(msg), FOREVER);
833 d->state = old_state;
834 if (pHba->host)
835 spin_unlock_irq(pHba->host->host_lock);
836 if (rcode != 0) {
837 if(rcode == -EOPNOTSUPP ){
838 printk(KERN_INFO"%s: Device reset not supported\n",pHba->name);
839 return FAILED;
840 }
841 printk(KERN_INFO"%s: Device reset failed\n",pHba->name);
842 return FAILED;
843 } else {
844 printk(KERN_INFO"%s: Device reset successful\n",pHba->name);
845 return SUCCESS;
846 }
847 }
848
849
850 #define I2O_HBA_BUS_RESET 0x87
851 // This version of bus reset is called by the eh_error handler
852 static int adpt_bus_reset(struct scsi_cmnd* cmd)
853 {
854 adpt_hba* pHba;
855 u32 msg[4];
856 u32 rcode;
857
858 pHba = (adpt_hba*)cmd->device->host->hostdata[0];
859 memset(msg, 0, sizeof(msg));
860 printk(KERN_WARNING"%s: Bus reset: SCSI Bus %d: tid: %d\n",pHba->name, cmd->device->channel,pHba->channel[cmd->device->channel].tid );
861 msg[0] = FOUR_WORD_MSG_SIZE|SGL_OFFSET_0;
862 msg[1] = (I2O_HBA_BUS_RESET<<24|HOST_TID<<12|pHba->channel[cmd->device->channel].tid);
863 msg[2] = 0;
864 msg[3] = 0;
865 if (pHba->host)
866 spin_lock_irq(pHba->host->host_lock);
867 rcode = adpt_i2o_post_wait(pHba, msg,sizeof(msg), FOREVER);
868 if (pHba->host)
869 spin_unlock_irq(pHba->host->host_lock);
870 if (rcode != 0) {
871 printk(KERN_WARNING"%s: Bus reset failed.\n",pHba->name);
872 return FAILED;
873 } else {
874 printk(KERN_WARNING"%s: Bus reset success.\n",pHba->name);
875 return SUCCESS;
876 }
877 }
878
879 // This version of reset is called by the eh_error_handler
880 static int __adpt_reset(struct scsi_cmnd* cmd)
881 {
882 adpt_hba* pHba;
883 int rcode;
884 pHba = (adpt_hba*)cmd->device->host->hostdata[0];
885 printk(KERN_WARNING"%s: Hba Reset: scsi id %d: tid: %d\n",pHba->name,cmd->device->channel,pHba->channel[cmd->device->channel].tid );
886 rcode = adpt_hba_reset(pHba);
887 if(rcode == 0){
888 printk(KERN_WARNING"%s: HBA reset complete\n",pHba->name);
889 return SUCCESS;
890 } else {
891 printk(KERN_WARNING"%s: HBA reset failed (%x)\n",pHba->name, rcode);
892 return FAILED;
893 }
894 }
895
896 static int adpt_reset(struct scsi_cmnd* cmd)
897 {
898 int rc;
899
900 spin_lock_irq(cmd->device->host->host_lock);
901 rc = __adpt_reset(cmd);
902 spin_unlock_irq(cmd->device->host->host_lock);
903
904 return rc;
905 }
906
907 // This version of reset is called by the ioctls and indirectly from eh_error_handler via adpt_reset
908 static int adpt_hba_reset(adpt_hba* pHba)
909 {
910 int rcode;
911
912 pHba->state |= DPTI_STATE_RESET;
913
914 // Activate does get status , init outbound, and get hrt
915 if ((rcode=adpt_i2o_activate_hba(pHba)) < 0) {
916 printk(KERN_ERR "%s: Could not activate\n", pHba->name);
917 adpt_i2o_delete_hba(pHba);
918 return rcode;
919 }
920
921 if ((rcode=adpt_i2o_build_sys_table()) < 0) {
922 adpt_i2o_delete_hba(pHba);
923 return rcode;
924 }
925 PDEBUG("%s: in HOLD state\n",pHba->name);
926
927 if ((rcode=adpt_i2o_online_hba(pHba)) < 0) {
928 adpt_i2o_delete_hba(pHba);
929 return rcode;
930 }
931 PDEBUG("%s: in OPERATIONAL state\n",pHba->name);
932
933 if ((rcode=adpt_i2o_lct_get(pHba)) < 0){
934 adpt_i2o_delete_hba(pHba);
935 return rcode;
936 }
937
938 if ((rcode=adpt_i2o_reparse_lct(pHba)) < 0){
939 adpt_i2o_delete_hba(pHba);
940 return rcode;
941 }
942 pHba->state &= ~DPTI_STATE_RESET;
943
944 adpt_fail_posted_scbs(pHba);
945 return 0; /* return success */
946 }
947
948 /*===========================================================================
949 *
950 *===========================================================================
951 */
952
953
954 static void adpt_i2o_sys_shutdown(void)
955 {
956 adpt_hba *pHba, *pNext;
957 struct adpt_i2o_post_wait_data *p1, *old;
958
959 printk(KERN_INFO"Shutting down Adaptec I2O controllers.\n");
960 printk(KERN_INFO" This could take a few minutes if there are many devices attached\n");
961 /* Delete all IOPs from the controller chain */
962 /* They should have already been released by the
963 * scsi-core
964 */
965 for (pHba = hba_chain; pHba; pHba = pNext) {
966 pNext = pHba->next;
967 adpt_i2o_delete_hba(pHba);
968 }
969
970 /* Remove any timedout entries from the wait queue. */
971 // spin_lock_irqsave(&adpt_post_wait_lock, flags);
972 /* Nothing should be outstanding at this point so just
973 * free them
974 */
975 for(p1 = adpt_post_wait_queue; p1;) {
976 old = p1;
977 p1 = p1->next;
978 kfree(old);
979 }
980 // spin_unlock_irqrestore(&adpt_post_wait_lock, flags);
981 adpt_post_wait_queue = NULL;
982
983 printk(KERN_INFO "Adaptec I2O controllers down.\n");
984 }
985
986 static int adpt_install_hba(struct scsi_host_template* sht, struct pci_dev* pDev)
987 {
988
989 adpt_hba* pHba = NULL;
990 adpt_hba* p = NULL;
991 ulong base_addr0_phys = 0;
992 ulong base_addr1_phys = 0;
993 u32 hba_map0_area_size = 0;
994 u32 hba_map1_area_size = 0;
995 void __iomem *base_addr_virt = NULL;
996 void __iomem *msg_addr_virt = NULL;
997 int dma64 = 0;
998
999 int raptorFlag = FALSE;
1000
1001 if(pci_enable_device(pDev)) {
1002 return -EINVAL;
1003 }
1004
1005 if (pci_request_regions(pDev, "dpt_i2o")) {
1006 PERROR("dpti: adpt_config_hba: pci request region failed\n");
1007 return -EINVAL;
1008 }
1009
1010 pci_set_master(pDev);
1011
1012 /*
1013 * See if we should enable dma64 mode.
1014 */
1015 if (sizeof(dma_addr_t) > 4 &&
1016 pci_set_dma_mask(pDev, DMA_64BIT_MASK) == 0) {
1017 if (dma_get_required_mask(&pDev->dev) > DMA_32BIT_MASK)
1018 dma64 = 1;
1019 }
1020 if (!dma64 && pci_set_dma_mask(pDev, DMA_32BIT_MASK) != 0)
1021 return -EINVAL;
1022
1023 /* adapter only supports message blocks below 4GB */
1024 pci_set_consistent_dma_mask(pDev, DMA_32BIT_MASK);
1025
1026 base_addr0_phys = pci_resource_start(pDev,0);
1027 hba_map0_area_size = pci_resource_len(pDev,0);
1028
1029 // Check if standard PCI card or single BAR Raptor
1030 if(pDev->device == PCI_DPT_DEVICE_ID){
1031 if(pDev->subsystem_device >=0xc032 && pDev->subsystem_device <= 0xc03b){
1032 // Raptor card with this device id needs 4M
1033 hba_map0_area_size = 0x400000;
1034 } else { // Not Raptor - it is a PCI card
1035 if(hba_map0_area_size > 0x100000 ){
1036 hba_map0_area_size = 0x100000;
1037 }
1038 }
1039 } else {// Raptor split BAR config
1040 // Use BAR1 in this configuration
1041 base_addr1_phys = pci_resource_start(pDev,1);
1042 hba_map1_area_size = pci_resource_len(pDev,1);
1043 raptorFlag = TRUE;
1044 }
1045
1046 #if BITS_PER_LONG == 64
1047 /*
1048 * The original Adaptec 64 bit driver has this comment here:
1049 * "x86_64 machines need more optimal mappings"
1050 *
1051 * I assume some HBAs report ridiculously large mappings
1052 * and we need to limit them on platforms with IOMMUs.
1053 */
1054 if (raptorFlag == TRUE) {
1055 if (hba_map0_area_size > 128)
1056 hba_map0_area_size = 128;
1057 if (hba_map1_area_size > 524288)
1058 hba_map1_area_size = 524288;
1059 } else {
1060 if (hba_map0_area_size > 524288)
1061 hba_map0_area_size = 524288;
1062 }
1063 #endif
1064
1065 base_addr_virt = ioremap(base_addr0_phys,hba_map0_area_size);
1066 if (!base_addr_virt) {
1067 pci_release_regions(pDev);
1068 PERROR("dpti: adpt_config_hba: io remap failed\n");
1069 return -EINVAL;
1070 }
1071
1072 if(raptorFlag == TRUE) {
1073 msg_addr_virt = ioremap(base_addr1_phys, hba_map1_area_size );
1074 if (!msg_addr_virt) {
1075 PERROR("dpti: adpt_config_hba: io remap failed on BAR1\n");
1076 iounmap(base_addr_virt);
1077 pci_release_regions(pDev);
1078 return -EINVAL;
1079 }
1080 } else {
1081 msg_addr_virt = base_addr_virt;
1082 }
1083
1084 // Allocate and zero the data structure
1085 pHba = kzalloc(sizeof(adpt_hba), GFP_KERNEL);
1086 if (!pHba) {
1087 if (msg_addr_virt != base_addr_virt)
1088 iounmap(msg_addr_virt);
1089 iounmap(base_addr_virt);
1090 pci_release_regions(pDev);
1091 return -ENOMEM;
1092 }
1093
1094 mutex_lock(&adpt_configuration_lock);
1095
1096 if(hba_chain != NULL){
1097 for(p = hba_chain; p->next; p = p->next);
1098 p->next = pHba;
1099 } else {
1100 hba_chain = pHba;
1101 }
1102 pHba->next = NULL;
1103 pHba->unit = hba_count;
1104 sprintf(pHba->name, "dpti%d", hba_count);
1105 hba_count++;
1106
1107 mutex_unlock(&adpt_configuration_lock);
1108
1109 pHba->pDev = pDev;
1110 pHba->base_addr_phys = base_addr0_phys;
1111
1112 // Set up the Virtual Base Address of the I2O Device
1113 pHba->base_addr_virt = base_addr_virt;
1114 pHba->msg_addr_virt = msg_addr_virt;
1115 pHba->irq_mask = base_addr_virt+0x30;
1116 pHba->post_port = base_addr_virt+0x40;
1117 pHba->reply_port = base_addr_virt+0x44;
1118
1119 pHba->hrt = NULL;
1120 pHba->lct = NULL;
1121 pHba->lct_size = 0;
1122 pHba->status_block = NULL;
1123 pHba->post_count = 0;
1124 pHba->state = DPTI_STATE_RESET;
1125 pHba->pDev = pDev;
1126 pHba->devices = NULL;
1127 pHba->dma64 = dma64;
1128
1129 // Initializing the spinlocks
1130 spin_lock_init(&pHba->state_lock);
1131 spin_lock_init(&adpt_post_wait_lock);
1132
1133 if(raptorFlag == 0){
1134 printk(KERN_INFO "Adaptec I2O RAID controller"
1135 " %d at %p size=%x irq=%d%s\n",
1136 hba_count-1, base_addr_virt,
1137 hba_map0_area_size, pDev->irq,
1138 dma64 ? " (64-bit DMA)" : "");
1139 } else {
1140 printk(KERN_INFO"Adaptec I2O RAID controller %d irq=%d%s\n",
1141 hba_count-1, pDev->irq,
1142 dma64 ? " (64-bit DMA)" : "");
1143 printk(KERN_INFO" BAR0 %p - size= %x\n",base_addr_virt,hba_map0_area_size);
1144 printk(KERN_INFO" BAR1 %p - size= %x\n",msg_addr_virt,hba_map1_area_size);
1145 }
1146
1147 if (request_irq (pDev->irq, adpt_isr, IRQF_SHARED, pHba->name, pHba)) {
1148 printk(KERN_ERR"%s: Couldn't register IRQ %d\n", pHba->name, pDev->irq);
1149 adpt_i2o_delete_hba(pHba);
1150 return -EINVAL;
1151 }
1152
1153 return 0;
1154 }
1155
1156
1157 static void adpt_i2o_delete_hba(adpt_hba* pHba)
1158 {
1159 adpt_hba* p1;
1160 adpt_hba* p2;
1161 struct i2o_device* d;
1162 struct i2o_device* next;
1163 int i;
1164 int j;
1165 struct adpt_device* pDev;
1166 struct adpt_device* pNext;
1167
1168
1169 mutex_lock(&adpt_configuration_lock);
1170 // scsi_unregister calls our adpt_release which
1171 // does a quiese
1172 if(pHba->host){
1173 free_irq(pHba->host->irq, pHba);
1174 }
1175 p2 = NULL;
1176 for( p1 = hba_chain; p1; p2 = p1,p1=p1->next){
1177 if(p1 == pHba) {
1178 if(p2) {
1179 p2->next = p1->next;
1180 } else {
1181 hba_chain = p1->next;
1182 }
1183 break;
1184 }
1185 }
1186
1187 hba_count--;
1188 mutex_unlock(&adpt_configuration_lock);
1189
1190 iounmap(pHba->base_addr_virt);
1191 pci_release_regions(pHba->pDev);
1192 if(pHba->msg_addr_virt != pHba->base_addr_virt){
1193 iounmap(pHba->msg_addr_virt);
1194 }
1195 if(pHba->FwDebugBuffer_P)
1196 iounmap(pHba->FwDebugBuffer_P);
1197 if(pHba->hrt) {
1198 dma_free_coherent(&pHba->pDev->dev,
1199 pHba->hrt->num_entries * pHba->hrt->entry_len << 2,
1200 pHba->hrt, pHba->hrt_pa);
1201 }
1202 if(pHba->lct) {
1203 dma_free_coherent(&pHba->pDev->dev, pHba->lct_size,
1204 pHba->lct, pHba->lct_pa);
1205 }
1206 if(pHba->status_block) {
1207 dma_free_coherent(&pHba->pDev->dev, sizeof(i2o_status_block),
1208 pHba->status_block, pHba->status_block_pa);
1209 }
1210 if(pHba->reply_pool) {
1211 dma_free_coherent(&pHba->pDev->dev,
1212 pHba->reply_fifo_size * REPLY_FRAME_SIZE * 4,
1213 pHba->reply_pool, pHba->reply_pool_pa);
1214 }
1215
1216 for(d = pHba->devices; d ; d = next){
1217 next = d->next;
1218 kfree(d);
1219 }
1220 for(i = 0 ; i < pHba->top_scsi_channel ; i++){
1221 for(j = 0; j < MAX_ID; j++){
1222 if(pHba->channel[i].device[j] != NULL){
1223 for(pDev = pHba->channel[i].device[j]; pDev; pDev = pNext){
1224 pNext = pDev->next_lun;
1225 kfree(pDev);
1226 }
1227 }
1228 }
1229 }
1230 pci_dev_put(pHba->pDev);
1231 kfree(pHba);
1232
1233 if (adpt_sysfs_class)
1234 device_destroy(adpt_sysfs_class,
1235 MKDEV(DPTI_I2O_MAJOR, pHba->unit));
1236
1237 if(hba_count <= 0){
1238 unregister_chrdev(DPTI_I2O_MAJOR, DPT_DRIVER);
1239 if (adpt_sysfs_class) {
1240 class_destroy(adpt_sysfs_class);
1241 adpt_sysfs_class = NULL;
1242 }
1243 }
1244 }
1245
1246 static struct adpt_device* adpt_find_device(adpt_hba* pHba, u32 chan, u32 id, u32 lun)
1247 {
1248 struct adpt_device* d;
1249
1250 if(chan < 0 || chan >= MAX_CHANNEL)
1251 return NULL;
1252
1253 if( pHba->channel[chan].device == NULL){
1254 printk(KERN_DEBUG"Adaptec I2O RAID: Trying to find device before they are allocated\n");
1255 return NULL;
1256 }
1257
1258 d = pHba->channel[chan].device[id];
1259 if(!d || d->tid == 0) {
1260 return NULL;
1261 }
1262
1263 /* If it is the only lun at that address then this should match*/
1264 if(d->scsi_lun == lun){
1265 return d;
1266 }
1267
1268 /* else we need to look through all the luns */
1269 for(d=d->next_lun ; d ; d = d->next_lun){
1270 if(d->scsi_lun == lun){
1271 return d;
1272 }
1273 }
1274 return NULL;
1275 }
1276
1277
1278 static int adpt_i2o_post_wait(adpt_hba* pHba, u32* msg, int len, int timeout)
1279 {
1280 // I used my own version of the WAIT_QUEUE_HEAD
1281 // to handle some version differences
1282 // When embedded in the kernel this could go back to the vanilla one
1283 ADPT_DECLARE_WAIT_QUEUE_HEAD(adpt_wq_i2o_post);
1284 int status = 0;
1285 ulong flags = 0;
1286 struct adpt_i2o_post_wait_data *p1, *p2;
1287 struct adpt_i2o_post_wait_data *wait_data =
1288 kmalloc(sizeof(struct adpt_i2o_post_wait_data),GFP_KERNEL);
1289 DECLARE_WAITQUEUE(wait, current);
1290
1291 if (!wait_data)
1292 return -ENOMEM;
1293
1294 /*
1295 * The spin locking is needed to keep anyone from playing
1296 * with the queue pointers and id while we do the same
1297 */
1298 spin_lock_irqsave(&adpt_post_wait_lock, flags);
1299 // TODO we need a MORE unique way of getting ids
1300 // to support async LCT get
1301 wait_data->next = adpt_post_wait_queue;
1302 adpt_post_wait_queue = wait_data;
1303 adpt_post_wait_id++;
1304 adpt_post_wait_id &= 0x7fff;
1305 wait_data->id = adpt_post_wait_id;
1306 spin_unlock_irqrestore(&adpt_post_wait_lock, flags);
1307
1308 wait_data->wq = &adpt_wq_i2o_post;
1309 wait_data->status = -ETIMEDOUT;
1310
1311 add_wait_queue(&adpt_wq_i2o_post, &wait);
1312
1313 msg[2] |= 0x80000000 | ((u32)wait_data->id);
1314 timeout *= HZ;
1315 if((status = adpt_i2o_post_this(pHba, msg, len)) == 0){
1316 set_current_state(TASK_INTERRUPTIBLE);
1317 if(pHba->host)
1318 spin_unlock_irq(pHba->host->host_lock);
1319 if (!timeout)
1320 schedule();
1321 else{
1322 timeout = schedule_timeout(timeout);
1323 if (timeout == 0) {
1324 // I/O issued, but cannot get result in
1325 // specified time. Freeing resorces is
1326 // dangerous.
1327 status = -ETIME;
1328 }
1329 }
1330 if(pHba->host)
1331 spin_lock_irq(pHba->host->host_lock);
1332 }
1333 remove_wait_queue(&adpt_wq_i2o_post, &wait);
1334
1335 if(status == -ETIMEDOUT){
1336 printk(KERN_INFO"dpti%d: POST WAIT TIMEOUT\n",pHba->unit);
1337 // We will have to free the wait_data memory during shutdown
1338 return status;
1339 }
1340
1341 /* Remove the entry from the queue. */
1342 p2 = NULL;
1343 spin_lock_irqsave(&adpt_post_wait_lock, flags);
1344 for(p1 = adpt_post_wait_queue; p1; p2 = p1, p1 = p1->next) {
1345 if(p1 == wait_data) {
1346 if(p1->status == I2O_DETAIL_STATUS_UNSUPPORTED_FUNCTION ) {
1347 status = -EOPNOTSUPP;
1348 }
1349 if(p2) {
1350 p2->next = p1->next;
1351 } else {
1352 adpt_post_wait_queue = p1->next;
1353 }
1354 break;
1355 }
1356 }
1357 spin_unlock_irqrestore(&adpt_post_wait_lock, flags);
1358
1359 kfree(wait_data);
1360
1361 return status;
1362 }
1363
1364
1365 static s32 adpt_i2o_post_this(adpt_hba* pHba, u32* data, int len)
1366 {
1367
1368 u32 m = EMPTY_QUEUE;
1369 u32 __iomem *msg;
1370 ulong timeout = jiffies + 30*HZ;
1371 do {
1372 rmb();
1373 m = readl(pHba->post_port);
1374 if (m != EMPTY_QUEUE) {
1375 break;
1376 }
1377 if(time_after(jiffies,timeout)){
1378 printk(KERN_WARNING"dpti%d: Timeout waiting for message frame!\n", pHba->unit);
1379 return -ETIMEDOUT;
1380 }
1381 schedule_timeout_uninterruptible(1);
1382 } while(m == EMPTY_QUEUE);
1383
1384 msg = pHba->msg_addr_virt + m;
1385 memcpy_toio(msg, data, len);
1386 wmb();
1387
1388 //post message
1389 writel(m, pHba->post_port);
1390 wmb();
1391
1392 return 0;
1393 }
1394
1395
1396 static void adpt_i2o_post_wait_complete(u32 context, int status)
1397 {
1398 struct adpt_i2o_post_wait_data *p1 = NULL;
1399 /*
1400 * We need to search through the adpt_post_wait
1401 * queue to see if the given message is still
1402 * outstanding. If not, it means that the IOP
1403 * took longer to respond to the message than we
1404 * had allowed and timer has already expired.
1405 * Not much we can do about that except log
1406 * it for debug purposes, increase timeout, and recompile
1407 *
1408 * Lock needed to keep anyone from moving queue pointers
1409 * around while we're looking through them.
1410 */
1411
1412 context &= 0x7fff;
1413
1414 spin_lock(&adpt_post_wait_lock);
1415 for(p1 = adpt_post_wait_queue; p1; p1 = p1->next) {
1416 if(p1->id == context) {
1417 p1->status = status;
1418 spin_unlock(&adpt_post_wait_lock);
1419 wake_up_interruptible(p1->wq);
1420 return;
1421 }
1422 }
1423 spin_unlock(&adpt_post_wait_lock);
1424 // If this happens we lose commands that probably really completed
1425 printk(KERN_DEBUG"dpti: Could Not find task %d in wait queue\n",context);
1426 printk(KERN_DEBUG" Tasks in wait queue:\n");
1427 for(p1 = adpt_post_wait_queue; p1; p1 = p1->next) {
1428 printk(KERN_DEBUG" %d\n",p1->id);
1429 }
1430 return;
1431 }
1432
1433 static s32 adpt_i2o_reset_hba(adpt_hba* pHba)
1434 {
1435 u32 msg[8];
1436 u8* status;
1437 dma_addr_t addr;
1438 u32 m = EMPTY_QUEUE ;
1439 ulong timeout = jiffies + (TMOUT_IOPRESET*HZ);
1440
1441 if(pHba->initialized == FALSE) { // First time reset should be quick
1442 timeout = jiffies + (25*HZ);
1443 } else {
1444 adpt_i2o_quiesce_hba(pHba);
1445 }
1446
1447 do {
1448 rmb();
1449 m = readl(pHba->post_port);
1450 if (m != EMPTY_QUEUE) {
1451 break;
1452 }
1453 if(time_after(jiffies,timeout)){
1454 printk(KERN_WARNING"Timeout waiting for message!\n");
1455 return -ETIMEDOUT;
1456 }
1457 schedule_timeout_uninterruptible(1);
1458 } while (m == EMPTY_QUEUE);
1459
1460 status = dma_alloc_coherent(&pHba->pDev->dev, 4, &addr, GFP_KERNEL);
1461 if(status == NULL) {
1462 adpt_send_nop(pHba, m);
1463 printk(KERN_ERR"IOP reset failed - no free memory.\n");
1464 return -ENOMEM;
1465 }
1466 memset(status,0,4);
1467
1468 msg[0]=EIGHT_WORD_MSG_SIZE|SGL_OFFSET_0;
1469 msg[1]=I2O_CMD_ADAPTER_RESET<<24|HOST_TID<<12|ADAPTER_TID;
1470 msg[2]=0;
1471 msg[3]=0;
1472 msg[4]=0;
1473 msg[5]=0;
1474 msg[6]=dma_low(addr);
1475 msg[7]=dma_high(addr);
1476
1477 memcpy_toio(pHba->msg_addr_virt+m, msg, sizeof(msg));
1478 wmb();
1479 writel(m, pHba->post_port);
1480 wmb();
1481
1482 while(*status == 0){
1483 if(time_after(jiffies,timeout)){
1484 printk(KERN_WARNING"%s: IOP Reset Timeout\n",pHba->name);
1485 /* We lose 4 bytes of "status" here, but we cannot
1486 free these because controller may awake and corrupt
1487 those bytes at any time */
1488 /* dma_free_coherent(&pHba->pDev->dev, 4, buf, addr); */
1489 return -ETIMEDOUT;
1490 }
1491 rmb();
1492 schedule_timeout_uninterruptible(1);
1493 }
1494
1495 if(*status == 0x01 /*I2O_EXEC_IOP_RESET_IN_PROGRESS*/) {
1496 PDEBUG("%s: Reset in progress...\n", pHba->name);
1497 // Here we wait for message frame to become available
1498 // indicated that reset has finished
1499 do {
1500 rmb();
1501 m = readl(pHba->post_port);
1502 if (m != EMPTY_QUEUE) {
1503 break;
1504 }
1505 if(time_after(jiffies,timeout)){
1506 printk(KERN_ERR "%s:Timeout waiting for IOP Reset.\n",pHba->name);
1507 /* We lose 4 bytes of "status" here, but we
1508 cannot free these because controller may
1509 awake and corrupt those bytes at any time */
1510 /* dma_free_coherent(&pHba->pDev->dev, 4, buf, addr); */
1511 return -ETIMEDOUT;
1512 }
1513 schedule_timeout_uninterruptible(1);
1514 } while (m == EMPTY_QUEUE);
1515 // Flush the offset
1516 adpt_send_nop(pHba, m);
1517 }
1518 adpt_i2o_status_get(pHba);
1519 if(*status == 0x02 ||
1520 pHba->status_block->iop_state != ADAPTER_STATE_RESET) {
1521 printk(KERN_WARNING"%s: Reset reject, trying to clear\n",
1522 pHba->name);
1523 } else {
1524 PDEBUG("%s: Reset completed.\n", pHba->name);
1525 }
1526
1527 dma_free_coherent(&pHba->pDev->dev, 4, status, addr);
1528 #ifdef UARTDELAY
1529 // This delay is to allow someone attached to the card through the debug UART to
1530 // set up the dump levels that they want before the rest of the initialization sequence
1531 adpt_delay(20000);
1532 #endif
1533 return 0;
1534 }
1535
1536
1537 static int adpt_i2o_parse_lct(adpt_hba* pHba)
1538 {
1539 int i;
1540 int max;
1541 int tid;
1542 struct i2o_device *d;
1543 i2o_lct *lct = pHba->lct;
1544 u8 bus_no = 0;
1545 s16 scsi_id;
1546 s16 scsi_lun;
1547 u32 buf[10]; // larger than 7, or 8 ...
1548 struct adpt_device* pDev;
1549
1550 if (lct == NULL) {
1551 printk(KERN_ERR "%s: LCT is empty???\n",pHba->name);
1552 return -1;
1553 }
1554
1555 max = lct->table_size;
1556 max -= 3;
1557 max /= 9;
1558
1559 for(i=0;i<max;i++) {
1560 if( lct->lct_entry[i].user_tid != 0xfff){
1561 /*
1562 * If we have hidden devices, we need to inform the upper layers about
1563 * the possible maximum id reference to handle device access when
1564 * an array is disassembled. This code has no other purpose but to
1565 * allow us future access to devices that are currently hidden
1566 * behind arrays, hotspares or have not been configured (JBOD mode).
1567 */
1568 if( lct->lct_entry[i].class_id != I2O_CLASS_RANDOM_BLOCK_STORAGE &&
1569 lct->lct_entry[i].class_id != I2O_CLASS_SCSI_PERIPHERAL &&
1570 lct->lct_entry[i].class_id != I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL ){
1571 continue;
1572 }
1573 tid = lct->lct_entry[i].tid;
1574 // I2O_DPT_DEVICE_INFO_GROUP_NO;
1575 if(adpt_i2o_query_scalar(pHba, tid, 0x8000, -1, buf, 32)<0) {
1576 continue;
1577 }
1578 bus_no = buf[0]>>16;
1579 scsi_id = buf[1];
1580 scsi_lun = (buf[2]>>8 )&0xff;
1581 if(bus_no >= MAX_CHANNEL) { // Something wrong skip it
1582 printk(KERN_WARNING"%s: Channel number %d out of range \n", pHba->name, bus_no);
1583 continue;
1584 }
1585 if (scsi_id >= MAX_ID){
1586 printk(KERN_WARNING"%s: SCSI ID %d out of range \n", pHba->name, bus_no);
1587 continue;
1588 }
1589 if(bus_no > pHba->top_scsi_channel){
1590 pHba->top_scsi_channel = bus_no;
1591 }
1592 if(scsi_id > pHba->top_scsi_id){
1593 pHba->top_scsi_id = scsi_id;
1594 }
1595 if(scsi_lun > pHba->top_scsi_lun){
1596 pHba->top_scsi_lun = scsi_lun;
1597 }
1598 continue;
1599 }
1600 d = kmalloc(sizeof(struct i2o_device), GFP_KERNEL);
1601 if(d==NULL)
1602 {
1603 printk(KERN_CRIT"%s: Out of memory for I2O device data.\n",pHba->name);
1604 return -ENOMEM;
1605 }
1606
1607 d->controller = pHba;
1608 d->next = NULL;
1609
1610 memcpy(&d->lct_data, &lct->lct_entry[i], sizeof(i2o_lct_entry));
1611
1612 d->flags = 0;
1613 tid = d->lct_data.tid;
1614 adpt_i2o_report_hba_unit(pHba, d);
1615 adpt_i2o_install_device(pHba, d);
1616 }
1617 bus_no = 0;
1618 for(d = pHba->devices; d ; d = d->next) {
1619 if(d->lct_data.class_id == I2O_CLASS_BUS_ADAPTER_PORT ||
1620 d->lct_data.class_id == I2O_CLASS_FIBRE_CHANNEL_PORT){
1621 tid = d->lct_data.tid;
1622 // TODO get the bus_no from hrt-but for now they are in order
1623 //bus_no =
1624 if(bus_no > pHba->top_scsi_channel){
1625 pHba->top_scsi_channel = bus_no;
1626 }
1627 pHba->channel[bus_no].type = d->lct_data.class_id;
1628 pHba->channel[bus_no].tid = tid;
1629 if(adpt_i2o_query_scalar(pHba, tid, 0x0200, -1, buf, 28)>=0)
1630 {
1631 pHba->channel[bus_no].scsi_id = buf[1];
1632 PDEBUG("Bus %d - SCSI ID %d.\n", bus_no, buf[1]);
1633 }
1634 // TODO remove - this is just until we get from hrt
1635 bus_no++;
1636 if(bus_no >= MAX_CHANNEL) { // Something wrong skip it
1637 printk(KERN_WARNING"%s: Channel number %d out of range - LCT\n", pHba->name, bus_no);
1638 break;
1639 }
1640 }
1641 }
1642
1643 // Setup adpt_device table
1644 for(d = pHba->devices; d ; d = d->next) {
1645 if(d->lct_data.class_id == I2O_CLASS_RANDOM_BLOCK_STORAGE ||
1646 d->lct_data.class_id == I2O_CLASS_SCSI_PERIPHERAL ||
1647 d->lct_data.class_id == I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL ){
1648
1649 tid = d->lct_data.tid;
1650 scsi_id = -1;
1651 // I2O_DPT_DEVICE_INFO_GROUP_NO;
1652 if(adpt_i2o_query_scalar(pHba, tid, 0x8000, -1, buf, 32)>=0) {
1653 bus_no = buf[0]>>16;
1654 scsi_id = buf[1];
1655 scsi_lun = (buf[2]>>8 )&0xff;
1656 if(bus_no >= MAX_CHANNEL) { // Something wrong skip it
1657 continue;
1658 }
1659 if (scsi_id >= MAX_ID) {
1660 continue;
1661 }
1662 if( pHba->channel[bus_no].device[scsi_id] == NULL){
1663 pDev = kzalloc(sizeof(struct adpt_device),GFP_KERNEL);
1664 if(pDev == NULL) {
1665 return -ENOMEM;
1666 }
1667 pHba->channel[bus_no].device[scsi_id] = pDev;
1668 } else {
1669 for( pDev = pHba->channel[bus_no].device[scsi_id];
1670 pDev->next_lun; pDev = pDev->next_lun){
1671 }
1672 pDev->next_lun = kzalloc(sizeof(struct adpt_device),GFP_KERNEL);
1673 if(pDev->next_lun == NULL) {
1674 return -ENOMEM;
1675 }
1676 pDev = pDev->next_lun;
1677 }
1678 pDev->tid = tid;
1679 pDev->scsi_channel = bus_no;
1680 pDev->scsi_id = scsi_id;
1681 pDev->scsi_lun = scsi_lun;
1682 pDev->pI2o_dev = d;
1683 d->owner = pDev;
1684 pDev->type = (buf[0])&0xff;
1685 pDev->flags = (buf[0]>>8)&0xff;
1686 if(scsi_id > pHba->top_scsi_id){
1687 pHba->top_scsi_id = scsi_id;
1688 }
1689 if(scsi_lun > pHba->top_scsi_lun){
1690 pHba->top_scsi_lun = scsi_lun;
1691 }
1692 }
1693 if(scsi_id == -1){
1694 printk(KERN_WARNING"Could not find SCSI ID for %s\n",
1695 d->lct_data.identity_tag);
1696 }
1697 }
1698 }
1699 return 0;
1700 }
1701
1702
1703 /*
1704 * Each I2O controller has a chain of devices on it - these match
1705 * the useful parts of the LCT of the board.
1706 */
1707
1708 static int adpt_i2o_install_device(adpt_hba* pHba, struct i2o_device *d)
1709 {
1710 mutex_lock(&adpt_configuration_lock);
1711 d->controller=pHba;
1712 d->owner=NULL;
1713 d->next=pHba->devices;
1714 d->prev=NULL;
1715 if (pHba->devices != NULL){
1716 pHba->devices->prev=d;
1717 }
1718 pHba->devices=d;
1719 *d->dev_name = 0;
1720
1721 mutex_unlock(&adpt_configuration_lock);
1722 return 0;
1723 }
1724
1725 static int adpt_open(struct inode *inode, struct file *file)
1726 {
1727 int minor;
1728 adpt_hba* pHba;
1729
1730 //TODO check for root access
1731 //
1732 minor = iminor(inode);
1733 if (minor >= hba_count) {
1734 return -ENXIO;
1735 }
1736 mutex_lock(&adpt_configuration_lock);
1737 for (pHba = hba_chain; pHba; pHba = pHba->next) {
1738 if (pHba->unit == minor) {
1739 break; /* found adapter */
1740 }
1741 }
1742 if (pHba == NULL) {
1743 mutex_unlock(&adpt_configuration_lock);
1744 return -ENXIO;
1745 }
1746
1747 // if(pHba->in_use){
1748 // mutex_unlock(&adpt_configuration_lock);
1749 // return -EBUSY;
1750 // }
1751
1752 pHba->in_use = 1;
1753 mutex_unlock(&adpt_configuration_lock);
1754
1755 return 0;
1756 }
1757
1758 static int adpt_close(struct inode *inode, struct file *file)
1759 {
1760 int minor;
1761 adpt_hba* pHba;
1762
1763 minor = iminor(inode);
1764 if (minor >= hba_count) {
1765 return -ENXIO;
1766 }
1767 mutex_lock(&adpt_configuration_lock);
1768 for (pHba = hba_chain; pHba; pHba = pHba->next) {
1769 if (pHba->unit == minor) {
1770 break; /* found adapter */
1771 }
1772 }
1773 mutex_unlock(&adpt_configuration_lock);
1774 if (pHba == NULL) {
1775 return -ENXIO;
1776 }
1777
1778 pHba->in_use = 0;
1779
1780 return 0;
1781 }
1782
1783
1784 static int adpt_i2o_passthru(adpt_hba* pHba, u32 __user *arg)
1785 {
1786 u32 msg[MAX_MESSAGE_SIZE];
1787 u32* reply = NULL;
1788 u32 size = 0;
1789 u32 reply_size = 0;
1790 u32 __user *user_msg = arg;
1791 u32 __user * user_reply = NULL;
1792 void *sg_list[pHba->sg_tablesize];
1793 u32 sg_offset = 0;
1794 u32 sg_count = 0;
1795 int sg_index = 0;
1796 u32 i = 0;
1797 u32 rcode = 0;
1798 void *p = NULL;
1799 dma_addr_t addr;
1800 ulong flags = 0;
1801
1802 memset(&msg, 0, MAX_MESSAGE_SIZE*4);
1803 // get user msg size in u32s
1804 if(get_user(size, &user_msg[0])){
1805 return -EFAULT;
1806 }
1807 size = size>>16;
1808
1809 user_reply = &user_msg[size];
1810 if(size > MAX_MESSAGE_SIZE){
1811 return -EFAULT;
1812 }
1813 size *= 4; // Convert to bytes
1814
1815 /* Copy in the user's I2O command */
1816 if(copy_from_user(msg, user_msg, size)) {
1817 return -EFAULT;
1818 }
1819 get_user(reply_size, &user_reply[0]);
1820 reply_size = reply_size>>16;
1821 if(reply_size > REPLY_FRAME_SIZE){
1822 reply_size = REPLY_FRAME_SIZE;
1823 }
1824 reply_size *= 4;
1825 reply = kzalloc(REPLY_FRAME_SIZE*4, GFP_KERNEL);
1826 if(reply == NULL) {
1827 printk(KERN_WARNING"%s: Could not allocate reply buffer\n",pHba->name);
1828 return -ENOMEM;
1829 }
1830 sg_offset = (msg[0]>>4)&0xf;
1831 msg[2] = 0x40000000; // IOCTL context
1832 msg[3] = adpt_ioctl_to_context(pHba, reply);
1833 if (msg[3] == (u32)-1)
1834 return -EBUSY;
1835
1836 memset(sg_list,0, sizeof(sg_list[0])*pHba->sg_tablesize);
1837 if(sg_offset) {
1838 // TODO add 64 bit API
1839 struct sg_simple_element *sg = (struct sg_simple_element*) (msg+sg_offset);
1840 sg_count = (size - sg_offset*4) / sizeof(struct sg_simple_element);
1841 if (sg_count > pHba->sg_tablesize){
1842 printk(KERN_DEBUG"%s:IOCTL SG List too large (%u)\n", pHba->name,sg_count);
1843 kfree (reply);
1844 return -EINVAL;
1845 }
1846
1847 for(i = 0; i < sg_count; i++) {
1848 int sg_size;
1849
1850 if (!(sg[i].flag_count & 0x10000000 /*I2O_SGL_FLAGS_SIMPLE_ADDRESS_ELEMENT*/)) {
1851 printk(KERN_DEBUG"%s:Bad SG element %d - not simple (%x)\n",pHba->name,i, sg[i].flag_count);
1852 rcode = -EINVAL;
1853 goto cleanup;
1854 }
1855 sg_size = sg[i].flag_count & 0xffffff;
1856 /* Allocate memory for the transfer */
1857 p = dma_alloc_coherent(&pHba->pDev->dev, sg_size, &addr, GFP_KERNEL);
1858 if(!p) {
1859 printk(KERN_DEBUG"%s: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
1860 pHba->name,sg_size,i,sg_count);
1861 rcode = -ENOMEM;
1862 goto cleanup;
1863 }
1864 sg_list[sg_index++] = p; // sglist indexed with input frame, not our internal frame.
1865 /* Copy in the user's SG buffer if necessary */
1866 if(sg[i].flag_count & 0x04000000 /*I2O_SGL_FLAGS_DIR*/) {
1867 // sg_simple_element API is 32 bit
1868 if (copy_from_user(p,(void __user *)(ulong)sg[i].addr_bus, sg_size)) {
1869 printk(KERN_DEBUG"%s: Could not copy SG buf %d FROM user\n",pHba->name,i);
1870 rcode = -EFAULT;
1871 goto cleanup;
1872 }
1873 }
1874 /* sg_simple_element API is 32 bit, but addr < 4GB */
1875 sg[i].addr_bus = addr;
1876 }
1877 }
1878
1879 do {
1880 if(pHba->host)
1881 spin_lock_irqsave(pHba->host->host_lock, flags);
1882 // This state stops any new commands from enterring the
1883 // controller while processing the ioctl
1884 // pHba->state |= DPTI_STATE_IOCTL;
1885 // We can't set this now - The scsi subsystem sets host_blocked and
1886 // the queue empties and stops. We need a way to restart the queue
1887 rcode = adpt_i2o_post_wait(pHba, msg, size, FOREVER);
1888 if (rcode != 0)
1889 printk("adpt_i2o_passthru: post wait failed %d %p\n",
1890 rcode, reply);
1891 // pHba->state &= ~DPTI_STATE_IOCTL;
1892 if(pHba->host)
1893 spin_unlock_irqrestore(pHba->host->host_lock, flags);
1894 } while(rcode == -ETIMEDOUT);
1895
1896 if(rcode){
1897 goto cleanup;
1898 }
1899
1900 if(sg_offset) {
1901 /* Copy back the Scatter Gather buffers back to user space */
1902 u32 j;
1903 // TODO add 64 bit API
1904 struct sg_simple_element* sg;
1905 int sg_size;
1906
1907 // re-acquire the original message to handle correctly the sg copy operation
1908 memset(&msg, 0, MAX_MESSAGE_SIZE*4);
1909 // get user msg size in u32s
1910 if(get_user(size, &user_msg[0])){
1911 rcode = -EFAULT;
1912 goto cleanup;
1913 }
1914 size = size>>16;
1915 size *= 4;
1916 /* Copy in the user's I2O command */
1917 if (copy_from_user (msg, user_msg, size)) {
1918 rcode = -EFAULT;
1919 goto cleanup;
1920 }
1921 sg_count = (size - sg_offset*4) / sizeof(struct sg_simple_element);
1922
1923 // TODO add 64 bit API
1924 sg = (struct sg_simple_element*)(msg + sg_offset);
1925 for (j = 0; j < sg_count; j++) {
1926 /* Copy out the SG list to user's buffer if necessary */
1927 if(! (sg[j].flag_count & 0x4000000 /*I2O_SGL_FLAGS_DIR*/)) {
1928 sg_size = sg[j].flag_count & 0xffffff;
1929 // sg_simple_element API is 32 bit
1930 if (copy_to_user((void __user *)(ulong)sg[j].addr_bus,sg_list[j], sg_size)) {
1931 printk(KERN_WARNING"%s: Could not copy %p TO user %x\n",pHba->name, sg_list[j], sg[j].addr_bus);
1932 rcode = -EFAULT;
1933 goto cleanup;
1934 }
1935 }
1936 }
1937 }
1938
1939 /* Copy back the reply to user space */
1940 if (reply_size) {
1941 // we wrote our own values for context - now restore the user supplied ones
1942 if(copy_from_user(reply+2, user_msg+2, sizeof(u32)*2)) {
1943 printk(KERN_WARNING"%s: Could not copy message context FROM user\n",pHba->name);
1944 rcode = -EFAULT;
1945 }
1946 if(copy_to_user(user_reply, reply, reply_size)) {
1947 printk(KERN_WARNING"%s: Could not copy reply TO user\n",pHba->name);
1948 rcode = -EFAULT;
1949 }
1950 }
1951
1952
1953 cleanup:
1954 if (rcode != -ETIME && rcode != -EINTR) {
1955 struct sg_simple_element *sg =
1956 (struct sg_simple_element*) (msg +sg_offset);
1957 kfree (reply);
1958 while(sg_index) {
1959 if(sg_list[--sg_index]) {
1960 dma_free_coherent(&pHba->pDev->dev,
1961 sg[sg_index].flag_count & 0xffffff,
1962 sg_list[sg_index],
1963 sg[sg_index].addr_bus);
1964 }
1965 }
1966 }
1967 return rcode;
1968 }
1969
1970
1971 /*
1972 * This routine returns information about the system. This does not effect
1973 * any logic and if the info is wrong - it doesn't matter.
1974 */
1975
1976 /* Get all the info we can not get from kernel services */
1977 static int adpt_system_info(void __user *buffer)
1978 {
1979 sysInfo_S si;
1980
1981 memset(&si, 0, sizeof(si));
1982
1983 si.osType = OS_LINUX;
1984 si.osMajorVersion = 0;
1985 si.osMinorVersion = 0;
1986 si.osRevision = 0;
1987 si.busType = SI_PCI_BUS;
1988 si.processorFamily = DPTI_sig.dsProcessorFamily;
1989
1990 #if defined __i386__
1991 adpt_i386_info(&si);
1992 #elif defined (__ia64__)
1993 adpt_ia64_info(&si);
1994 #elif defined(__sparc__)
1995 adpt_sparc_info(&si);
1996 #elif defined (__alpha__)
1997 adpt_alpha_info(&si);
1998 #else
1999 si.processorType = 0xff ;
2000 #endif
2001 if(copy_to_user(buffer, &si, sizeof(si))){
2002 printk(KERN_WARNING"dpti: Could not copy buffer TO user\n");
2003 return -EFAULT;
2004 }
2005
2006 return 0;
2007 }
2008
2009 #if defined __ia64__
2010 static void adpt_ia64_info(sysInfo_S* si)
2011 {
2012 // This is all the info we need for now
2013 // We will add more info as our new
2014 // managmenent utility requires it
2015 si->processorType = PROC_IA64;
2016 }
2017 #endif
2018
2019
2020 #if defined __sparc__
2021 static void adpt_sparc_info(sysInfo_S* si)
2022 {
2023 // This is all the info we need for now
2024 // We will add more info as our new
2025 // managmenent utility requires it
2026 si->processorType = PROC_ULTRASPARC;
2027 }
2028 #endif
2029
2030 #if defined __alpha__
2031 static void adpt_alpha_info(sysInfo_S* si)
2032 {
2033 // This is all the info we need for now
2034 // We will add more info as our new
2035 // managmenent utility requires it
2036 si->processorType = PROC_ALPHA;
2037 }
2038 #endif
2039
2040 #if defined __i386__
2041
2042 static void adpt_i386_info(sysInfo_S* si)
2043 {
2044 // This is all the info we need for now
2045 // We will add more info as our new
2046 // managmenent utility requires it
2047 switch (boot_cpu_data.x86) {
2048 case CPU_386:
2049 si->processorType = PROC_386;
2050 break;
2051 case CPU_486:
2052 si->processorType = PROC_486;
2053 break;
2054 case CPU_586:
2055 si->processorType = PROC_PENTIUM;
2056 break;
2057 default: // Just in case
2058 si->processorType = PROC_PENTIUM;
2059 break;
2060 }
2061 }
2062
2063 #endif
2064
2065
2066 static int adpt_ioctl(struct inode *inode, struct file *file, uint cmd,
2067 ulong arg)
2068 {
2069 int minor;
2070 int error = 0;
2071 adpt_hba* pHba;
2072 ulong flags = 0;
2073 void __user *argp = (void __user *)arg;
2074
2075 minor = iminor(inode);
2076 if (minor >= DPTI_MAX_HBA){
2077 return -ENXIO;
2078 }
2079 mutex_lock(&adpt_configuration_lock);
2080 for (pHba = hba_chain; pHba; pHba = pHba->next) {
2081 if (pHba->unit == minor) {
2082 break; /* found adapter */
2083 }
2084 }
2085 mutex_unlock(&adpt_configuration_lock);
2086 if(pHba == NULL){
2087 return -ENXIO;
2088 }
2089
2090 while((volatile u32) pHba->state & DPTI_STATE_RESET )
2091 schedule_timeout_uninterruptible(2);
2092
2093 switch (cmd) {
2094 // TODO: handle 3 cases
2095 case DPT_SIGNATURE:
2096 if (copy_to_user(argp, &DPTI_sig, sizeof(DPTI_sig))) {
2097 return -EFAULT;
2098 }
2099 break;
2100 case I2OUSRCMD:
2101 return adpt_i2o_passthru(pHba, argp);
2102
2103 case DPT_CTRLINFO:{
2104 drvrHBAinfo_S HbaInfo;
2105
2106 #define FLG_OSD_PCI_VALID 0x0001
2107 #define FLG_OSD_DMA 0x0002
2108 #define FLG_OSD_I2O 0x0004
2109 memset(&HbaInfo, 0, sizeof(HbaInfo));
2110 HbaInfo.drvrHBAnum = pHba->unit;
2111 HbaInfo.baseAddr = (ulong) pHba->base_addr_phys;
2112 HbaInfo.blinkState = adpt_read_blink_led(pHba);
2113 HbaInfo.pciBusNum = pHba->pDev->bus->number;
2114 HbaInfo.pciDeviceNum=PCI_SLOT(pHba->pDev->devfn);
2115 HbaInfo.Interrupt = pHba->pDev->irq;
2116 HbaInfo.hbaFlags = FLG_OSD_PCI_VALID | FLG_OSD_DMA | FLG_OSD_I2O;
2117 if(copy_to_user(argp, &HbaInfo, sizeof(HbaInfo))){
2118 printk(KERN_WARNING"%s: Could not copy HbaInfo TO user\n",pHba->name);
2119 return -EFAULT;
2120 }
2121 break;
2122 }
2123 case DPT_SYSINFO:
2124 return adpt_system_info(argp);
2125 case DPT_BLINKLED:{
2126 u32 value;
2127 value = (u32)adpt_read_blink_led(pHba);
2128 if (copy_to_user(argp, &value, sizeof(value))) {
2129 return -EFAULT;
2130 }
2131 break;
2132 }
2133 case I2ORESETCMD:
2134 if(pHba->host)
2135 spin_lock_irqsave(pHba->host->host_lock, flags);
2136 adpt_hba_reset(pHba);
2137 if(pHba->host)
2138 spin_unlock_irqrestore(pHba->host->host_lock, flags);
2139 break;
2140 case I2ORESCANCMD:
2141 adpt_rescan(pHba);
2142 break;
2143 default:
2144 return -EINVAL;
2145 }
2146
2147 return error;
2148 }
2149
2150 #ifdef CONFIG_COMPAT
2151 static long compat_adpt_ioctl(struct file *file,
2152 unsigned int cmd, unsigned long arg)
2153 {
2154 struct inode *inode;
2155 long ret;
2156
2157 inode = file->f_dentry->d_inode;
2158
2159 lock_kernel();
2160
2161 switch(cmd) {
2162 case DPT_SIGNATURE:
2163 case I2OUSRCMD:
2164 case DPT_CTRLINFO:
2165 case DPT_SYSINFO:
2166 case DPT_BLINKLED:
2167 case I2ORESETCMD:
2168 case I2ORESCANCMD:
2169 case (DPT_TARGET_BUSY & 0xFFFF):
2170 case DPT_TARGET_BUSY:
2171 ret = adpt_ioctl(inode, file, cmd, arg);
2172 break;
2173 default:
2174 ret = -ENOIOCTLCMD;
2175 }
2176
2177 unlock_kernel();
2178
2179 return ret;
2180 }
2181 #endif
2182
2183 static irqreturn_t adpt_isr(int irq, void *dev_id)
2184 {
2185 struct scsi_cmnd* cmd;
2186 adpt_hba* pHba = dev_id;
2187 u32 m;
2188 void __iomem *reply;
2189 u32 status=0;
2190 u32 context;
2191 ulong flags = 0;
2192 int handled = 0;
2193
2194 if (pHba == NULL){
2195 printk(KERN_WARNING"adpt_isr: NULL dev_id\n");
2196 return IRQ_NONE;
2197 }
2198 if(pHba->host)
2199 spin_lock_irqsave(pHba->host->host_lock, flags);
2200
2201 while( readl(pHba->irq_mask) & I2O_INTERRUPT_PENDING_B) {
2202 m = readl(pHba->reply_port);
2203 if(m == EMPTY_QUEUE){
2204 // Try twice then give up
2205 rmb();
2206 m = readl(pHba->reply_port);
2207 if(m == EMPTY_QUEUE){
2208 // This really should not happen
2209 printk(KERN_ERR"dpti: Could not get reply frame\n");
2210 goto out;
2211 }
2212 }
2213 if (pHba->reply_pool_pa <= m &&
2214 m < pHba->reply_pool_pa +
2215 (pHba->reply_fifo_size * REPLY_FRAME_SIZE * 4)) {
2216 reply = (u8 *)pHba->reply_pool +
2217 (m - pHba->reply_pool_pa);
2218 } else {
2219 /* Ick, we should *never* be here */
2220 printk(KERN_ERR "dpti: reply frame not from pool\n");
2221 reply = (u8 *)bus_to_virt(m);
2222 }
2223
2224 if (readl(reply) & MSG_FAIL) {
2225 u32 old_m = readl(reply+28);
2226 void __iomem *msg;
2227 u32 old_context;
2228 PDEBUG("%s: Failed message\n",pHba->name);
2229 if(old_m >= 0x100000){
2230 printk(KERN_ERR"%s: Bad preserved MFA (%x)- dropping frame\n",pHba->name,old_m);
2231 writel(m,pHba->reply_port);
2232 continue;
2233 }
2234 // Transaction context is 0 in failed reply frame
2235 msg = pHba->msg_addr_virt + old_m;
2236 old_context = readl(msg+12);
2237 writel(old_context, reply+12);
2238 adpt_send_nop(pHba, old_m);
2239 }
2240 context = readl(reply+8);
2241 if(context & 0x40000000){ // IOCTL
2242 void *p = adpt_ioctl_from_context(pHba, readl(reply+12));
2243 if( p != NULL) {
2244 memcpy_fromio(p, reply, REPLY_FRAME_SIZE * 4);
2245 }
2246 // All IOCTLs will also be post wait
2247 }
2248 if(context & 0x80000000){ // Post wait message
2249 status = readl(reply+16);
2250 if(status >> 24){
2251 status &= 0xffff; /* Get detail status */
2252 } else {
2253 status = I2O_POST_WAIT_OK;
2254 }
2255 if(!(context & 0x40000000)) {
2256 cmd = adpt_cmd_from_context(pHba,
2257 readl(reply+12));
2258 if(cmd != NULL) {
2259 printk(KERN_WARNING"%s: Apparent SCSI cmd in Post Wait Context - cmd=%p context=%x\n", pHba->name, cmd, context);
2260 }
2261 }
2262 adpt_i2o_post_wait_complete(context, status);
2263 } else { // SCSI message
2264 cmd = adpt_cmd_from_context (pHba, readl(reply+12));
2265 if(cmd != NULL){
2266 scsi_dma_unmap(cmd);
2267 if(cmd->serial_number != 0) { // If not timedout
2268 adpt_i2o_to_scsi(reply, cmd);
2269 }
2270 }
2271 }
2272 writel(m, pHba->reply_port);
2273 wmb();
2274 rmb();
2275 }
2276 handled = 1;
2277 out: if(pHba->host)
2278 spin_unlock_irqrestore(pHba->host->host_lock, flags);
2279 return IRQ_RETVAL(handled);
2280 }
2281
2282 static s32 adpt_scsi_to_i2o(adpt_hba* pHba, struct scsi_cmnd* cmd, struct adpt_device* d)
2283 {
2284 int i;
2285 u32 msg[MAX_MESSAGE_SIZE];
2286 u32* mptr;
2287 u32* lptr;
2288 u32 *lenptr;
2289 int direction;
2290 int scsidir;
2291 int nseg;
2292 u32 len;
2293 u32 reqlen;
2294 s32 rcode;
2295 dma_addr_t addr;
2296
2297 memset(msg, 0 , sizeof(msg));
2298 len = scsi_bufflen(cmd);
2299 direction = 0x00000000;
2300
2301 scsidir = 0x00000000; // DATA NO XFER
2302 if(len) {
2303 /*
2304 * Set SCBFlags to indicate if data is being transferred
2305 * in or out, or no data transfer
2306 * Note: Do not have to verify index is less than 0 since
2307 * cmd->cmnd[0] is an unsigned char
2308 */
2309 switch(cmd->sc_data_direction){
2310 case DMA_FROM_DEVICE:
2311 scsidir =0x40000000; // DATA IN (iop<--dev)
2312 break;
2313 case DMA_TO_DEVICE:
2314 direction=0x04000000; // SGL OUT
2315 scsidir =0x80000000; // DATA OUT (iop-->dev)
2316 break;
2317 case DMA_NONE:
2318 break;
2319 case DMA_BIDIRECTIONAL:
2320 scsidir =0x40000000; // DATA IN (iop<--dev)
2321 // Assume In - and continue;
2322 break;
2323 default:
2324 printk(KERN_WARNING"%s: scsi opcode 0x%x not supported.\n",
2325 pHba->name, cmd->cmnd[0]);
2326 cmd->result = (DID_OK <<16) | (INITIATOR_ERROR << 8);
2327 cmd->scsi_done(cmd);
2328 return 0;
2329 }
2330 }
2331 // msg[0] is set later
2332 // I2O_CMD_SCSI_EXEC
2333 msg[1] = ((0xff<<24)|(HOST_TID<<12)|d->tid);
2334 msg[2] = 0;
2335 msg[3] = adpt_cmd_to_context(cmd); /* Want SCSI control block back */
2336 // Our cards use the transaction context as the tag for queueing
2337 // Adaptec/DPT Private stuff
2338 msg[4] = I2O_CMD_SCSI_EXEC|(DPT_ORGANIZATION_ID<<16);
2339 msg[5] = d->tid;
2340 /* Direction, disconnect ok | sense data | simple queue , CDBLen */
2341 // I2O_SCB_FLAG_ENABLE_DISCONNECT |
2342 // I2O_SCB_FLAG_SIMPLE_QUEUE_TAG |
2343 // I2O_SCB_FLAG_SENSE_DATA_IN_MESSAGE;
2344 msg[6] = scsidir|0x20a00000|cmd->cmd_len;
2345
2346 mptr=msg+7;
2347
2348 // Write SCSI command into the message - always 16 byte block
2349 memset(mptr, 0, 16);
2350 memcpy(mptr, cmd->cmnd, cmd->cmd_len);
2351 mptr+=4;
2352 lenptr=mptr++; /* Remember me - fill in when we know */
2353 if (dpt_dma64(pHba)) {
2354 reqlen = 16; // SINGLE SGE
2355 *mptr++ = (0x7C<<24)+(2<<16)+0x02; /* Enable 64 bit */
2356 *mptr++ = 1 << PAGE_SHIFT;
2357 } else {
2358 reqlen = 14; // SINGLE SGE
2359 }
2360 /* Now fill in the SGList and command */
2361
2362 nseg = scsi_dma_map(cmd);
2363 BUG_ON(nseg < 0);
2364 if (nseg) {
2365 struct scatterlist *sg;
2366
2367 len = 0;
2368 scsi_for_each_sg(cmd, sg, nseg, i) {
2369 lptr = mptr;
2370 *mptr++ = direction|0x10000000|sg_dma_len(sg);
2371 len+=sg_dma_len(sg);
2372 addr = sg_dma_address(sg);
2373 *mptr++ = dma_low(addr);
2374 if (dpt_dma64(pHba))
2375 *mptr++ = dma_high(addr);
2376 /* Make this an end of list */
2377 if (i == nseg - 1)
2378 *lptr = direction|0xD0000000|sg_dma_len(sg);
2379 }
2380 reqlen = mptr - msg;
2381 *lenptr = len;
2382
2383 if(cmd->underflow && len != cmd->underflow){
2384 printk(KERN_WARNING"Cmd len %08X Cmd underflow %08X\n",
2385 len, cmd->underflow);
2386 }
2387 } else {
2388 *lenptr = len = 0;
2389 reqlen = 12;
2390 }
2391
2392 /* Stick the headers on */
2393 msg[0] = reqlen<<16 | ((reqlen > 12) ? SGL_OFFSET_12 : SGL_OFFSET_0);
2394
2395 // Send it on it's way
2396 rcode = adpt_i2o_post_this(pHba, msg, reqlen<<2);
2397 if (rcode == 0) {
2398 return 0;
2399 }
2400 return rcode;
2401 }
2402
2403
2404 static s32 adpt_scsi_host_alloc(adpt_hba* pHba, struct scsi_host_template *sht)
2405 {
2406 struct Scsi_Host *host;
2407
2408 host = scsi_host_alloc(sht, sizeof(adpt_hba*));
2409 if (host == NULL) {
2410 printk("%s: scsi_host_alloc returned NULL\n", pHba->name);
2411 return -1;
2412 }
2413 host->hostdata[0] = (unsigned long)pHba;
2414 pHba->host = host;
2415
2416 host->irq = pHba->pDev->irq;
2417 /* no IO ports, so don't have to set host->io_port and
2418 * host->n_io_port
2419 */
2420 host->io_port = 0;
2421 host->n_io_port = 0;
2422 /* see comments in scsi_host.h */
2423 host->max_id = 16;
2424 host->max_lun = 256;
2425 host->max_channel = pHba->top_scsi_channel + 1;
2426 host->cmd_per_lun = 1;
2427 host->unique_id = (u32)sys_tbl_pa + pHba->unit;
2428 host->sg_tablesize = pHba->sg_tablesize;
2429 host->can_queue = pHba->post_fifo_size;
2430
2431 return 0;
2432 }
2433
2434
2435 static s32 adpt_i2o_to_scsi(void __iomem *reply, struct scsi_cmnd* cmd)
2436 {
2437 adpt_hba* pHba;
2438 u32 hba_status;
2439 u32 dev_status;
2440 u32 reply_flags = readl(reply) & 0xff00; // Leave it shifted up 8 bits
2441 // I know this would look cleaner if I just read bytes
2442 // but the model I have been using for all the rest of the
2443 // io is in 4 byte words - so I keep that model
2444 u16 detailed_status = readl(reply+16) &0xffff;
2445 dev_status = (detailed_status & 0xff);
2446 hba_status = detailed_status >> 8;
2447
2448 // calculate resid for sg
2449 scsi_set_resid(cmd, scsi_bufflen(cmd) - readl(reply+5));
2450
2451 pHba = (adpt_hba*) cmd->device->host->hostdata[0];
2452
2453 cmd->sense_buffer[0] = '\0'; // initialize sense valid flag to false
2454
2455 if(!(reply_flags & MSG_FAIL)) {
2456 switch(detailed_status & I2O_SCSI_DSC_MASK) {
2457 case I2O_SCSI_DSC_SUCCESS:
2458 cmd->result = (DID_OK << 16);
2459 // handle underflow
2460 if(readl(reply+5) < cmd->underflow ) {
2461 cmd->result = (DID_ERROR <<16);
2462 printk(KERN_WARNING"%s: SCSI CMD underflow\n",pHba->name);
2463 }
2464 break;
2465 case I2O_SCSI_DSC_REQUEST_ABORTED:
2466 cmd->result = (DID_ABORT << 16);
2467 break;
2468 case I2O_SCSI_DSC_PATH_INVALID:
2469 case I2O_SCSI_DSC_DEVICE_NOT_PRESENT:
2470 case I2O_SCSI_DSC_SELECTION_TIMEOUT:
2471 case I2O_SCSI_DSC_COMMAND_TIMEOUT:
2472 case I2O_SCSI_DSC_NO_ADAPTER:
2473 case I2O_SCSI_DSC_RESOURCE_UNAVAILABLE:
2474 printk(KERN_WARNING"%s: SCSI Timeout-Device (%d,%d,%d) hba status=0x%x, dev status=0x%x, cmd=0x%x\n",
2475 pHba->name, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun, hba_status, dev_status, cmd->cmnd[0]);
2476 cmd->result = (DID_TIME_OUT << 16);
2477 break;
2478 case I2O_SCSI_DSC_ADAPTER_BUSY:
2479 case I2O_SCSI_DSC_BUS_BUSY:
2480 cmd->result = (DID_BUS_BUSY << 16);
2481 break;
2482 case I2O_SCSI_DSC_SCSI_BUS_RESET:
2483 case I2O_SCSI_DSC_BDR_MESSAGE_SENT:
2484 cmd->result = (DID_RESET << 16);
2485 break;
2486 case I2O_SCSI_DSC_PARITY_ERROR_FAILURE:
2487 printk(KERN_WARNING"%s: SCSI CMD parity error\n",pHba->name);
2488 cmd->result = (DID_PARITY << 16);
2489 break;
2490 case I2O_SCSI_DSC_UNABLE_TO_ABORT:
2491 case I2O_SCSI_DSC_COMPLETE_WITH_ERROR:
2492 case I2O_SCSI_DSC_UNABLE_TO_TERMINATE:
2493 case I2O_SCSI_DSC_MR_MESSAGE_RECEIVED:
2494 case I2O_SCSI_DSC_AUTOSENSE_FAILED:
2495 case I2O_SCSI_DSC_DATA_OVERRUN:
2496 case I2O_SCSI_DSC_UNEXPECTED_BUS_FREE:
2497 case I2O_SCSI_DSC_SEQUENCE_FAILURE:
2498 case I2O_SCSI_DSC_REQUEST_LENGTH_ERROR:
2499 case I2O_SCSI_DSC_PROVIDE_FAILURE:
2500 case I2O_SCSI_DSC_REQUEST_TERMINATED:
2501 case I2O_SCSI_DSC_IDE_MESSAGE_SENT:
2502 case I2O_SCSI_DSC_UNACKNOWLEDGED_EVENT:
2503 case I2O_SCSI_DSC_MESSAGE_RECEIVED:
2504 case I2O_SCSI_DSC_INVALID_CDB:
2505 case I2O_SCSI_DSC_LUN_INVALID:
2506 case I2O_SCSI_DSC_SCSI_TID_INVALID:
2507 case I2O_SCSI_DSC_FUNCTION_UNAVAILABLE:
2508 case I2O_SCSI_DSC_NO_NEXUS:
2509 case I2O_SCSI_DSC_CDB_RECEIVED:
2510 case I2O_SCSI_DSC_LUN_ALREADY_ENABLED:
2511 case I2O_SCSI_DSC_QUEUE_FROZEN:
2512 case I2O_SCSI_DSC_REQUEST_INVALID:
2513 default:
2514 printk(KERN_WARNING"%s: SCSI error %0x-Device(%d,%d,%d) hba_status=0x%x, dev_status=0x%x, cmd=0x%x\n",
2515 pHba->name, detailed_status & I2O_SCSI_DSC_MASK, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun,
2516 hba_status, dev_status, cmd->cmnd[0]);
2517 cmd->result = (DID_ERROR << 16);
2518 break;
2519 }
2520
2521 // copy over the request sense data if it was a check
2522 // condition status
2523 if (dev_status == SAM_STAT_CHECK_CONDITION) {
2524 u32 len = min(SCSI_SENSE_BUFFERSIZE, 40);
2525 // Copy over the sense data
2526 memcpy_fromio(cmd->sense_buffer, (reply+28) , len);
2527 if(cmd->sense_buffer[0] == 0x70 /* class 7 */ &&
2528 cmd->sense_buffer[2] == DATA_PROTECT ){
2529 /* This is to handle an array failed */
2530 cmd->result = (DID_TIME_OUT << 16);
2531 printk(KERN_WARNING"%s: SCSI Data Protect-Device (%d,%d,%d) hba_status=0x%x, dev_status=0x%x, cmd=0x%x\n",
2532 pHba->name, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun,
2533 hba_status, dev_status, cmd->cmnd[0]);
2534
2535 }
2536 }
2537 } else {
2538 /* In this condtion we could not talk to the tid
2539 * the card rejected it. We should signal a retry
2540 * for a limitted number of retries.
2541 */
2542 cmd->result = (DID_TIME_OUT << 16);
2543 printk(KERN_WARNING"%s: I2O MSG_FAIL - Device (%d,%d,%d) tid=%d, cmd=0x%x\n",
2544 pHba->name, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun,
2545 ((struct adpt_device*)(cmd->device->hostdata))->tid, cmd->cmnd[0]);
2546 }
2547
2548 cmd->result |= (dev_status);
2549
2550 if(cmd->scsi_done != NULL){
2551 cmd->scsi_done(cmd);
2552 }
2553 return cmd->result;
2554 }
2555
2556
2557 static s32 adpt_rescan(adpt_hba* pHba)
2558 {
2559 s32 rcode;
2560 ulong flags = 0;
2561
2562 if(pHba->host)
2563 spin_lock_irqsave(pHba->host->host_lock, flags);
2564 if ((rcode=adpt_i2o_lct_get(pHba)) < 0)
2565 goto out;
2566 if ((rcode=adpt_i2o_reparse_lct(pHba)) < 0)
2567 goto out;
2568 rcode = 0;
2569 out: if(pHba->host)
2570 spin_unlock_irqrestore(pHba->host->host_lock, flags);
2571 return rcode;
2572 }
2573
2574
2575 static s32 adpt_i2o_reparse_lct(adpt_hba* pHba)
2576 {
2577 int i;
2578 int max;
2579 int tid;
2580 struct i2o_device *d;
2581 i2o_lct *lct = pHba->lct;
2582 u8 bus_no = 0;
2583 s16 scsi_id;
2584 s16 scsi_lun;
2585 u32 buf[10]; // at least 8 u32's
2586 struct adpt_device* pDev = NULL;
2587 struct i2o_device* pI2o_dev = NULL;
2588
2589 if (lct == NULL) {
2590 printk(KERN_ERR "%s: LCT is empty???\n",pHba->name);
2591 return -1;
2592 }
2593
2594 max = lct->table_size;
2595 max -= 3;
2596 max /= 9;
2597
2598 // Mark each drive as unscanned
2599 for (d = pHba->devices; d; d = d->next) {
2600 pDev =(struct adpt_device*) d->owner;
2601 if(!pDev){
2602 continue;
2603 }
2604 pDev->state |= DPTI_DEV_UNSCANNED;
2605 }
2606
2607 printk(KERN_INFO "%s: LCT has %d entries.\n", pHba->name,max);
2608
2609 for(i=0;i<max;i++) {
2610 if( lct->lct_entry[i].user_tid != 0xfff){
2611 continue;
2612 }
2613
2614 if( lct->lct_entry[i].class_id == I2O_CLASS_RANDOM_BLOCK_STORAGE ||
2615 lct->lct_entry[i].class_id == I2O_CLASS_SCSI_PERIPHERAL ||
2616 lct->lct_entry[i].class_id == I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL ){
2617 tid = lct->lct_entry[i].tid;
2618 if(adpt_i2o_query_scalar(pHba, tid, 0x8000, -1, buf, 32)<0) {
2619 printk(KERN_ERR"%s: Could not query device\n",pHba->name);
2620 continue;
2621 }
2622 bus_no = buf[0]>>16;
2623 scsi_id = buf[1];
2624 scsi_lun = (buf[2]>>8 )&0xff;
2625 pDev = pHba->channel[bus_no].device[scsi_id];
2626 /* da lun */
2627 while(pDev) {
2628 if(pDev->scsi_lun == scsi_lun) {
2629 break;
2630 }
2631 pDev = pDev->next_lun;
2632 }
2633 if(!pDev ) { // Something new add it
2634 d = kmalloc(sizeof(struct i2o_device), GFP_KERNEL);
2635 if(d==NULL)
2636 {
2637 printk(KERN_CRIT "Out of memory for I2O device data.\n");
2638 return -ENOMEM;
2639 }
2640
2641 d->controller = pHba;
2642 d->next = NULL;
2643
2644 memcpy(&d->lct_data, &lct->lct_entry[i], sizeof(i2o_lct_entry));
2645
2646 d->flags = 0;
2647 adpt_i2o_report_hba_unit(pHba, d);
2648 adpt_i2o_install_device(pHba, d);
2649
2650 if(bus_no >= MAX_CHANNEL) { // Something wrong skip it
2651 printk(KERN_WARNING"%s: Channel number %d out of range \n", pHba->name, bus_no);
2652 continue;
2653 }
2654 pDev = pHba->channel[bus_no].device[scsi_id];
2655 if( pDev == NULL){
2656 pDev = kzalloc(sizeof(struct adpt_device),GFP_KERNEL);
2657 if(pDev == NULL) {
2658 return -ENOMEM;
2659 }
2660 pHba->channel[bus_no].device[scsi_id] = pDev;
2661 } else {
2662 while (pDev->next_lun) {
2663 pDev = pDev->next_lun;
2664 }
2665 pDev = pDev->next_lun = kzalloc(sizeof(struct adpt_device),GFP_KERNEL);
2666 if(pDev == NULL) {
2667 return -ENOMEM;
2668 }
2669 }
2670 pDev->tid = d->lct_data.tid;
2671 pDev->scsi_channel = bus_no;
2672 pDev->scsi_id = scsi_id;
2673 pDev->scsi_lun = scsi_lun;
2674 pDev->pI2o_dev = d;
2675 d->owner = pDev;
2676 pDev->type = (buf[0])&0xff;
2677 pDev->flags = (buf[0]>>8)&0xff;
2678 // Too late, SCSI system has made up it's mind, but what the hey ...
2679 if(scsi_id > pHba->top_scsi_id){
2680 pHba->top_scsi_id = scsi_id;
2681 }
2682 if(scsi_lun > pHba->top_scsi_lun){
2683 pHba->top_scsi_lun = scsi_lun;
2684 }
2685 continue;
2686 } // end of new i2o device
2687
2688 // We found an old device - check it
2689 while(pDev) {
2690 if(pDev->scsi_lun == scsi_lun) {
2691 if(!scsi_device_online(pDev->pScsi_dev)) {
2692 printk(KERN_WARNING"%s: Setting device (%d,%d,%d) back online\n",
2693 pHba->name,bus_no,scsi_id,scsi_lun);
2694 if (pDev->pScsi_dev) {
2695 scsi_device_set_state(pDev->pScsi_dev, SDEV_RUNNING);
2696 }
2697 }
2698 d = pDev->pI2o_dev;
2699 if(d->lct_data.tid != tid) { // something changed
2700 pDev->tid = tid;
2701 memcpy(&d->lct_data, &lct->lct_entry[i], sizeof(i2o_lct_entry));
2702 if (pDev->pScsi_dev) {
2703 pDev->pScsi_dev->changed = TRUE;
2704 pDev->pScsi_dev->removable = TRUE;
2705 }
2706 }
2707 // Found it - mark it scanned
2708 pDev->state = DPTI_DEV_ONLINE;
2709 break;
2710 }
2711 pDev = pDev->next_lun;
2712 }
2713 }
2714 }
2715 for (pI2o_dev = pHba->devices; pI2o_dev; pI2o_dev = pI2o_dev->next) {
2716 pDev =(struct adpt_device*) pI2o_dev->owner;
2717 if(!pDev){
2718 continue;
2719 }
2720 // Drive offline drives that previously existed but could not be found
2721 // in the LCT table
2722 if (pDev->state & DPTI_DEV_UNSCANNED){
2723 pDev->state = DPTI_DEV_OFFLINE;
2724 printk(KERN_WARNING"%s: Device (%d,%d,%d) offline\n",pHba->name,pDev->scsi_channel,pDev->scsi_id,pDev->scsi_lun);
2725 if (pDev->pScsi_dev) {
2726 scsi_device_set_state(pDev->pScsi_dev, SDEV_OFFLINE);
2727 }
2728 }
2729 }
2730 return 0;
2731 }
2732
2733 static void adpt_fail_posted_scbs(adpt_hba* pHba)
2734 {
2735 struct scsi_cmnd* cmd = NULL;
2736 struct scsi_device* d = NULL;
2737
2738 shost_for_each_device(d, pHba->host) {
2739 unsigned long flags;
2740 spin_lock_irqsave(&d->list_lock, flags);
2741 list_for_each_entry(cmd, &d->cmd_list, list) {
2742 if(cmd->serial_number == 0){
2743 continue;
2744 }
2745 cmd->result = (DID_OK << 16) | (QUEUE_FULL <<1);
2746 cmd->scsi_done(cmd);
2747 }
2748 spin_unlock_irqrestore(&d->list_lock, flags);
2749 }
2750 }
2751
2752
2753 /*============================================================================
2754 * Routines from i2o subsystem
2755 *============================================================================
2756 */
2757
2758
2759
2760 /*
2761 * Bring an I2O controller into HOLD state. See the spec.
2762 */
2763 static int adpt_i2o_activate_hba(adpt_hba* pHba)
2764 {
2765 int rcode;
2766
2767 if(pHba->initialized ) {
2768 if (adpt_i2o_status_get(pHba) < 0) {
2769 if((rcode = adpt_i2o_reset_hba(pHba)) != 0){
2770 printk(KERN_WARNING"%s: Could NOT reset.\n", pHba->name);
2771 return rcode;
2772 }
2773 if (adpt_i2o_status_get(pHba) < 0) {
2774 printk(KERN_INFO "HBA not responding.\n");
2775 return -1;
2776 }
2777 }
2778
2779 if(pHba->status_block->iop_state == ADAPTER_STATE_FAULTED) {
2780 printk(KERN_CRIT "%s: hardware fault\n", pHba->name);
2781 return -1;
2782 }
2783
2784 if (pHba->status_block->iop_state == ADAPTER_STATE_READY ||
2785 pHba->status_block->iop_state == ADAPTER_STATE_OPERATIONAL ||
2786 pHba->status_block->iop_state == ADAPTER_STATE_HOLD ||
2787 pHba->status_block->iop_state == ADAPTER_STATE_FAILED) {
2788 adpt_i2o_reset_hba(pHba);
2789 if (adpt_i2o_status_get(pHba) < 0 || pHba->status_block->iop_state != ADAPTER_STATE_RESET) {
2790 printk(KERN_ERR "%s: Failed to initialize.\n", pHba->name);
2791 return -1;
2792 }
2793 }
2794 } else {
2795 if((rcode = adpt_i2o_reset_hba(pHba)) != 0){
2796 printk(KERN_WARNING"%s: Could NOT reset.\n", pHba->name);
2797 return rcode;
2798 }
2799
2800 }
2801
2802 if (adpt_i2o_init_outbound_q(pHba) < 0) {
2803 return -1;
2804 }
2805
2806 /* In HOLD state */
2807
2808 if (adpt_i2o_hrt_get(pHba) < 0) {
2809 return -1;
2810 }
2811
2812 return 0;
2813 }
2814
2815 /*
2816 * Bring a controller online into OPERATIONAL state.
2817 */
2818
2819 static int adpt_i2o_online_hba(adpt_hba* pHba)
2820 {
2821 if (adpt_i2o_systab_send(pHba) < 0) {
2822 adpt_i2o_delete_hba(pHba);
2823 return -1;
2824 }
2825 /* In READY state */
2826
2827 if (adpt_i2o_enable_hba(pHba) < 0) {
2828 adpt_i2o_delete_hba(pHba);
2829 return -1;
2830 }
2831
2832 /* In OPERATIONAL state */
2833 return 0;
2834 }
2835
2836 static s32 adpt_send_nop(adpt_hba*pHba,u32 m)
2837 {
2838 u32 __iomem *msg;
2839 ulong timeout = jiffies + 5*HZ;
2840
2841 while(m == EMPTY_QUEUE){
2842 rmb();
2843 m = readl(pHba->post_port);
2844 if(m != EMPTY_QUEUE){
2845 break;
2846 }
2847 if(time_after(jiffies,timeout)){
2848 printk(KERN_ERR "%s: Timeout waiting for message frame!\n",pHba->name);
2849 return 2;
2850 }
2851 schedule_timeout_uninterruptible(1);
2852 }
2853 msg = (u32 __iomem *)(pHba->msg_addr_virt + m);
2854 writel( THREE_WORD_MSG_SIZE | SGL_OFFSET_0,&msg[0]);
2855 writel( I2O_CMD_UTIL_NOP << 24 | HOST_TID << 12 | 0,&msg[1]);
2856 writel( 0,&msg[2]);
2857 wmb();
2858
2859 writel(m, pHba->post_port);
2860 wmb();
2861 return 0;
2862 }
2863
2864 static s32 adpt_i2o_init_outbound_q(adpt_hba* pHba)
2865 {
2866 u8 *status;
2867 dma_addr_t addr;
2868 u32 __iomem *msg = NULL;
2869 int i;
2870 ulong timeout = jiffies + TMOUT_INITOUTBOUND*HZ;
2871 u32 m;
2872
2873 do {
2874 rmb();
2875 m = readl(pHba->post_port);
2876 if (m != EMPTY_QUEUE) {
2877 break;
2878 }
2879
2880 if(time_after(jiffies,timeout)){
2881 printk(KERN_WARNING"%s: Timeout waiting for message frame\n",pHba->name);
2882 return -ETIMEDOUT;
2883 }
2884 schedule_timeout_uninterruptible(1);
2885 } while(m == EMPTY_QUEUE);
2886
2887 msg=(u32 __iomem *)(pHba->msg_addr_virt+m);
2888
2889 status = dma_alloc_coherent(&pHba->pDev->dev, 4, &addr, GFP_KERNEL);
2890 if (!status) {
2891 adpt_send_nop(pHba, m);
2892 printk(KERN_WARNING"%s: IOP reset failed - no free memory.\n",
2893 pHba->name);
2894 return -ENOMEM;
2895 }
2896 memset(status, 0, 4);
2897
2898 writel(EIGHT_WORD_MSG_SIZE| SGL_OFFSET_6, &msg[0]);
2899 writel(I2O_CMD_OUTBOUND_INIT<<24 | HOST_TID<<12 | ADAPTER_TID, &msg[1]);
2900 writel(0, &msg[2]);
2901 writel(0x0106, &msg[3]); /* Transaction context */
2902 writel(4096, &msg[4]); /* Host page frame size */
2903 writel((REPLY_FRAME_SIZE)<<16|0x80, &msg[5]); /* Outbound msg frame size and Initcode */
2904 writel(0xD0000004, &msg[6]); /* Simple SG LE, EOB */
2905 writel((u32)addr, &msg[7]);
2906
2907 writel(m, pHba->post_port);
2908 wmb();
2909
2910 // Wait for the reply status to come back
2911 do {
2912 if (*status) {
2913 if (*status != 0x01 /*I2O_EXEC_OUTBOUND_INIT_IN_PROGRESS*/) {
2914 break;
2915 }
2916 }
2917 rmb();
2918 if(time_after(jiffies,timeout)){
2919 printk(KERN_WARNING"%s: Timeout Initializing\n",pHba->name);
2920 /* We lose 4 bytes of "status" here, but we
2921 cannot free these because controller may
2922 awake and corrupt those bytes at any time */
2923 /* dma_free_coherent(&pHba->pDev->dev, 4, status, addr); */
2924 return -ETIMEDOUT;
2925 }
2926 schedule_timeout_uninterruptible(1);
2927 } while (1);
2928
2929 // If the command was successful, fill the fifo with our reply
2930 // message packets
2931 if(*status != 0x04 /*I2O_EXEC_OUTBOUND_INIT_COMPLETE*/) {
2932 dma_free_coherent(&pHba->pDev->dev, 4, status, addr);
2933 return -2;
2934 }
2935 dma_free_coherent(&pHba->pDev->dev, 4, status, addr);
2936
2937 if(pHba->reply_pool != NULL) {
2938 dma_free_coherent(&pHba->pDev->dev,
2939 pHba->reply_fifo_size * REPLY_FRAME_SIZE * 4,
2940 pHba->reply_pool, pHba->reply_pool_pa);
2941 }
2942
2943 pHba->reply_pool = dma_alloc_coherent(&pHba->pDev->dev,
2944 pHba->reply_fifo_size * REPLY_FRAME_SIZE * 4,
2945 &pHba->reply_pool_pa, GFP_KERNEL);
2946 if (!pHba->reply_pool) {
2947 printk(KERN_ERR "%s: Could not allocate reply pool\n", pHba->name);
2948 return -ENOMEM;
2949 }
2950 memset(pHba->reply_pool, 0 , pHba->reply_fifo_size * REPLY_FRAME_SIZE * 4);
2951
2952 for(i = 0; i < pHba->reply_fifo_size; i++) {
2953 writel(pHba->reply_pool_pa + (i * REPLY_FRAME_SIZE * 4),
2954 pHba->reply_port);
2955 wmb();
2956 }
2957 adpt_i2o_status_get(pHba);
2958 return 0;
2959 }
2960
2961
2962 /*
2963 * I2O System Table. Contains information about
2964 * all the IOPs in the system. Used to inform IOPs
2965 * about each other's existence.
2966 *
2967 * sys_tbl_ver is the CurrentChangeIndicator that is
2968 * used by IOPs to track changes.
2969 */
2970
2971
2972
2973 static s32 adpt_i2o_status_get(adpt_hba* pHba)
2974 {
2975 ulong timeout;
2976 u32 m;
2977 u32 __iomem *msg;
2978 u8 *status_block=NULL;
2979
2980 if(pHba->status_block == NULL) {
2981 pHba->status_block = dma_alloc_coherent(&pHba->pDev->dev,
2982 sizeof(i2o_status_block),
2983 &pHba->status_block_pa, GFP_KERNEL);
2984 if(pHba->status_block == NULL) {
2985 printk(KERN_ERR
2986 "dpti%d: Get Status Block failed; Out of memory. \n",
2987 pHba->unit);
2988 return -ENOMEM;
2989 }
2990 }
2991 memset(pHba->status_block, 0, sizeof(i2o_status_block));
2992 status_block = (u8*)(pHba->status_block);
2993 timeout = jiffies+TMOUT_GETSTATUS*HZ;
2994 do {
2995 rmb();
2996 m = readl(pHba->post_port);
2997 if (m != EMPTY_QUEUE) {
2998 break;
2999 }
3000 if(time_after(jiffies,timeout)){
3001 printk(KERN_ERR "%s: Timeout waiting for message !\n",
3002 pHba->name);
3003 return -ETIMEDOUT;
3004 }
3005 schedule_timeout_uninterruptible(1);
3006 } while(m==EMPTY_QUEUE);
3007
3008
3009 msg=(u32 __iomem *)(pHba->msg_addr_virt+m);
3010
3011 writel(NINE_WORD_MSG_SIZE|SGL_OFFSET_0, &msg[0]);
3012 writel(I2O_CMD_STATUS_GET<<24|HOST_TID<<12|ADAPTER_TID, &msg[1]);
3013 writel(1, &msg[2]);
3014 writel(0, &msg[3]);
3015 writel(0, &msg[4]);
3016 writel(0, &msg[5]);
3017 writel( dma_low(pHba->status_block_pa), &msg[6]);
3018 writel( dma_high(pHba->status_block_pa), &msg[7]);
3019 writel(sizeof(i2o_status_block), &msg[8]); // 88 bytes
3020
3021 //post message
3022 writel(m, pHba->post_port);
3023 wmb();
3024
3025 while(status_block[87]!=0xff){
3026 if(time_after(jiffies,timeout)){
3027 printk(KERN_ERR"dpti%d: Get status timeout.\n",
3028 pHba->unit);
3029 return -ETIMEDOUT;
3030 }
3031 rmb();
3032 schedule_timeout_uninterruptible(1);
3033 }
3034
3035 // Set up our number of outbound and inbound messages
3036 pHba->post_fifo_size = pHba->status_block->max_inbound_frames;
3037 if (pHba->post_fifo_size > MAX_TO_IOP_MESSAGES) {
3038 pHba->post_fifo_size = MAX_TO_IOP_MESSAGES;
3039 }
3040
3041 pHba->reply_fifo_size = pHba->status_block->max_outbound_frames;
3042 if (pHba->reply_fifo_size > MAX_FROM_IOP_MESSAGES) {
3043 pHba->reply_fifo_size = MAX_FROM_IOP_MESSAGES;
3044 }
3045
3046 // Calculate the Scatter Gather list size
3047 if (dpt_dma64(pHba)) {
3048 pHba->sg_tablesize
3049 = ((pHba->status_block->inbound_frame_size * 4
3050 - 14 * sizeof(u32))
3051 / (sizeof(struct sg_simple_element) + sizeof(u32)));
3052 } else {
3053 pHba->sg_tablesize
3054 = ((pHba->status_block->inbound_frame_size * 4
3055 - 12 * sizeof(u32))
3056 / sizeof(struct sg_simple_element));
3057 }
3058 if (pHba->sg_tablesize > SG_LIST_ELEMENTS) {
3059 pHba->sg_tablesize = SG_LIST_ELEMENTS;
3060 }
3061
3062
3063 #ifdef DEBUG
3064 printk("dpti%d: State = ",pHba->unit);
3065 switch(pHba->status_block->iop_state) {
3066 case 0x01:
3067 printk("INIT\n");
3068 break;
3069 case 0x02:
3070 printk("RESET\n");
3071 break;
3072 case 0x04:
3073 printk("HOLD\n");
3074 break;
3075 case 0x05:
3076 printk("READY\n");
3077 break;
3078 case 0x08:
3079 printk("OPERATIONAL\n");
3080 break;
3081 case 0x10:
3082 printk("FAILED\n");
3083 break;
3084 case 0x11:
3085 printk("FAULTED\n");
3086 break;
3087 default:
3088 printk("%x (unknown!!)\n",pHba->status_block->iop_state);
3089 }
3090 #endif
3091 return 0;
3092 }
3093
3094 /*
3095 * Get the IOP's Logical Configuration Table
3096 */
3097 static int adpt_i2o_lct_get(adpt_hba* pHba)
3098 {
3099 u32 msg[8];
3100 int ret;
3101 u32 buf[16];
3102
3103 if ((pHba->lct_size == 0) || (pHba->lct == NULL)){
3104 pHba->lct_size = pHba->status_block->expected_lct_size;
3105 }
3106 do {
3107 if (pHba->lct == NULL) {
3108 pHba->lct = dma_alloc_coherent(&pHba->pDev->dev,
3109 pHba->lct_size, &pHba->lct_pa,
3110 GFP_KERNEL);
3111 if(pHba->lct == NULL) {
3112 printk(KERN_CRIT "%s: Lct Get failed. Out of memory.\n",
3113 pHba->name);
3114 return -ENOMEM;
3115 }
3116 }
3117 memset(pHba->lct, 0, pHba->lct_size);
3118
3119 msg[0] = EIGHT_WORD_MSG_SIZE|SGL_OFFSET_6;
3120 msg[1] = I2O_CMD_LCT_NOTIFY<<24 | HOST_TID<<12 | ADAPTER_TID;
3121 msg[2] = 0;
3122 msg[3] = 0;
3123 msg[4] = 0xFFFFFFFF; /* All devices */
3124 msg[5] = 0x00000000; /* Report now */
3125 msg[6] = 0xD0000000|pHba->lct_size;
3126 msg[7] = (u32)pHba->lct_pa;
3127
3128 if ((ret=adpt_i2o_post_wait(pHba, msg, sizeof(msg), 360))) {
3129 printk(KERN_ERR "%s: LCT Get failed (status=%#10x.\n",
3130 pHba->name, ret);
3131 printk(KERN_ERR"Adaptec: Error Reading Hardware.\n");
3132 return ret;
3133 }
3134
3135 if ((pHba->lct->table_size << 2) > pHba->lct_size) {
3136 pHba->lct_size = pHba->lct->table_size << 2;
3137 dma_free_coherent(&pHba->pDev->dev, pHba->lct_size,
3138 pHba->lct, pHba->lct_pa);
3139 pHba->lct = NULL;
3140 }
3141 } while (pHba->lct == NULL);
3142
3143 PDEBUG("%s: Hardware resource table read.\n", pHba->name);
3144
3145
3146 // I2O_DPT_EXEC_IOP_BUFFERS_GROUP_NO;
3147 if(adpt_i2o_query_scalar(pHba, 0 , 0x8000, -1, buf, sizeof(buf))>=0) {
3148 pHba->FwDebugBufferSize = buf[1];
3149 pHba->FwDebugBuffer_P = ioremap(pHba->base_addr_phys + buf[0],
3150 pHba->FwDebugBufferSize);
3151 if (pHba->FwDebugBuffer_P) {
3152 pHba->FwDebugFlags_P = pHba->FwDebugBuffer_P +
3153 FW_DEBUG_FLAGS_OFFSET;
3154 pHba->FwDebugBLEDvalue_P = pHba->FwDebugBuffer_P +
3155 FW_DEBUG_BLED_OFFSET;
3156 pHba->FwDebugBLEDflag_P = pHba->FwDebugBLEDvalue_P + 1;
3157 pHba->FwDebugStrLength_P = pHba->FwDebugBuffer_P +
3158 FW_DEBUG_STR_LENGTH_OFFSET;
3159 pHba->FwDebugBuffer_P += buf[2];
3160 pHba->FwDebugFlags = 0;
3161 }
3162 }
3163
3164 return 0;
3165 }
3166
3167 static int adpt_i2o_build_sys_table(void)
3168 {
3169 adpt_hba* pHba = hba_chain;
3170 int count = 0;
3171
3172 if (sys_tbl)
3173 dma_free_coherent(&pHba->pDev->dev, sys_tbl_len,
3174 sys_tbl, sys_tbl_pa);
3175
3176 sys_tbl_len = sizeof(struct i2o_sys_tbl) + // Header + IOPs
3177 (hba_count) * sizeof(struct i2o_sys_tbl_entry);
3178
3179 sys_tbl = dma_alloc_coherent(&pHba->pDev->dev,
3180 sys_tbl_len, &sys_tbl_pa, GFP_KERNEL);
3181 if (!sys_tbl) {
3182 printk(KERN_WARNING "SysTab Set failed. Out of memory.\n");
3183 return -ENOMEM;
3184 }
3185 memset(sys_tbl, 0, sys_tbl_len);
3186
3187 sys_tbl->num_entries = hba_count;
3188 sys_tbl->version = I2OVERSION;
3189 sys_tbl->change_ind = sys_tbl_ind++;
3190
3191 for(pHba = hba_chain; pHba; pHba = pHba->next) {
3192 u64 addr;
3193 // Get updated Status Block so we have the latest information
3194 if (adpt_i2o_status_get(pHba)) {
3195 sys_tbl->num_entries--;
3196 continue; // try next one
3197 }
3198
3199 sys_tbl->iops[count].org_id = pHba->status_block->org_id;
3200 sys_tbl->iops[count].iop_id = pHba->unit + 2;
3201 sys_tbl->iops[count].seg_num = 0;
3202 sys_tbl->iops[count].i2o_version = pHba->status_block->i2o_version;
3203 sys_tbl->iops[count].iop_state = pHba->status_block->iop_state;
3204 sys_tbl->iops[count].msg_type = pHba->status_block->msg_type;
3205 sys_tbl->iops[count].frame_size = pHba->status_block->inbound_frame_size;
3206 sys_tbl->iops[count].last_changed = sys_tbl_ind - 1; // ??
3207 sys_tbl->iops[count].iop_capabilities = pHba->status_block->iop_capabilities;
3208 addr = pHba->base_addr_phys + 0x40;
3209 sys_tbl->iops[count].inbound_low = dma_low(addr);
3210 sys_tbl->iops[count].inbound_high = dma_high(addr);
3211
3212 count++;
3213 }
3214
3215 #ifdef DEBUG
3216 {
3217 u32 *table = (u32*)sys_tbl;
3218 printk(KERN_DEBUG"sys_tbl_len=%d in 32bit words\n",(sys_tbl_len >>2));
3219 for(count = 0; count < (sys_tbl_len >>2); count++) {
3220 printk(KERN_INFO "sys_tbl[%d] = %0#10x\n",
3221 count, table[count]);
3222 }
3223 }
3224 #endif
3225
3226 return 0;
3227 }
3228
3229
3230 /*
3231 * Dump the information block associated with a given unit (TID)
3232 */
3233
3234 static void adpt_i2o_report_hba_unit(adpt_hba* pHba, struct i2o_device *d)
3235 {
3236 char buf[64];
3237 int unit = d->lct_data.tid;
3238
3239 printk(KERN_INFO "TID %3.3d ", unit);
3240
3241 if(adpt_i2o_query_scalar(pHba, unit, 0xF100, 3, buf, 16)>=0)
3242 {
3243 buf[16]=0;
3244 printk(" Vendor: %-12.12s", buf);
3245 }
3246 if(adpt_i2o_query_scalar(pHba, unit, 0xF100, 4, buf, 16)>=0)
3247 {
3248 buf[16]=0;
3249 printk(" Device: %-12.12s", buf);
3250 }
3251 if(adpt_i2o_query_scalar(pHba, unit, 0xF100, 6, buf, 8)>=0)
3252 {
3253 buf[8]=0;
3254 printk(" Rev: %-12.12s\n", buf);
3255 }
3256 #ifdef DEBUG
3257 printk(KERN_INFO "\tClass: %.21s\n", adpt_i2o_get_class_name(d->lct_data.class_id));
3258 printk(KERN_INFO "\tSubclass: 0x%04X\n", d->lct_data.sub_class);
3259 printk(KERN_INFO "\tFlags: ");
3260
3261 if(d->lct_data.device_flags&(1<<0))
3262 printk("C"); // ConfigDialog requested
3263 if(d->lct_data.device_flags&(1<<1))
3264 printk("U"); // Multi-user capable
3265 if(!(d->lct_data.device_flags&(1<<4)))
3266 printk("P"); // Peer service enabled!
3267 if(!(d->lct_data.device_flags&(1<<5)))
3268 printk("M"); // Mgmt service enabled!
3269 printk("\n");
3270 #endif
3271 }
3272
3273 #ifdef DEBUG
3274 /*
3275 * Do i2o class name lookup
3276 */
3277 static const char *adpt_i2o_get_class_name(int class)
3278 {
3279 int idx = 16;
3280 static char *i2o_class_name[] = {
3281 "Executive",
3282 "Device Driver Module",
3283 "Block Device",
3284 "Tape Device",
3285 "LAN Interface",
3286 "WAN Interface",
3287 "Fibre Channel Port",
3288 "Fibre Channel Device",
3289 "SCSI Device",
3290 "ATE Port",
3291 "ATE Device",
3292 "Floppy Controller",
3293 "Floppy Device",
3294 "Secondary Bus Port",
3295 "Peer Transport Agent",
3296 "Peer Transport",
3297 "Unknown"
3298 };
3299
3300 switch(class&0xFFF) {
3301 case I2O_CLASS_EXECUTIVE:
3302 idx = 0; break;
3303 case I2O_CLASS_DDM:
3304 idx = 1; break;
3305 case I2O_CLASS_RANDOM_BLOCK_STORAGE:
3306 idx = 2; break;
3307 case I2O_CLASS_SEQUENTIAL_STORAGE:
3308 idx = 3; break;
3309 case I2O_CLASS_LAN:
3310 idx = 4; break;
3311 case I2O_CLASS_WAN:
3312 idx = 5; break;
3313 case I2O_CLASS_FIBRE_CHANNEL_PORT:
3314 idx = 6; break;
3315 case I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL:
3316 idx = 7; break;
3317 case I2O_CLASS_SCSI_PERIPHERAL:
3318 idx = 8; break;
3319 case I2O_CLASS_ATE_PORT:
3320 idx = 9; break;
3321 case I2O_CLASS_ATE_PERIPHERAL:
3322 idx = 10; break;
3323 case I2O_CLASS_FLOPPY_CONTROLLER:
3324 idx = 11; break;
3325 case I2O_CLASS_FLOPPY_DEVICE:
3326 idx = 12; break;
3327 case I2O_CLASS_BUS_ADAPTER_PORT:
3328 idx = 13; break;
3329 case I2O_CLASS_PEER_TRANSPORT_AGENT:
3330 idx = 14; break;
3331 case I2O_CLASS_PEER_TRANSPORT:
3332 idx = 15; break;
3333 }
3334 return i2o_class_name[idx];
3335 }
3336 #endif
3337
3338
3339 static s32 adpt_i2o_hrt_get(adpt_hba* pHba)
3340 {
3341 u32 msg[6];
3342 int ret, size = sizeof(i2o_hrt);
3343
3344 do {
3345 if (pHba->hrt == NULL) {
3346 pHba->hrt = dma_alloc_coherent(&pHba->pDev->dev,
3347 size, &pHba->hrt_pa, GFP_KERNEL);
3348 if (pHba->hrt == NULL) {
3349 printk(KERN_CRIT "%s: Hrt Get failed; Out of memory.\n", pHba->name);
3350 return -ENOMEM;
3351 }
3352 }
3353
3354 msg[0]= SIX_WORD_MSG_SIZE| SGL_OFFSET_4;
3355 msg[1]= I2O_CMD_HRT_GET<<24 | HOST_TID<<12 | ADAPTER_TID;
3356 msg[2]= 0;
3357 msg[3]= 0;
3358 msg[4]= (0xD0000000 | size); /* Simple transaction */
3359 msg[5]= (u32)pHba->hrt_pa; /* Dump it here */
3360
3361 if ((ret = adpt_i2o_post_wait(pHba, msg, sizeof(msg),20))) {
3362 printk(KERN_ERR "%s: Unable to get HRT (status=%#10x)\n", pHba->name, ret);
3363 return ret;
3364 }
3365
3366 if (pHba->hrt->num_entries * pHba->hrt->entry_len << 2 > size) {
3367 int newsize = pHba->hrt->num_entries * pHba->hrt->entry_len << 2;
3368 dma_free_coherent(&pHba->pDev->dev, size,
3369 pHba->hrt, pHba->hrt_pa);
3370 size = newsize;
3371 pHba->hrt = NULL;
3372 }
3373 } while(pHba->hrt == NULL);
3374 return 0;
3375 }
3376
3377 /*
3378 * Query one scalar group value or a whole scalar group.
3379 */
3380 static int adpt_i2o_query_scalar(adpt_hba* pHba, int tid,
3381 int group, int field, void *buf, int buflen)
3382 {
3383 u16 opblk[] = { 1, 0, I2O_PARAMS_FIELD_GET, group, 1, field };
3384 u8 *opblk_va;
3385 dma_addr_t opblk_pa;
3386 u8 *resblk_va;
3387 dma_addr_t resblk_pa;
3388
3389 int size;
3390
3391 /* 8 bytes for header */
3392 resblk_va = dma_alloc_coherent(&pHba->pDev->dev,
3393 sizeof(u8) * (8 + buflen), &resblk_pa, GFP_KERNEL);
3394 if (resblk_va == NULL) {
3395 printk(KERN_CRIT "%s: query scalar failed; Out of memory.\n", pHba->name);
3396 return -ENOMEM;
3397 }
3398
3399 opblk_va = dma_alloc_coherent(&pHba->pDev->dev,
3400 sizeof(opblk), &opblk_pa, GFP_KERNEL);
3401 if (opblk_va == NULL) {
3402 dma_free_coherent(&pHba->pDev->dev, sizeof(u8) * (8+buflen),
3403 resblk_va, resblk_pa);
3404 printk(KERN_CRIT "%s: query operatio failed; Out of memory.\n",
3405 pHba->name);
3406 return -ENOMEM;
3407 }
3408 if (field == -1) /* whole group */
3409 opblk[4] = -1;
3410
3411 memcpy(opblk_va, opblk, sizeof(opblk));
3412 size = adpt_i2o_issue_params(I2O_CMD_UTIL_PARAMS_GET, pHba, tid,
3413 opblk_va, opblk_pa, sizeof(opblk),
3414 resblk_va, resblk_pa, sizeof(u8)*(8+buflen));
3415 dma_free_coherent(&pHba->pDev->dev, sizeof(opblk), opblk_va, opblk_pa);
3416 if (size == -ETIME) {
3417 dma_free_coherent(&pHba->pDev->dev, sizeof(u8) * (8+buflen),
3418 resblk_va, resblk_pa);
3419 printk(KERN_WARNING "%s: issue params failed; Timed out.\n", pHba->name);
3420 return -ETIME;
3421 } else if (size == -EINTR) {
3422 dma_free_coherent(&pHba->pDev->dev, sizeof(u8) * (8+buflen),
3423 resblk_va, resblk_pa);
3424 printk(KERN_WARNING "%s: issue params failed; Interrupted.\n", pHba->name);
3425 return -EINTR;
3426 }
3427
3428 memcpy(buf, resblk_va+8, buflen); /* cut off header */
3429
3430 dma_free_coherent(&pHba->pDev->dev, sizeof(u8) * (8+buflen),
3431 resblk_va, resblk_pa);
3432 if (size < 0)
3433 return size;
3434
3435 return buflen;
3436 }
3437
3438
3439 /* Issue UTIL_PARAMS_GET or UTIL_PARAMS_SET
3440 *
3441 * This function can be used for all UtilParamsGet/Set operations.
3442 * The OperationBlock is given in opblk-buffer,
3443 * and results are returned in resblk-buffer.
3444 * Note that the minimum sized resblk is 8 bytes and contains
3445 * ResultCount, ErrorInfoSize, BlockStatus and BlockSize.
3446 */
3447 static int adpt_i2o_issue_params(int cmd, adpt_hba* pHba, int tid,
3448 void *opblk_va, dma_addr_t opblk_pa, int oplen,
3449 void *resblk_va, dma_addr_t resblk_pa, int reslen)
3450 {
3451 u32 msg[9];
3452 u32 *res = (u32 *)resblk_va;
3453 int wait_status;
3454
3455 msg[0] = NINE_WORD_MSG_SIZE | SGL_OFFSET_5;
3456 msg[1] = cmd << 24 | HOST_TID << 12 | tid;
3457 msg[2] = 0;
3458 msg[3] = 0;
3459 msg[4] = 0;
3460 msg[5] = 0x54000000 | oplen; /* OperationBlock */
3461 msg[6] = (u32)opblk_pa;
3462 msg[7] = 0xD0000000 | reslen; /* ResultBlock */
3463 msg[8] = (u32)resblk_pa;
3464
3465 if ((wait_status = adpt_i2o_post_wait(pHba, msg, sizeof(msg), 20))) {
3466 printk("adpt_i2o_issue_params: post_wait failed (%p)\n", resblk_va);
3467 return wait_status; /* -DetailedStatus */
3468 }
3469
3470 if (res[1]&0x00FF0000) { /* BlockStatus != SUCCESS */
3471 printk(KERN_WARNING "%s: %s - Error:\n ErrorInfoSize = 0x%02x, "
3472 "BlockStatus = 0x%02x, BlockSize = 0x%04x\n",
3473 pHba->name,
3474 (cmd == I2O_CMD_UTIL_PARAMS_SET) ? "PARAMS_SET"
3475 : "PARAMS_GET",
3476 res[1]>>24, (res[1]>>16)&0xFF, res[1]&0xFFFF);
3477 return -((res[1] >> 16) & 0xFF); /* -BlockStatus */
3478 }
3479
3480 return 4 + ((res[1] & 0x0000FFFF) << 2); /* bytes used in resblk */
3481 }
3482
3483
3484 static s32 adpt_i2o_quiesce_hba(adpt_hba* pHba)
3485 {
3486 u32 msg[4];
3487 int ret;
3488
3489 adpt_i2o_status_get(pHba);
3490
3491 /* SysQuiesce discarded if IOP not in READY or OPERATIONAL state */
3492
3493 if((pHba->status_block->iop_state != ADAPTER_STATE_READY) &&
3494 (pHba->status_block->iop_state != ADAPTER_STATE_OPERATIONAL)){
3495 return 0;
3496 }
3497
3498 msg[0] = FOUR_WORD_MSG_SIZE|SGL_OFFSET_0;
3499 msg[1] = I2O_CMD_SYS_QUIESCE<<24|HOST_TID<<12|ADAPTER_TID;
3500 msg[2] = 0;
3501 msg[3] = 0;
3502
3503 if((ret = adpt_i2o_post_wait(pHba, msg, sizeof(msg), 240))) {
3504 printk(KERN_INFO"dpti%d: Unable to quiesce (status=%#x).\n",
3505 pHba->unit, -ret);
3506 } else {
3507 printk(KERN_INFO"dpti%d: Quiesced.\n",pHba->unit);
3508 }
3509
3510 adpt_i2o_status_get(pHba);
3511 return ret;
3512 }
3513
3514
3515 /*
3516 * Enable IOP. Allows the IOP to resume external operations.
3517 */
3518 static int adpt_i2o_enable_hba(adpt_hba* pHba)
3519 {
3520 u32 msg[4];
3521 int ret;
3522
3523 adpt_i2o_status_get(pHba);
3524 if(!pHba->status_block){
3525 return -ENOMEM;
3526 }
3527 /* Enable only allowed on READY state */
3528 if(pHba->status_block->iop_state == ADAPTER_STATE_OPERATIONAL)
3529 return 0;
3530
3531 if(pHba->status_block->iop_state != ADAPTER_STATE_READY)
3532 return -EINVAL;
3533
3534 msg[0]=FOUR_WORD_MSG_SIZE|SGL_OFFSET_0;
3535 msg[1]=I2O_CMD_SYS_ENABLE<<24|HOST_TID<<12|ADAPTER_TID;
3536 msg[2]= 0;
3537 msg[3]= 0;
3538
3539 if ((ret = adpt_i2o_post_wait(pHba, msg, sizeof(msg), 240))) {
3540 printk(KERN_WARNING"%s: Could not enable (status=%#10x).\n",
3541 pHba->name, ret);
3542 } else {
3543 PDEBUG("%s: Enabled.\n", pHba->name);
3544 }
3545
3546 adpt_i2o_status_get(pHba);
3547 return ret;
3548 }
3549
3550
3551 static int adpt_i2o_systab_send(adpt_hba* pHba)
3552 {
3553 u32 msg[12];
3554 int ret;
3555
3556 msg[0] = I2O_MESSAGE_SIZE(12) | SGL_OFFSET_6;
3557 msg[1] = I2O_CMD_SYS_TAB_SET<<24 | HOST_TID<<12 | ADAPTER_TID;
3558 msg[2] = 0;
3559 msg[3] = 0;
3560 msg[4] = (0<<16) | ((pHba->unit+2) << 12); /* Host 0 IOP ID (unit + 2) */
3561 msg[5] = 0; /* Segment 0 */
3562
3563 /*
3564 * Provide three SGL-elements:
3565 * System table (SysTab), Private memory space declaration and
3566 * Private i/o space declaration
3567 */
3568 msg[6] = 0x54000000 | sys_tbl_len;
3569 msg[7] = (u32)sys_tbl_pa;
3570 msg[8] = 0x54000000 | 0;
3571 msg[9] = 0;
3572 msg[10] = 0xD4000000 | 0;
3573 msg[11] = 0;
3574
3575 if ((ret=adpt_i2o_post_wait(pHba, msg, sizeof(msg), 120))) {
3576 printk(KERN_INFO "%s: Unable to set SysTab (status=%#10x).\n",
3577 pHba->name, ret);
3578 }
3579 #ifdef DEBUG
3580 else {
3581 PINFO("%s: SysTab set.\n", pHba->name);
3582 }
3583 #endif
3584
3585 return ret;
3586 }
3587
3588
3589 /*============================================================================
3590 *
3591 *============================================================================
3592 */
3593
3594
3595 #ifdef UARTDELAY
3596
3597 static static void adpt_delay(int millisec)
3598 {
3599 int i;
3600 for (i = 0; i < millisec; i++) {
3601 udelay(1000); /* delay for one millisecond */
3602 }
3603 }
3604
3605 #endif
3606
3607 static struct scsi_host_template driver_template = {
3608 .module = THIS_MODULE,
3609 .name = "dpt_i2o",
3610 .proc_name = "dpt_i2o",
3611 .proc_info = adpt_proc_info,
3612 .info = adpt_info,
3613 .queuecommand = adpt_queue,
3614 .eh_abort_handler = adpt_abort,
3615 .eh_device_reset_handler = adpt_device_reset,
3616 .eh_bus_reset_handler = adpt_bus_reset,
3617 .eh_host_reset_handler = adpt_reset,
3618 .bios_param = adpt_bios_param,
3619 .slave_configure = adpt_slave_configure,
3620 .can_queue = MAX_TO_IOP_MESSAGES,
3621 .this_id = 7,
3622 .cmd_per_lun = 1,
3623 .use_clustering = ENABLE_CLUSTERING,
3624 };
3625
3626 static int __init adpt_init(void)
3627 {
3628 int error;
3629 adpt_hba *pHba, *next;
3630
3631 printk("Loading Adaptec I2O RAID: Version " DPT_I2O_VERSION "\n");
3632
3633 error = adpt_detect(&driver_template);
3634 if (error < 0)
3635 return error;
3636 if (hba_chain == NULL)
3637 return -ENODEV;
3638
3639 for (pHba = hba_chain; pHba; pHba = pHba->next) {
3640 error = scsi_add_host(pHba->host, &pHba->pDev->dev);
3641 if (error)
3642 goto fail;
3643 scsi_scan_host(pHba->host);
3644 }
3645 return 0;
3646 fail:
3647 for (pHba = hba_chain; pHba; pHba = next) {
3648 next = pHba->next;
3649 scsi_remove_host(pHba->host);
3650 }
3651 return error;
3652 }
3653
3654 static void __exit adpt_exit(void)
3655 {
3656 adpt_hba *pHba, *next;
3657
3658 for (pHba = hba_chain; pHba; pHba = pHba->next)
3659 scsi_remove_host(pHba->host);
3660 for (pHba = hba_chain; pHba; pHba = next) {
3661 next = pHba->next;
3662 adpt_release(pHba->host);
3663 }
3664 }
3665
3666 module_init(adpt_init);
3667 module_exit(adpt_exit);
3668
3669 MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.105399 seconds and 4 git commands to generate.