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