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