?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
allow coexistance of N build and AC build.
[tomato.git] / release / src-rt-6.x / linux / linux-2.6 / drivers / scsi / dpt_i2o.c
blobc06347fcaa39cc861e526d14f1fc64fd41248f3b
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 = kmalloc(sizeof(adpt_hba), GFP_KERNEL);
954 if( pHba == NULL) {
955 if(msg_addr_virt != base_addr_virt){
956 iounmap(msg_addr_virt);
957 }
958 iounmap(base_addr_virt);
959 pci_release_regions(pDev);
960 return -ENOMEM;
961 }
962 memset(pHba, 0, sizeof(adpt_hba));
963
964 mutex_lock(&adpt_configuration_lock);
965
966 if(hba_chain != NULL){
967 for(p = hba_chain; p->next; p = p->next);
968 p->next = pHba;
969 } else {
970 hba_chain = pHba;
971 }
972 pHba->next = NULL;
973 pHba->unit = hba_count;
974 sprintf(pHba->name, "dpti%d", hba_count);
975 hba_count++;
976
977 mutex_unlock(&adpt_configuration_lock);
978
979 pHba->pDev = pDev;
980 pHba->base_addr_phys = base_addr0_phys;
981
982 // Set up the Virtual Base Address of the I2O Device
983 pHba->base_addr_virt = base_addr_virt;
984 pHba->msg_addr_virt = msg_addr_virt;
985 pHba->irq_mask = base_addr_virt+0x30;
986 pHba->post_port = base_addr_virt+0x40;
987 pHba->reply_port = base_addr_virt+0x44;
988
989 pHba->hrt = NULL;
990 pHba->lct = NULL;
991 pHba->lct_size = 0;
992 pHba->status_block = NULL;
993 pHba->post_count = 0;
994 pHba->state = DPTI_STATE_RESET;
995 pHba->pDev = pDev;
996 pHba->devices = NULL;
997
998 // Initializing the spinlocks
999 spin_lock_init(&pHba->state_lock);
1000 spin_lock_init(&adpt_post_wait_lock);
1001
1002 if(raptorFlag == 0){
1003 printk(KERN_INFO"Adaptec I2O RAID controller %d at %p size=%x irq=%d\n",
1004 hba_count-1, base_addr_virt, hba_map0_area_size, pDev->irq);
1005 } else {
1006 printk(KERN_INFO"Adaptec I2O RAID controller %d irq=%d\n",hba_count-1, pDev->irq);
1007 printk(KERN_INFO" BAR0 %p - size= %x\n",base_addr_virt,hba_map0_area_size);
1008 printk(KERN_INFO" BAR1 %p - size= %x\n",msg_addr_virt,hba_map1_area_size);
1009 }
1010
1011 if (request_irq (pDev->irq, adpt_isr, IRQF_SHARED, pHba->name, pHba)) {
1012 printk(KERN_ERR"%s: Couldn't register IRQ %d\n", pHba->name, pDev->irq);
1013 adpt_i2o_delete_hba(pHba);
1014 return -EINVAL;
1015 }
1016
1017 return 0;
1018 }
1019
1020
1021 static void adpt_i2o_delete_hba(adpt_hba* pHba)
1022 {
1023 adpt_hba* p1;
1024 adpt_hba* p2;
1025 struct i2o_device* d;
1026 struct i2o_device* next;
1027 int i;
1028 int j;
1029 struct adpt_device* pDev;
1030 struct adpt_device* pNext;
1031
1032
1033 mutex_lock(&adpt_configuration_lock);
1034 // scsi_unregister calls our adpt_release which
1035 // does a quiese
1036 if(pHba->host){
1037 free_irq(pHba->host->irq, pHba);
1038 }
1039 p2 = NULL;
1040 for( p1 = hba_chain; p1; p2 = p1,p1=p1->next){
1041 if(p1 == pHba) {
1042 if(p2) {
1043 p2->next = p1->next;
1044 } else {
1045 hba_chain = p1->next;
1046 }
1047 break;
1048 }
1049 }
1050
1051 hba_count--;
1052 mutex_unlock(&adpt_configuration_lock);
1053
1054 iounmap(pHba->base_addr_virt);
1055 pci_release_regions(pHba->pDev);
1056 if(pHba->msg_addr_virt != pHba->base_addr_virt){
1057 iounmap(pHba->msg_addr_virt);
1058 }
1059 kfree(pHba->hrt);
1060 kfree(pHba->lct);
1061 kfree(pHba->status_block);
1062 kfree(pHba->reply_pool);
1063
1064 for(d = pHba->devices; d ; d = next){
1065 next = d->next;
1066 kfree(d);
1067 }
1068 for(i = 0 ; i < pHba->top_scsi_channel ; i++){
1069 for(j = 0; j < MAX_ID; j++){
1070 if(pHba->channel[i].device[j] != NULL){
1071 for(pDev = pHba->channel[i].device[j]; pDev; pDev = pNext){
1072 pNext = pDev->next_lun;
1073 kfree(pDev);
1074 }
1075 }
1076 }
1077 }
1078 pci_dev_put(pHba->pDev);
1079 kfree(pHba);
1080
1081 if(hba_count <= 0){
1082 unregister_chrdev(DPTI_I2O_MAJOR, DPT_DRIVER);
1083 }
1084 }
1085
1086
1087 static int adpt_init(void)
1088 {
1089 printk("Loading Adaptec I2O RAID: Version " DPT_I2O_VERSION "\n");
1090 #ifdef REBOOT_NOTIFIER
1091 register_reboot_notifier(&adpt_reboot_notifier);
1092 #endif
1093
1094 return 0;
1095 }
1096
1097
1098 static struct adpt_device* adpt_find_device(adpt_hba* pHba, u32 chan, u32 id, u32 lun)
1099 {
1100 struct adpt_device* d;
1101
1102 if(chan < 0 || chan >= MAX_CHANNEL)
1103 return NULL;
1104
1105 if( pHba->channel[chan].device == NULL){
1106 printk(KERN_DEBUG"Adaptec I2O RAID: Trying to find device before they are allocated\n");
1107 return NULL;
1108 }
1109
1110 d = pHba->channel[chan].device[id];
1111 if(!d || d->tid == 0) {
1112 return NULL;
1113 }
1114
1115 /* If it is the only lun at that address then this should match*/
1116 if(d->scsi_lun == lun){
1117 return d;
1118 }
1119
1120 /* else we need to look through all the luns */
1121 for(d=d->next_lun ; d ; d = d->next_lun){
1122 if(d->scsi_lun == lun){
1123 return d;
1124 }
1125 }
1126 return NULL;
1127 }
1128
1129
1130 static int adpt_i2o_post_wait(adpt_hba* pHba, u32* msg, int len, int timeout)
1131 {
1132 // I used my own version of the WAIT_QUEUE_HEAD
1133 // to handle some version differences
1134 // When embedded in the kernel this could go back to the vanilla one
1135 ADPT_DECLARE_WAIT_QUEUE_HEAD(adpt_wq_i2o_post);
1136 int status = 0;
1137 ulong flags = 0;
1138 struct adpt_i2o_post_wait_data *p1, *p2;
1139 struct adpt_i2o_post_wait_data *wait_data =
1140 kmalloc(sizeof(struct adpt_i2o_post_wait_data),GFP_KERNEL);
1141 DECLARE_WAITQUEUE(wait, current);
1142
1143 if (!wait_data)
1144 return -ENOMEM;
1145
1146 /*
1147 * The spin locking is needed to keep anyone from playing
1148 * with the queue pointers and id while we do the same
1149 */
1150 spin_lock_irqsave(&adpt_post_wait_lock, flags);
1151 // TODO we need a MORE unique way of getting ids
1152 // to support async LCT get
1153 wait_data->next = adpt_post_wait_queue;
1154 adpt_post_wait_queue = wait_data;
1155 adpt_post_wait_id++;
1156 adpt_post_wait_id &= 0x7fff;
1157 wait_data->id = adpt_post_wait_id;
1158 spin_unlock_irqrestore(&adpt_post_wait_lock, flags);
1159
1160 wait_data->wq = &adpt_wq_i2o_post;
1161 wait_data->status = -ETIMEDOUT;
1162
1163 add_wait_queue(&adpt_wq_i2o_post, &wait);
1164
1165 msg[2] |= 0x80000000 | ((u32)wait_data->id);
1166 timeout *= HZ;
1167 if((status = adpt_i2o_post_this(pHba, msg, len)) == 0){
1168 set_current_state(TASK_INTERRUPTIBLE);
1169 if(pHba->host)
1170 spin_unlock_irq(pHba->host->host_lock);
1171 if (!timeout)
1172 schedule();
1173 else{
1174 timeout = schedule_timeout(timeout);
1175 if (timeout == 0) {
1176 // I/O issued, but cannot get result in
1177 // specified time. Freeing resorces is
1178 // dangerous.
1179 status = -ETIME;
1180 }
1181 }
1182 if(pHba->host)
1183 spin_lock_irq(pHba->host->host_lock);
1184 }
1185 remove_wait_queue(&adpt_wq_i2o_post, &wait);
1186
1187 if(status == -ETIMEDOUT){
1188 printk(KERN_INFO"dpti%d: POST WAIT TIMEOUT\n",pHba->unit);
1189 // We will have to free the wait_data memory during shutdown
1190 return status;
1191 }
1192
1193 /* Remove the entry from the queue. */
1194 p2 = NULL;
1195 spin_lock_irqsave(&adpt_post_wait_lock, flags);
1196 for(p1 = adpt_post_wait_queue; p1; p2 = p1, p1 = p1->next) {
1197 if(p1 == wait_data) {
1198 if(p1->status == I2O_DETAIL_STATUS_UNSUPPORTED_FUNCTION ) {
1199 status = -EOPNOTSUPP;
1200 }
1201 if(p2) {
1202 p2->next = p1->next;
1203 } else {
1204 adpt_post_wait_queue = p1->next;
1205 }
1206 break;
1207 }
1208 }
1209 spin_unlock_irqrestore(&adpt_post_wait_lock, flags);
1210
1211 kfree(wait_data);
1212
1213 return status;
1214 }
1215
1216
1217 static s32 adpt_i2o_post_this(adpt_hba* pHba, u32* data, int len)
1218 {
1219
1220 u32 m = EMPTY_QUEUE;
1221 u32 __iomem *msg;
1222 ulong timeout = jiffies + 30*HZ;
1223 do {
1224 rmb();
1225 m = readl(pHba->post_port);
1226 if (m != EMPTY_QUEUE) {
1227 break;
1228 }
1229 if(time_after(jiffies,timeout)){
1230 printk(KERN_WARNING"dpti%d: Timeout waiting for message frame!\n", pHba->unit);
1231 return -ETIMEDOUT;
1232 }
1233 schedule_timeout_uninterruptible(1);
1234 } while(m == EMPTY_QUEUE);
1235
1236 msg = pHba->msg_addr_virt + m;
1237 memcpy_toio(msg, data, len);
1238 wmb();
1239
1240 //post message
1241 writel(m, pHba->post_port);
1242 wmb();
1243
1244 return 0;
1245 }
1246
1247
1248 static void adpt_i2o_post_wait_complete(u32 context, int status)
1249 {
1250 struct adpt_i2o_post_wait_data *p1 = NULL;
1251 /*
1252 * We need to search through the adpt_post_wait
1253 * queue to see if the given message is still
1254 * outstanding. If not, it means that the IOP
1255 * took longer to respond to the message than we
1256 * had allowed and timer has already expired.
1257 * Not much we can do about that except log
1258 * it for debug purposes, increase timeout, and recompile
1259 *
1260 * Lock needed to keep anyone from moving queue pointers
1261 * around while we're looking through them.
1262 */
1263
1264 context &= 0x7fff;
1265
1266 spin_lock(&adpt_post_wait_lock);
1267 for(p1 = adpt_post_wait_queue; p1; p1 = p1->next) {
1268 if(p1->id == context) {
1269 p1->status = status;
1270 spin_unlock(&adpt_post_wait_lock);
1271 wake_up_interruptible(p1->wq);
1272 return;
1273 }
1274 }
1275 spin_unlock(&adpt_post_wait_lock);
1276 // If this happens we lose commands that probably really completed
1277 printk(KERN_DEBUG"dpti: Could Not find task %d in wait queue\n",context);
1278 printk(KERN_DEBUG" Tasks in wait queue:\n");
1279 for(p1 = adpt_post_wait_queue; p1; p1 = p1->next) {
1280 printk(KERN_DEBUG" %d\n",p1->id);
1281 }
1282 return;
1283 }
1284
1285 static s32 adpt_i2o_reset_hba(adpt_hba* pHba)
1286 {
1287 u32 msg[8];
1288 u8* status;
1289 u32 m = EMPTY_QUEUE ;
1290 ulong timeout = jiffies + (TMOUT_IOPRESET*HZ);
1291
1292 if(pHba->initialized == FALSE) { // First time reset should be quick
1293 timeout = jiffies + (25*HZ);
1294 } else {
1295 adpt_i2o_quiesce_hba(pHba);
1296 }
1297
1298 do {
1299 rmb();
1300 m = readl(pHba->post_port);
1301 if (m != EMPTY_QUEUE) {
1302 break;
1303 }
1304 if(time_after(jiffies,timeout)){
1305 printk(KERN_WARNING"Timeout waiting for message!\n");
1306 return -ETIMEDOUT;
1307 }
1308 schedule_timeout_uninterruptible(1);
1309 } while (m == EMPTY_QUEUE);
1310
1311 status = kzalloc(4, GFP_KERNEL|ADDR32);
1312 if(status == NULL) {
1313 adpt_send_nop(pHba, m);
1314 printk(KERN_ERR"IOP reset failed - no free memory.\n");
1315 return -ENOMEM;
1316 }
1317
1318 msg[0]=EIGHT_WORD_MSG_SIZE|SGL_OFFSET_0;
1319 msg[1]=I2O_CMD_ADAPTER_RESET<<24|HOST_TID<<12|ADAPTER_TID;
1320 msg[2]=0;
1321 msg[3]=0;
1322 msg[4]=0;
1323 msg[5]=0;
1324 msg[6]=virt_to_bus(status);
1325 msg[7]=0;
1326
1327 memcpy_toio(pHba->msg_addr_virt+m, msg, sizeof(msg));
1328 wmb();
1329 writel(m, pHba->post_port);
1330 wmb();
1331
1332 while(*status == 0){
1333 if(time_after(jiffies,timeout)){
1334 printk(KERN_WARNING"%s: IOP Reset Timeout\n",pHba->name);
1335 kfree(status);
1336 return -ETIMEDOUT;
1337 }
1338 rmb();
1339 schedule_timeout_uninterruptible(1);
1340 }
1341
1342 if(*status == 0x01 /*I2O_EXEC_IOP_RESET_IN_PROGRESS*/) {
1343 PDEBUG("%s: Reset in progress...\n", pHba->name);
1344 // Here we wait for message frame to become available
1345 // indicated that reset has finished
1346 do {
1347 rmb();
1348 m = readl(pHba->post_port);
1349 if (m != EMPTY_QUEUE) {
1350 break;
1351 }
1352 if(time_after(jiffies,timeout)){
1353 printk(KERN_ERR "%s:Timeout waiting for IOP Reset.\n",pHba->name);
1354 return -ETIMEDOUT;
1355 }
1356 schedule_timeout_uninterruptible(1);
1357 } while (m == EMPTY_QUEUE);
1358 // Flush the offset
1359 adpt_send_nop(pHba, m);
1360 }
1361 adpt_i2o_status_get(pHba);
1362 if(*status == 0x02 ||
1363 pHba->status_block->iop_state != ADAPTER_STATE_RESET) {
1364 printk(KERN_WARNING"%s: Reset reject, trying to clear\n",
1365 pHba->name);
1366 } else {
1367 PDEBUG("%s: Reset completed.\n", pHba->name);
1368 }
1369
1370 kfree(status);
1371 #ifdef UARTDELAY
1372 // This delay is to allow someone attached to the card through the debug UART to
1373 // set up the dump levels that they want before the rest of the initialization sequence
1374 adpt_delay(20000);
1375 #endif
1376 return 0;
1377 }
1378
1379
1380 static int adpt_i2o_parse_lct(adpt_hba* pHba)
1381 {
1382 int i;
1383 int max;
1384 int tid;
1385 struct i2o_device *d;
1386 i2o_lct *lct = pHba->lct;
1387 u8 bus_no = 0;
1388 s16 scsi_id;
1389 s16 scsi_lun;
1390 u32 buf[10]; // larger than 7, or 8 ...
1391 struct adpt_device* pDev;
1392
1393 if (lct == NULL) {
1394 printk(KERN_ERR "%s: LCT is empty???\n",pHba->name);
1395 return -1;
1396 }
1397
1398 max = lct->table_size;
1399 max -= 3;
1400 max /= 9;
1401
1402 for(i=0;i<max;i++) {
1403 if( lct->lct_entry[i].user_tid != 0xfff){
1404 /*
1405 * If we have hidden devices, we need to inform the upper layers about
1406 * the possible maximum id reference to handle device access when
1407 * an array is disassembled. This code has no other purpose but to
1408 * allow us future access to devices that are currently hidden
1409 * behind arrays, hotspares or have not been configured (JBOD mode).
1410 */
1411 if( lct->lct_entry[i].class_id != I2O_CLASS_RANDOM_BLOCK_STORAGE &&
1412 lct->lct_entry[i].class_id != I2O_CLASS_SCSI_PERIPHERAL &&
1413 lct->lct_entry[i].class_id != I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL ){
1414 continue;
1415 }
1416 tid = lct->lct_entry[i].tid;
1417 // I2O_DPT_DEVICE_INFO_GROUP_NO;
1418 if(adpt_i2o_query_scalar(pHba, tid, 0x8000, -1, buf, 32)<0) {
1419 continue;
1420 }
1421 bus_no = buf[0]>>16;
1422 scsi_id = buf[1];
1423 scsi_lun = (buf[2]>>8 )&0xff;
1424 if(bus_no >= MAX_CHANNEL) { // Something wrong skip it
1425 printk(KERN_WARNING"%s: Channel number %d out of range \n", pHba->name, bus_no);
1426 continue;
1427 }
1428 if (scsi_id >= MAX_ID){
1429 printk(KERN_WARNING"%s: SCSI ID %d out of range \n", pHba->name, bus_no);
1430 continue;
1431 }
1432 if(bus_no > pHba->top_scsi_channel){
1433 pHba->top_scsi_channel = bus_no;
1434 }
1435 if(scsi_id > pHba->top_scsi_id){
1436 pHba->top_scsi_id = scsi_id;
1437 }
1438 if(scsi_lun > pHba->top_scsi_lun){
1439 pHba->top_scsi_lun = scsi_lun;
1440 }
1441 continue;
1442 }
1443 d = kmalloc(sizeof(struct i2o_device), GFP_KERNEL);
1444 if(d==NULL)
1445 {
1446 printk(KERN_CRIT"%s: Out of memory for I2O device data.\n",pHba->name);
1447 return -ENOMEM;
1448 }
1449
1450 d->controller = pHba;
1451 d->next = NULL;
1452
1453 memcpy(&d->lct_data, &lct->lct_entry[i], sizeof(i2o_lct_entry));
1454
1455 d->flags = 0;
1456 tid = d->lct_data.tid;
1457 adpt_i2o_report_hba_unit(pHba, d);
1458 adpt_i2o_install_device(pHba, d);
1459 }
1460 bus_no = 0;
1461 for(d = pHba->devices; d ; d = d->next) {
1462 if(d->lct_data.class_id == I2O_CLASS_BUS_ADAPTER_PORT ||
1463 d->lct_data.class_id == I2O_CLASS_FIBRE_CHANNEL_PORT){
1464 tid = d->lct_data.tid;
1465 // TODO get the bus_no from hrt-but for now they are in order
1466 //bus_no =
1467 if(bus_no > pHba->top_scsi_channel){
1468 pHba->top_scsi_channel = bus_no;
1469 }
1470 pHba->channel[bus_no].type = d->lct_data.class_id;
1471 pHba->channel[bus_no].tid = tid;
1472 if(adpt_i2o_query_scalar(pHba, tid, 0x0200, -1, buf, 28)>=0)
1473 {
1474 pHba->channel[bus_no].scsi_id = buf[1];
1475 PDEBUG("Bus %d - SCSI ID %d.\n", bus_no, buf[1]);
1476 }
1477 // TODO remove - this is just until we get from hrt
1478 bus_no++;
1479 if(bus_no >= MAX_CHANNEL) { // Something wrong skip it
1480 printk(KERN_WARNING"%s: Channel number %d out of range - LCT\n", pHba->name, bus_no);
1481 break;
1482 }
1483 }
1484 }
1485
1486 // Setup adpt_device table
1487 for(d = pHba->devices; d ; d = d->next) {
1488 if(d->lct_data.class_id == I2O_CLASS_RANDOM_BLOCK_STORAGE ||
1489 d->lct_data.class_id == I2O_CLASS_SCSI_PERIPHERAL ||
1490 d->lct_data.class_id == I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL ){
1491
1492 tid = d->lct_data.tid;
1493 scsi_id = -1;
1494 // I2O_DPT_DEVICE_INFO_GROUP_NO;
1495 if(adpt_i2o_query_scalar(pHba, tid, 0x8000, -1, buf, 32)>=0) {
1496 bus_no = buf[0]>>16;
1497 scsi_id = buf[1];
1498 scsi_lun = (buf[2]>>8 )&0xff;
1499 if(bus_no >= MAX_CHANNEL) { // Something wrong skip it
1500 continue;
1501 }
1502 if (scsi_id >= MAX_ID) {
1503 continue;
1504 }
1505 if( pHba->channel[bus_no].device[scsi_id] == NULL){
1506 pDev = kzalloc(sizeof(struct adpt_device),GFP_KERNEL);
1507 if(pDev == NULL) {
1508 return -ENOMEM;
1509 }
1510 pHba->channel[bus_no].device[scsi_id] = pDev;
1511 } else {
1512 for( pDev = pHba->channel[bus_no].device[scsi_id];
1513 pDev->next_lun; pDev = pDev->next_lun){
1514 }
1515 pDev->next_lun = kzalloc(sizeof(struct adpt_device),GFP_KERNEL);
1516 if(pDev->next_lun == NULL) {
1517 return -ENOMEM;
1518 }
1519 pDev = pDev->next_lun;
1520 }
1521 pDev->tid = tid;
1522 pDev->scsi_channel = bus_no;
1523 pDev->scsi_id = scsi_id;
1524 pDev->scsi_lun = scsi_lun;
1525 pDev->pI2o_dev = d;
1526 d->owner = pDev;
1527 pDev->type = (buf[0])&0xff;
1528 pDev->flags = (buf[0]>>8)&0xff;
1529 if(scsi_id > pHba->top_scsi_id){
1530 pHba->top_scsi_id = scsi_id;
1531 }
1532 if(scsi_lun > pHba->top_scsi_lun){
1533 pHba->top_scsi_lun = scsi_lun;
1534 }
1535 }
1536 if(scsi_id == -1){
1537 printk(KERN_WARNING"Could not find SCSI ID for %s\n",
1538 d->lct_data.identity_tag);
1539 }
1540 }
1541 }
1542 return 0;
1543 }
1544
1545
1546 /*
1547 * Each I2O controller has a chain of devices on it - these match
1548 * the useful parts of the LCT of the board.
1549 */
1550
1551 static int adpt_i2o_install_device(adpt_hba* pHba, struct i2o_device *d)
1552 {
1553 mutex_lock(&adpt_configuration_lock);
1554 d->controller=pHba;
1555 d->owner=NULL;
1556 d->next=pHba->devices;
1557 d->prev=NULL;
1558 if (pHba->devices != NULL){
1559 pHba->devices->prev=d;
1560 }
1561 pHba->devices=d;
1562 *d->dev_name = 0;
1563
1564 mutex_unlock(&adpt_configuration_lock);
1565 return 0;
1566 }
1567
1568 static int adpt_open(struct inode *inode, struct file *file)
1569 {
1570 int minor;
1571 adpt_hba* pHba;
1572
1573 //TODO check for root access
1574 //
1575 minor = iminor(inode);
1576 if (minor >= hba_count) {
1577 return -ENXIO;
1578 }
1579 mutex_lock(&adpt_configuration_lock);
1580 for (pHba = hba_chain; pHba; pHba = pHba->next) {
1581 if (pHba->unit == minor) {
1582 break; /* found adapter */
1583 }
1584 }
1585 if (pHba == NULL) {
1586 mutex_unlock(&adpt_configuration_lock);
1587 return -ENXIO;
1588 }
1589
1590 // if(pHba->in_use){
1591 // mutex_unlock(&adpt_configuration_lock);
1592 // return -EBUSY;
1593 // }
1594
1595 pHba->in_use = 1;
1596 mutex_unlock(&adpt_configuration_lock);
1597
1598 return 0;
1599 }
1600
1601 static int adpt_close(struct inode *inode, struct file *file)
1602 {
1603 int minor;
1604 adpt_hba* pHba;
1605
1606 minor = iminor(inode);
1607 if (minor >= hba_count) {
1608 return -ENXIO;
1609 }
1610 mutex_lock(&adpt_configuration_lock);
1611 for (pHba = hba_chain; pHba; pHba = pHba->next) {
1612 if (pHba->unit == minor) {
1613 break; /* found adapter */
1614 }
1615 }
1616 mutex_unlock(&adpt_configuration_lock);
1617 if (pHba == NULL) {
1618 return -ENXIO;
1619 }
1620
1621 pHba->in_use = 0;
1622
1623 return 0;
1624 }
1625
1626
1627 static int adpt_i2o_passthru(adpt_hba* pHba, u32 __user *arg)
1628 {
1629 u32 msg[MAX_MESSAGE_SIZE];
1630 u32* reply = NULL;
1631 u32 size = 0;
1632 u32 reply_size = 0;
1633 u32 __user *user_msg = arg;
1634 u32 __user * user_reply = NULL;
1635 void *sg_list[pHba->sg_tablesize];
1636 u32 sg_offset = 0;
1637 u32 sg_count = 0;
1638 int sg_index = 0;
1639 u32 i = 0;
1640 u32 rcode = 0;
1641 void *p = NULL;
1642 ulong flags = 0;
1643
1644 memset(&msg, 0, MAX_MESSAGE_SIZE*4);
1645 // get user msg size in u32s
1646 if(get_user(size, &user_msg[0])){
1647 return -EFAULT;
1648 }
1649 size = size>>16;
1650
1651 user_reply = &user_msg[size];
1652 if(size > MAX_MESSAGE_SIZE){
1653 return -EFAULT;
1654 }
1655 size *= 4; // Convert to bytes
1656
1657 /* Copy in the user's I2O command */
1658 if(copy_from_user(msg, user_msg, size)) {
1659 return -EFAULT;
1660 }
1661 get_user(reply_size, &user_reply[0]);
1662 reply_size = reply_size>>16;
1663 if(reply_size > REPLY_FRAME_SIZE){
1664 reply_size = REPLY_FRAME_SIZE;
1665 }
1666 reply_size *= 4;
1667 reply = kzalloc(REPLY_FRAME_SIZE*4, GFP_KERNEL);
1668 if(reply == NULL) {
1669 printk(KERN_WARNING"%s: Could not allocate reply buffer\n",pHba->name);
1670 return -ENOMEM;
1671 }
1672 sg_offset = (msg[0]>>4)&0xf;
1673 msg[2] = 0x40000000; // IOCTL context
1674 msg[3] = (u32)reply;
1675 memset(sg_list,0, sizeof(sg_list[0])*pHba->sg_tablesize);
1676 if(sg_offset) {
1677 // TODO 64bit fix
1678 struct sg_simple_element *sg = (struct sg_simple_element*) (msg+sg_offset);
1679 sg_count = (size - sg_offset*4) / sizeof(struct sg_simple_element);
1680 if (sg_count > pHba->sg_tablesize){
1681 printk(KERN_DEBUG"%s:IOCTL SG List too large (%u)\n", pHba->name,sg_count);
1682 kfree (reply);
1683 return -EINVAL;
1684 }
1685
1686 for(i = 0; i < sg_count; i++) {
1687 int sg_size;
1688
1689 if (!(sg[i].flag_count & 0x10000000 /*I2O_SGL_FLAGS_SIMPLE_ADDRESS_ELEMENT*/)) {
1690 printk(KERN_DEBUG"%s:Bad SG element %d - not simple (%x)\n",pHba->name,i, sg[i].flag_count);
1691 rcode = -EINVAL;
1692 goto cleanup;
1693 }
1694 sg_size = sg[i].flag_count & 0xffffff;
1695 /* Allocate memory for the transfer */
1696 p = kmalloc(sg_size, GFP_KERNEL|ADDR32);
1697 if(!p) {
1698 printk(KERN_DEBUG"%s: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
1699 pHba->name,sg_size,i,sg_count);
1700 rcode = -ENOMEM;
1701 goto cleanup;
1702 }
1703 sg_list[sg_index++] = p; // sglist indexed with input frame, not our internal frame.
1704 /* Copy in the user's SG buffer if necessary */
1705 if(sg[i].flag_count & 0x04000000 /*I2O_SGL_FLAGS_DIR*/) {
1706 // TODO 64bit fix
1707 if (copy_from_user(p,(void __user *)sg[i].addr_bus, sg_size)) {
1708 printk(KERN_DEBUG"%s: Could not copy SG buf %d FROM user\n",pHba->name,i);
1709 rcode = -EFAULT;
1710 goto cleanup;
1711 }
1712 }
1713 //TODO 64bit fix
1714 sg[i].addr_bus = (u32)virt_to_bus(p);
1715 }
1716 }
1717
1718 do {
1719 if(pHba->host)
1720 spin_lock_irqsave(pHba->host->host_lock, flags);
1721 // This state stops any new commands from enterring the
1722 // controller while processing the ioctl
1723 // pHba->state |= DPTI_STATE_IOCTL;
1724 // We can't set this now - The scsi subsystem sets host_blocked and
1725 // the queue empties and stops. We need a way to restart the queue
1726 rcode = adpt_i2o_post_wait(pHba, msg, size, FOREVER);
1727 if (rcode != 0)
1728 printk("adpt_i2o_passthru: post wait failed %d %p\n",
1729 rcode, reply);
1730 // pHba->state &= ~DPTI_STATE_IOCTL;
1731 if(pHba->host)
1732 spin_unlock_irqrestore(pHba->host->host_lock, flags);
1733 } while(rcode == -ETIMEDOUT);
1734
1735 if(rcode){
1736 goto cleanup;
1737 }
1738
1739 if(sg_offset) {
1740 /* Copy back the Scatter Gather buffers back to user space */
1741 u32 j;
1742 // TODO 64bit fix
1743 struct sg_simple_element* sg;
1744 int sg_size;
1745
1746 // re-acquire the original message to handle correctly the sg copy operation
1747 memset(&msg, 0, MAX_MESSAGE_SIZE*4);
1748 // get user msg size in u32s
1749 if(get_user(size, &user_msg[0])){
1750 rcode = -EFAULT;
1751 goto cleanup;
1752 }
1753 size = size>>16;
1754 size *= 4;
1755 /* Copy in the user's I2O command */
1756 if (copy_from_user (msg, user_msg, size)) {
1757 rcode = -EFAULT;
1758 goto cleanup;
1759 }
1760 sg_count = (size - sg_offset*4) / sizeof(struct sg_simple_element);
1761
1762 // TODO 64bit fix
1763 sg = (struct sg_simple_element*)(msg + sg_offset);
1764 for (j = 0; j < sg_count; j++) {
1765 /* Copy out the SG list to user's buffer if necessary */
1766 if(! (sg[j].flag_count & 0x4000000 /*I2O_SGL_FLAGS_DIR*/)) {
1767 sg_size = sg[j].flag_count & 0xffffff;
1768 // TODO 64bit fix
1769 if (copy_to_user((void __user *)sg[j].addr_bus,sg_list[j], sg_size)) {
1770 printk(KERN_WARNING"%s: Could not copy %p TO user %x\n",pHba->name, sg_list[j], sg[j].addr_bus);
1771 rcode = -EFAULT;
1772 goto cleanup;
1773 }
1774 }
1775 }
1776 }
1777
1778 /* Copy back the reply to user space */
1779 if (reply_size) {
1780 // we wrote our own values for context - now restore the user supplied ones
1781 if(copy_from_user(reply+2, user_msg+2, sizeof(u32)*2)) {
1782 printk(KERN_WARNING"%s: Could not copy message context FROM user\n",pHba->name);
1783 rcode = -EFAULT;
1784 }
1785 if(copy_to_user(user_reply, reply, reply_size)) {
1786 printk(KERN_WARNING"%s: Could not copy reply TO user\n",pHba->name);
1787 rcode = -EFAULT;
1788 }
1789 }
1790
1791
1792 cleanup:
1793 if (rcode != -ETIME && rcode != -EINTR)
1794 kfree (reply);
1795 while(sg_index) {
1796 if(sg_list[--sg_index]) {
1797 if (rcode != -ETIME && rcode != -EINTR)
1798 kfree(sg_list[sg_index]);
1799 }
1800 }
1801 return rcode;
1802 }
1803
1804
1805 /*
1806 * This routine returns information about the system. This does not effect
1807 * any logic and if the info is wrong - it doesn't matter.
1808 */
1809
1810 /* Get all the info we can not get from kernel services */
1811 static int adpt_system_info(void __user *buffer)
1812 {
1813 sysInfo_S si;
1814
1815 memset(&si, 0, sizeof(si));
1816
1817 si.osType = OS_LINUX;
1818 si.osMajorVersion = 0;
1819 si.osMinorVersion = 0;
1820 si.osRevision = 0;
1821 si.busType = SI_PCI_BUS;
1822 si.processorFamily = DPTI_sig.dsProcessorFamily;
1823
1824 #if defined __i386__
1825 adpt_i386_info(&si);
1826 #elif defined (__ia64__)
1827 adpt_ia64_info(&si);
1828 #elif defined(__sparc__)
1829 adpt_sparc_info(&si);
1830 #elif defined (__alpha__)
1831 adpt_alpha_info(&si);
1832 #else
1833 si.processorType = 0xff ;
1834 #endif
1835 if(copy_to_user(buffer, &si, sizeof(si))){
1836 printk(KERN_WARNING"dpti: Could not copy buffer TO user\n");
1837 return -EFAULT;
1838 }
1839
1840 return 0;
1841 }
1842
1843 #if defined __ia64__
1844 static void adpt_ia64_info(sysInfo_S* si)
1845 {
1846 // This is all the info we need for now
1847 // We will add more info as our new
1848 // managmenent utility requires it
1849 si->processorType = PROC_IA64;
1850 }
1851 #endif
1852
1853
1854 #if defined __sparc__
1855 static void adpt_sparc_info(sysInfo_S* si)
1856 {
1857 // This is all the info we need for now
1858 // We will add more info as our new
1859 // managmenent utility requires it
1860 si->processorType = PROC_ULTRASPARC;
1861 }
1862 #endif
1863
1864 #if defined __alpha__
1865 static void adpt_alpha_info(sysInfo_S* si)
1866 {
1867 // This is all the info we need for now
1868 // We will add more info as our new
1869 // managmenent utility requires it
1870 si->processorType = PROC_ALPHA;
1871 }
1872 #endif
1873
1874 #if defined __i386__
1875
1876 static void adpt_i386_info(sysInfo_S* si)
1877 {
1878 // This is all the info we need for now
1879 // We will add more info as our new
1880 // managmenent utility requires it
1881 switch (boot_cpu_data.x86) {
1882 case CPU_386:
1883 si->processorType = PROC_386;
1884 break;
1885 case CPU_486:
1886 si->processorType = PROC_486;
1887 break;
1888 case CPU_586:
1889 si->processorType = PROC_PENTIUM;
1890 break;
1891 default: // Just in case
1892 si->processorType = PROC_PENTIUM;
1893 break;
1894 }
1895 }
1896
1897 #endif
1898
1899
1900 static int adpt_ioctl(struct inode *inode, struct file *file, uint cmd,
1901 ulong arg)
1902 {
1903 int minor;
1904 int error = 0;
1905 adpt_hba* pHba;
1906 ulong flags = 0;
1907 void __user *argp = (void __user *)arg;
1908
1909 minor = iminor(inode);
1910 if (minor >= DPTI_MAX_HBA){
1911 return -ENXIO;
1912 }
1913 mutex_lock(&adpt_configuration_lock);
1914 for (pHba = hba_chain; pHba; pHba = pHba->next) {
1915 if (pHba->unit == minor) {
1916 break; /* found adapter */
1917 }
1918 }
1919 mutex_unlock(&adpt_configuration_lock);
1920 if(pHba == NULL){
1921 return -ENXIO;
1922 }
1923
1924 while((volatile u32) pHba->state & DPTI_STATE_RESET )
1925 schedule_timeout_uninterruptible(2);
1926
1927 switch (cmd) {
1928 // TODO: handle 3 cases
1929 case DPT_SIGNATURE:
1930 if (copy_to_user(argp, &DPTI_sig, sizeof(DPTI_sig))) {
1931 return -EFAULT;
1932 }
1933 break;
1934 case I2OUSRCMD:
1935 return adpt_i2o_passthru(pHba, argp);
1936
1937 case DPT_CTRLINFO:{
1938 drvrHBAinfo_S HbaInfo;
1939
1940 #define FLG_OSD_PCI_VALID 0x0001
1941 #define FLG_OSD_DMA 0x0002
1942 #define FLG_OSD_I2O 0x0004
1943 memset(&HbaInfo, 0, sizeof(HbaInfo));
1944 HbaInfo.drvrHBAnum = pHba->unit;
1945 HbaInfo.baseAddr = (ulong) pHba->base_addr_phys;
1946 HbaInfo.blinkState = adpt_read_blink_led(pHba);
1947 HbaInfo.pciBusNum = pHba->pDev->bus->number;
1948 HbaInfo.pciDeviceNum=PCI_SLOT(pHba->pDev->devfn);
1949 HbaInfo.Interrupt = pHba->pDev->irq;
1950 HbaInfo.hbaFlags = FLG_OSD_PCI_VALID | FLG_OSD_DMA | FLG_OSD_I2O;
1951 if(copy_to_user(argp, &HbaInfo, sizeof(HbaInfo))){
1952 printk(KERN_WARNING"%s: Could not copy HbaInfo TO user\n",pHba->name);
1953 return -EFAULT;
1954 }
1955 break;
1956 }
1957 case DPT_SYSINFO:
1958 return adpt_system_info(argp);
1959 case DPT_BLINKLED:{
1960 u32 value;
1961 value = (u32)adpt_read_blink_led(pHba);
1962 if (copy_to_user(argp, &value, sizeof(value))) {
1963 return -EFAULT;
1964 }
1965 break;
1966 }
1967 case I2ORESETCMD:
1968 if(pHba->host)
1969 spin_lock_irqsave(pHba->host->host_lock, flags);
1970 adpt_hba_reset(pHba);
1971 if(pHba->host)
1972 spin_unlock_irqrestore(pHba->host->host_lock, flags);
1973 break;
1974 case I2ORESCANCMD:
1975 adpt_rescan(pHba);
1976 break;
1977 default:
1978 return -EINVAL;
1979 }
1980
1981 return error;
1982 }
1983
1984
1985 static irqreturn_t adpt_isr(int irq, void *dev_id)
1986 {
1987 struct scsi_cmnd* cmd;
1988 adpt_hba* pHba = dev_id;
1989 u32 m;
1990 void __iomem *reply;
1991 u32 status=0;
1992 u32 context;
1993 ulong flags = 0;
1994 int handled = 0;
1995
1996 if (pHba == NULL){
1997 printk(KERN_WARNING"adpt_isr: NULL dev_id\n");
1998 return IRQ_NONE;
1999 }
2000 if(pHba->host)
2001 spin_lock_irqsave(pHba->host->host_lock, flags);
2002
2003 while( readl(pHba->irq_mask) & I2O_INTERRUPT_PENDING_B) {
2004 m = readl(pHba->reply_port);
2005 if(m == EMPTY_QUEUE){
2006 // Try twice then give up
2007 rmb();
2008 m = readl(pHba->reply_port);
2009 if(m == EMPTY_QUEUE){
2010 // This really should not happen
2011 printk(KERN_ERR"dpti: Could not get reply frame\n");
2012 goto out;
2013 }
2014 }
2015 reply = bus_to_virt(m);
2016
2017 if (readl(reply) & MSG_FAIL) {
2018 u32 old_m = readl(reply+28);
2019 void __iomem *msg;
2020 u32 old_context;
2021 PDEBUG("%s: Failed message\n",pHba->name);
2022 if(old_m >= 0x100000){
2023 printk(KERN_ERR"%s: Bad preserved MFA (%x)- dropping frame\n",pHba->name,old_m);
2024 writel(m,pHba->reply_port);
2025 continue;
2026 }
2027 // Transaction context is 0 in failed reply frame
2028 msg = pHba->msg_addr_virt + old_m;
2029 old_context = readl(msg+12);
2030 writel(old_context, reply+12);
2031 adpt_send_nop(pHba, old_m);
2032 }
2033 context = readl(reply+8);
2034 if(context & 0x40000000){ // IOCTL
2035 void *p = (void *)readl(reply+12);
2036 if( p != NULL) {
2037 memcpy_fromio(p, reply, REPLY_FRAME_SIZE * 4);
2038 }
2039 // All IOCTLs will also be post wait
2040 }
2041 if(context & 0x80000000){ // Post wait message
2042 status = readl(reply+16);
2043 if(status >> 24){
2044 status &= 0xffff; /* Get detail status */
2045 } else {
2046 status = I2O_POST_WAIT_OK;
2047 }
2048 if(!(context & 0x40000000)) {
2049 cmd = (struct scsi_cmnd*) readl(reply+12);
2050 if(cmd != NULL) {
2051 printk(KERN_WARNING"%s: Apparent SCSI cmd in Post Wait Context - cmd=%p context=%x\n", pHba->name, cmd, context);
2052 }
2053 }
2054 adpt_i2o_post_wait_complete(context, status);
2055 } else { // SCSI message
2056 cmd = (struct scsi_cmnd*) readl(reply+12);
2057 if(cmd != NULL){
2058 if(cmd->serial_number != 0) { // If not timedout
2059 adpt_i2o_to_scsi(reply, cmd);
2060 }
2061 }
2062 }
2063 writel(m, pHba->reply_port);
2064 wmb();
2065 rmb();
2066 }
2067 handled = 1;
2068 out: if(pHba->host)
2069 spin_unlock_irqrestore(pHba->host->host_lock, flags);
2070 return IRQ_RETVAL(handled);
2071 }
2072
2073 static s32 adpt_scsi_to_i2o(adpt_hba* pHba, struct scsi_cmnd* cmd, struct adpt_device* d)
2074 {
2075 int i;
2076 u32 msg[MAX_MESSAGE_SIZE];
2077 u32* mptr;
2078 u32 *lenptr;
2079 int direction;
2080 int scsidir;
2081 u32 len;
2082 u32 reqlen;
2083 s32 rcode;
2084
2085 memset(msg, 0 , sizeof(msg));
2086 len = cmd->request_bufflen;
2087 direction = 0x00000000;
2088
2089 scsidir = 0x00000000; // DATA NO XFER
2090 if(len) {
2091 /*
2092 * Set SCBFlags to indicate if data is being transferred
2093 * in or out, or no data transfer
2094 * Note: Do not have to verify index is less than 0 since
2095 * cmd->cmnd[0] is an unsigned char
2096 */
2097 switch(cmd->sc_data_direction){
2098 case DMA_FROM_DEVICE:
2099 scsidir =0x40000000; // DATA IN (iop<--dev)
2100 break;
2101 case DMA_TO_DEVICE:
2102 direction=0x04000000; // SGL OUT
2103 scsidir =0x80000000; // DATA OUT (iop-->dev)
2104 break;
2105 case DMA_NONE:
2106 break;
2107 case DMA_BIDIRECTIONAL:
2108 scsidir =0x40000000; // DATA IN (iop<--dev)
2109 // Assume In - and continue;
2110 break;
2111 default:
2112 printk(KERN_WARNING"%s: scsi opcode 0x%x not supported.\n",
2113 pHba->name, cmd->cmnd[0]);
2114 cmd->result = (DID_OK <<16) | (INITIATOR_ERROR << 8);
2115 cmd->scsi_done(cmd);
2116 return 0;
2117 }
2118 }
2119 // msg[0] is set later
2120 // I2O_CMD_SCSI_EXEC
2121 msg[1] = ((0xff<<24)|(HOST_TID<<12)|d->tid);
2122 msg[2] = 0;
2123 msg[3] = (u32)cmd; /* We want the SCSI control block back */
2124 // Our cards use the transaction context as the tag for queueing
2125 // Adaptec/DPT Private stuff
2126 msg[4] = I2O_CMD_SCSI_EXEC|(DPT_ORGANIZATION_ID<<16);
2127 msg[5] = d->tid;
2128 /* Direction, disconnect ok | sense data | simple queue , CDBLen */
2129 // I2O_SCB_FLAG_ENABLE_DISCONNECT |
2130 // I2O_SCB_FLAG_SIMPLE_QUEUE_TAG |
2131 // I2O_SCB_FLAG_SENSE_DATA_IN_MESSAGE;
2132 msg[6] = scsidir|0x20a00000|cmd->cmd_len;
2133
2134 mptr=msg+7;
2135
2136 // Write SCSI command into the message - always 16 byte block
2137 memset(mptr, 0, 16);
2138 memcpy(mptr, cmd->cmnd, cmd->cmd_len);
2139 mptr+=4;
2140 lenptr=mptr++; /* Remember me - fill in when we know */
2141 reqlen = 14; // SINGLE SGE
2142 /* Now fill in the SGList and command */
2143 if(cmd->use_sg) {
2144 struct scatterlist *sg = (struct scatterlist *)cmd->request_buffer;
2145 int sg_count = pci_map_sg(pHba->pDev, sg, cmd->use_sg,
2146 cmd->sc_data_direction);
2147
2148
2149 len = 0;
2150 for(i = 0 ; i < sg_count; i++) {
2151 *mptr++ = direction|0x10000000|sg_dma_len(sg);
2152 len+=sg_dma_len(sg);
2153 *mptr++ = sg_dma_address(sg);
2154 sg++;
2155 }
2156 /* Make this an end of list */
2157 mptr[-2] = direction|0xD0000000|sg_dma_len(sg-1);
2158 reqlen = mptr - msg;
2159 *lenptr = len;
2160
2161 if(cmd->underflow && len != cmd->underflow){
2162 printk(KERN_WARNING"Cmd len %08X Cmd underflow %08X\n",
2163 len, cmd->underflow);
2164 }
2165 } else {
2166 *lenptr = len = cmd->request_bufflen;
2167 if(len == 0) {
2168 reqlen = 12;
2169 } else {
2170 *mptr++ = 0xD0000000|direction|cmd->request_bufflen;
2171 *mptr++ = pci_map_single(pHba->pDev,
2172 cmd->request_buffer,
2173 cmd->request_bufflen,
2174 cmd->sc_data_direction);
2175 }
2176 }
2177
2178 /* Stick the headers on */
2179 msg[0] = reqlen<<16 | ((reqlen > 12) ? SGL_OFFSET_12 : SGL_OFFSET_0);
2180
2181 // Send it on it's way
2182 rcode = adpt_i2o_post_this(pHba, msg, reqlen<<2);
2183 if (rcode == 0) {
2184 return 0;
2185 }
2186 return rcode;
2187 }
2188
2189
2190 static s32 adpt_scsi_register(adpt_hba* pHba,struct scsi_host_template * sht)
2191 {
2192 struct Scsi_Host *host = NULL;
2193
2194 host = scsi_register(sht, sizeof(adpt_hba*));
2195 if (host == NULL) {
2196 printk ("%s: scsi_register returned NULL\n",pHba->name);
2197 return -1;
2198 }
2199 host->hostdata[0] = (unsigned long)pHba;
2200 pHba->host = host;
2201
2202 host->irq = pHba->pDev->irq;
2203 /* no IO ports, so don't have to set host->io_port and
2204 * host->n_io_port
2205 */
2206 host->io_port = 0;
2207 host->n_io_port = 0;
2208 /* see comments in scsi_host.h */
2209 host->max_id = 16;
2210 host->max_lun = 256;
2211 host->max_channel = pHba->top_scsi_channel + 1;
2212 host->cmd_per_lun = 1;
2213 host->unique_id = (uint) pHba;
2214 host->sg_tablesize = pHba->sg_tablesize;
2215 host->can_queue = pHba->post_fifo_size;
2216
2217 return 0;
2218 }
2219
2220
2221 static s32 adpt_i2o_to_scsi(void __iomem *reply, struct scsi_cmnd* cmd)
2222 {
2223 adpt_hba* pHba;
2224 u32 hba_status;
2225 u32 dev_status;
2226 u32 reply_flags = readl(reply) & 0xff00; // Leave it shifted up 8 bits
2227 // I know this would look cleaner if I just read bytes
2228 // but the model I have been using for all the rest of the
2229 // io is in 4 byte words - so I keep that model
2230 u16 detailed_status = readl(reply+16) &0xffff;
2231 dev_status = (detailed_status & 0xff);
2232 hba_status = detailed_status >> 8;
2233
2234 // calculate resid for sg
2235 cmd->resid = cmd->request_bufflen - readl(reply+5);
2236
2237 pHba = (adpt_hba*) cmd->device->host->hostdata[0];
2238
2239 cmd->sense_buffer[0] = '\0'; // initialize sense valid flag to false
2240
2241 if(!(reply_flags & MSG_FAIL)) {
2242 switch(detailed_status & I2O_SCSI_DSC_MASK) {
2243 case I2O_SCSI_DSC_SUCCESS:
2244 cmd->result = (DID_OK << 16);
2245 // handle underflow
2246 if(readl(reply+5) < cmd->underflow ) {
2247 cmd->result = (DID_ERROR <<16);
2248 printk(KERN_WARNING"%s: SCSI CMD underflow\n",pHba->name);
2249 }
2250 break;
2251 case I2O_SCSI_DSC_REQUEST_ABORTED:
2252 cmd->result = (DID_ABORT << 16);
2253 break;
2254 case I2O_SCSI_DSC_PATH_INVALID:
2255 case I2O_SCSI_DSC_DEVICE_NOT_PRESENT:
2256 case I2O_SCSI_DSC_SELECTION_TIMEOUT:
2257 case I2O_SCSI_DSC_COMMAND_TIMEOUT:
2258 case I2O_SCSI_DSC_NO_ADAPTER:
2259 case I2O_SCSI_DSC_RESOURCE_UNAVAILABLE:
2260 printk(KERN_WARNING"%s: SCSI Timeout-Device (%d,%d,%d) hba status=0x%x, dev status=0x%x, cmd=0x%x\n",
2261 pHba->name, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun, hba_status, dev_status, cmd->cmnd[0]);
2262 cmd->result = (DID_TIME_OUT << 16);
2263 break;
2264 case I2O_SCSI_DSC_ADAPTER_BUSY:
2265 case I2O_SCSI_DSC_BUS_BUSY:
2266 cmd->result = (DID_BUS_BUSY << 16);
2267 break;
2268 case I2O_SCSI_DSC_SCSI_BUS_RESET:
2269 case I2O_SCSI_DSC_BDR_MESSAGE_SENT:
2270 cmd->result = (DID_RESET << 16);
2271 break;
2272 case I2O_SCSI_DSC_PARITY_ERROR_FAILURE:
2273 printk(KERN_WARNING"%s: SCSI CMD parity error\n",pHba->name);
2274 cmd->result = (DID_PARITY << 16);
2275 break;
2276 case I2O_SCSI_DSC_UNABLE_TO_ABORT:
2277 case I2O_SCSI_DSC_COMPLETE_WITH_ERROR:
2278 case I2O_SCSI_DSC_UNABLE_TO_TERMINATE:
2279 case I2O_SCSI_DSC_MR_MESSAGE_RECEIVED:
2280 case I2O_SCSI_DSC_AUTOSENSE_FAILED:
2281 case I2O_SCSI_DSC_DATA_OVERRUN:
2282 case I2O_SCSI_DSC_UNEXPECTED_BUS_FREE:
2283 case I2O_SCSI_DSC_SEQUENCE_FAILURE:
2284 case I2O_SCSI_DSC_REQUEST_LENGTH_ERROR:
2285 case I2O_SCSI_DSC_PROVIDE_FAILURE:
2286 case I2O_SCSI_DSC_REQUEST_TERMINATED:
2287 case I2O_SCSI_DSC_IDE_MESSAGE_SENT:
2288 case I2O_SCSI_DSC_UNACKNOWLEDGED_EVENT:
2289 case I2O_SCSI_DSC_MESSAGE_RECEIVED:
2290 case I2O_SCSI_DSC_INVALID_CDB:
2291 case I2O_SCSI_DSC_LUN_INVALID:
2292 case I2O_SCSI_DSC_SCSI_TID_INVALID:
2293 case I2O_SCSI_DSC_FUNCTION_UNAVAILABLE:
2294 case I2O_SCSI_DSC_NO_NEXUS:
2295 case I2O_SCSI_DSC_CDB_RECEIVED:
2296 case I2O_SCSI_DSC_LUN_ALREADY_ENABLED:
2297 case I2O_SCSI_DSC_QUEUE_FROZEN:
2298 case I2O_SCSI_DSC_REQUEST_INVALID:
2299 default:
2300 printk(KERN_WARNING"%s: SCSI error %0x-Device(%d,%d,%d) hba_status=0x%x, dev_status=0x%x, cmd=0x%x\n",
2301 pHba->name, detailed_status & I2O_SCSI_DSC_MASK, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun,
2302 hba_status, dev_status, cmd->cmnd[0]);
2303 cmd->result = (DID_ERROR << 16);
2304 break;
2305 }
2306
2307 // copy over the request sense data if it was a check
2308 // condition status
2309 if (dev_status == 0x02 /*CHECK_CONDITION*/) {
2310 u32 len = min(SCSI_SENSE_BUFFERSIZE, 40);
2311 // Copy over the sense data
2312 memcpy_fromio(cmd->sense_buffer, (reply+28) , len);
2313 if(cmd->sense_buffer[0] == 0x70 /* class 7 */ &&
2314 cmd->sense_buffer[2] == DATA_PROTECT ){
2315 /* This is to handle an array failed */
2316 cmd->result = (DID_TIME_OUT << 16);
2317 printk(KERN_WARNING"%s: SCSI Data Protect-Device (%d,%d,%d) hba_status=0x%x, dev_status=0x%x, cmd=0x%x\n",
2318 pHba->name, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun,
2319 hba_status, dev_status, cmd->cmnd[0]);
2320
2321 }
2322 }
2323 } else {
2324 /* In this condtion we could not talk to the tid
2325 * the card rejected it. We should signal a retry
2326 * for a limitted number of retries.
2327 */
2328 cmd->result = (DID_TIME_OUT << 16);
2329 printk(KERN_WARNING"%s: I2O MSG_FAIL - Device (%d,%d,%d) tid=%d, cmd=0x%x\n",
2330 pHba->name, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun,
2331 ((struct adpt_device*)(cmd->device->hostdata))->tid, cmd->cmnd[0]);
2332 }
2333
2334 cmd->result |= (dev_status);
2335
2336 if(cmd->scsi_done != NULL){
2337 cmd->scsi_done(cmd);
2338 }
2339 return cmd->result;
2340 }
2341
2342
2343 static s32 adpt_rescan(adpt_hba* pHba)
2344 {
2345 s32 rcode;
2346 ulong flags = 0;
2347
2348 if(pHba->host)
2349 spin_lock_irqsave(pHba->host->host_lock, flags);
2350 if ((rcode=adpt_i2o_lct_get(pHba)) < 0)
2351 goto out;
2352 if ((rcode=adpt_i2o_reparse_lct(pHba)) < 0)
2353 goto out;
2354 rcode = 0;
2355 out: if(pHba->host)
2356 spin_unlock_irqrestore(pHba->host->host_lock, flags);
2357 return rcode;
2358 }
2359
2360
2361 static s32 adpt_i2o_reparse_lct(adpt_hba* pHba)
2362 {
2363 int i;
2364 int max;
2365 int tid;
2366 struct i2o_device *d;
2367 i2o_lct *lct = pHba->lct;
2368 u8 bus_no = 0;
2369 s16 scsi_id;
2370 s16 scsi_lun;
2371 u32 buf[10]; // at least 8 u32's
2372 struct adpt_device* pDev = NULL;
2373 struct i2o_device* pI2o_dev = NULL;
2374
2375 if (lct == NULL) {
2376 printk(KERN_ERR "%s: LCT is empty???\n",pHba->name);
2377 return -1;
2378 }
2379
2380 max = lct->table_size;
2381 max -= 3;
2382 max /= 9;
2383
2384 // Mark each drive as unscanned
2385 for (d = pHba->devices; d; d = d->next) {
2386 pDev =(struct adpt_device*) d->owner;
2387 if(!pDev){
2388 continue;
2389 }
2390 pDev->state |= DPTI_DEV_UNSCANNED;
2391 }
2392
2393 printk(KERN_INFO "%s: LCT has %d entries.\n", pHba->name,max);
2394
2395 for(i=0;i<max;i++) {
2396 if( lct->lct_entry[i].user_tid != 0xfff){
2397 continue;
2398 }
2399
2400 if( lct->lct_entry[i].class_id == I2O_CLASS_RANDOM_BLOCK_STORAGE ||
2401 lct->lct_entry[i].class_id == I2O_CLASS_SCSI_PERIPHERAL ||
2402 lct->lct_entry[i].class_id == I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL ){
2403 tid = lct->lct_entry[i].tid;
2404 if(adpt_i2o_query_scalar(pHba, tid, 0x8000, -1, buf, 32)<0) {
2405 printk(KERN_ERR"%s: Could not query device\n",pHba->name);
2406 continue;
2407 }
2408 bus_no = buf[0]>>16;
2409 scsi_id = buf[1];
2410 scsi_lun = (buf[2]>>8 )&0xff;
2411 pDev = pHba->channel[bus_no].device[scsi_id];
2412 /* da lun */
2413 while(pDev) {
2414 if(pDev->scsi_lun == scsi_lun) {
2415 break;
2416 }
2417 pDev = pDev->next_lun;
2418 }
2419 if(!pDev ) { // Something new add it
2420 d = kmalloc(sizeof(struct i2o_device), GFP_KERNEL);
2421 if(d==NULL)
2422 {
2423 printk(KERN_CRIT "Out of memory for I2O device data.\n");
2424 return -ENOMEM;
2425 }
2426
2427 d->controller = pHba;
2428 d->next = NULL;
2429
2430 memcpy(&d->lct_data, &lct->lct_entry[i], sizeof(i2o_lct_entry));
2431
2432 d->flags = 0;
2433 adpt_i2o_report_hba_unit(pHba, d);
2434 adpt_i2o_install_device(pHba, d);
2435
2436 if(bus_no >= MAX_CHANNEL) { // Something wrong skip it
2437 printk(KERN_WARNING"%s: Channel number %d out of range \n", pHba->name, bus_no);
2438 continue;
2439 }
2440 pDev = pHba->channel[bus_no].device[scsi_id];
2441 if( pDev == NULL){
2442 pDev = kzalloc(sizeof(struct adpt_device),GFP_KERNEL);
2443 if(pDev == NULL) {
2444 return -ENOMEM;
2445 }
2446 pHba->channel[bus_no].device[scsi_id] = pDev;
2447 } else {
2448 while (pDev->next_lun) {
2449 pDev = pDev->next_lun;
2450 }
2451 pDev = pDev->next_lun = kzalloc(sizeof(struct adpt_device),GFP_KERNEL);
2452 if(pDev == NULL) {
2453 return -ENOMEM;
2454 }
2455 }
2456 pDev->tid = d->lct_data.tid;
2457 pDev->scsi_channel = bus_no;
2458 pDev->scsi_id = scsi_id;
2459 pDev->scsi_lun = scsi_lun;
2460 pDev->pI2o_dev = d;
2461 d->owner = pDev;
2462 pDev->type = (buf[0])&0xff;
2463 pDev->flags = (buf[0]>>8)&0xff;
2464 // Too late, SCSI system has made up it's mind, but what the hey ...
2465 if(scsi_id > pHba->top_scsi_id){
2466 pHba->top_scsi_id = scsi_id;
2467 }
2468 if(scsi_lun > pHba->top_scsi_lun){
2469 pHba->top_scsi_lun = scsi_lun;
2470 }
2471 continue;
2472 } // end of new i2o device
2473
2474 // We found an old device - check it
2475 while(pDev) {
2476 if(pDev->scsi_lun == scsi_lun) {
2477 if(!scsi_device_online(pDev->pScsi_dev)) {
2478 printk(KERN_WARNING"%s: Setting device (%d,%d,%d) back online\n",
2479 pHba->name,bus_no,scsi_id,scsi_lun);
2480 if (pDev->pScsi_dev) {
2481 scsi_device_set_state(pDev->pScsi_dev, SDEV_RUNNING);
2482 }
2483 }
2484 d = pDev->pI2o_dev;
2485 if(d->lct_data.tid != tid) { // something changed
2486 pDev->tid = tid;
2487 memcpy(&d->lct_data, &lct->lct_entry[i], sizeof(i2o_lct_entry));
2488 if (pDev->pScsi_dev) {
2489 pDev->pScsi_dev->changed = TRUE;
2490 pDev->pScsi_dev->removable = TRUE;
2491 }
2492 }
2493 // Found it - mark it scanned
2494 pDev->state = DPTI_DEV_ONLINE;
2495 break;
2496 }
2497 pDev = pDev->next_lun;
2498 }
2499 }
2500 }
2501 for (pI2o_dev = pHba->devices; pI2o_dev; pI2o_dev = pI2o_dev->next) {
2502 pDev =(struct adpt_device*) pI2o_dev->owner;
2503 if(!pDev){
2504 continue;
2505 }
2506 // Drive offline drives that previously existed but could not be found
2507 // in the LCT table
2508 if (pDev->state & DPTI_DEV_UNSCANNED){
2509 pDev->state = DPTI_DEV_OFFLINE;
2510 printk(KERN_WARNING"%s: Device (%d,%d,%d) offline\n",pHba->name,pDev->scsi_channel,pDev->scsi_id,pDev->scsi_lun);
2511 if (pDev->pScsi_dev) {
2512 scsi_device_set_state(pDev->pScsi_dev, SDEV_OFFLINE);
2513 }
2514 }
2515 }
2516 return 0;
2517 }
2518
2519 static void adpt_fail_posted_scbs(adpt_hba* pHba)
2520 {
2521 struct scsi_cmnd* cmd = NULL;
2522 struct scsi_device* d = NULL;
2523
2524 shost_for_each_device(d, pHba->host) {
2525 unsigned long flags;
2526 spin_lock_irqsave(&d->list_lock, flags);
2527 list_for_each_entry(cmd, &d->cmd_list, list) {
2528 if(cmd->serial_number == 0){
2529 continue;
2530 }
2531 cmd->result = (DID_OK << 16) | (QUEUE_FULL <<1);
2532 cmd->scsi_done(cmd);
2533 }
2534 spin_unlock_irqrestore(&d->list_lock, flags);
2535 }
2536 }
2537
2538
2539 /*============================================================================
2540 * Routines from i2o subsystem
2541 *============================================================================
2542 */
2543
2544
2545
2546 /*
2547 * Bring an I2O controller into HOLD state. See the spec.
2548 */
2549 static int adpt_i2o_activate_hba(adpt_hba* pHba)
2550 {
2551 int rcode;
2552
2553 if(pHba->initialized ) {
2554 if (adpt_i2o_status_get(pHba) < 0) {
2555 if((rcode = adpt_i2o_reset_hba(pHba)) != 0){
2556 printk(KERN_WARNING"%s: Could NOT reset.\n", pHba->name);
2557 return rcode;
2558 }
2559 if (adpt_i2o_status_get(pHba) < 0) {
2560 printk(KERN_INFO "HBA not responding.\n");
2561 return -1;
2562 }
2563 }
2564
2565 if(pHba->status_block->iop_state == ADAPTER_STATE_FAULTED) {
2566 printk(KERN_CRIT "%s: hardware fault\n", pHba->name);
2567 return -1;
2568 }
2569
2570 if (pHba->status_block->iop_state == ADAPTER_STATE_READY ||
2571 pHba->status_block->iop_state == ADAPTER_STATE_OPERATIONAL ||
2572 pHba->status_block->iop_state == ADAPTER_STATE_HOLD ||
2573 pHba->status_block->iop_state == ADAPTER_STATE_FAILED) {
2574 adpt_i2o_reset_hba(pHba);
2575 if (adpt_i2o_status_get(pHba) < 0 || pHba->status_block->iop_state != ADAPTER_STATE_RESET) {
2576 printk(KERN_ERR "%s: Failed to initialize.\n", pHba->name);
2577 return -1;
2578 }
2579 }
2580 } else {
2581 if((rcode = adpt_i2o_reset_hba(pHba)) != 0){
2582 printk(KERN_WARNING"%s: Could NOT reset.\n", pHba->name);
2583 return rcode;
2584 }
2585
2586 }
2587
2588 if (adpt_i2o_init_outbound_q(pHba) < 0) {
2589 return -1;
2590 }
2591
2592 /* In HOLD state */
2593
2594 if (adpt_i2o_hrt_get(pHba) < 0) {
2595 return -1;
2596 }
2597
2598 return 0;
2599 }
2600
2601 /*
2602 * Bring a controller online into OPERATIONAL state.
2603 */
2604
2605 static int adpt_i2o_online_hba(adpt_hba* pHba)
2606 {
2607 if (adpt_i2o_systab_send(pHba) < 0) {
2608 adpt_i2o_delete_hba(pHba);
2609 return -1;
2610 }
2611 /* In READY state */
2612
2613 if (adpt_i2o_enable_hba(pHba) < 0) {
2614 adpt_i2o_delete_hba(pHba);
2615 return -1;
2616 }
2617
2618 /* In OPERATIONAL state */
2619 return 0;
2620 }
2621
2622 static s32 adpt_send_nop(adpt_hba*pHba,u32 m)
2623 {
2624 u32 __iomem *msg;
2625 ulong timeout = jiffies + 5*HZ;
2626
2627 while(m == EMPTY_QUEUE){
2628 rmb();
2629 m = readl(pHba->post_port);
2630 if(m != EMPTY_QUEUE){
2631 break;
2632 }
2633 if(time_after(jiffies,timeout)){
2634 printk(KERN_ERR "%s: Timeout waiting for message frame!\n",pHba->name);
2635 return 2;
2636 }
2637 schedule_timeout_uninterruptible(1);
2638 }
2639 msg = (u32 __iomem *)(pHba->msg_addr_virt + m);
2640 writel( THREE_WORD_MSG_SIZE | SGL_OFFSET_0,&msg[0]);
2641 writel( I2O_CMD_UTIL_NOP << 24 | HOST_TID << 12 | 0,&msg[1]);
2642 writel( 0,&msg[2]);
2643 wmb();
2644
2645 writel(m, pHba->post_port);
2646 wmb();
2647 return 0;
2648 }
2649
2650 static s32 adpt_i2o_init_outbound_q(adpt_hba* pHba)
2651 {
2652 u8 *status;
2653 u32 __iomem *msg = NULL;
2654 int i;
2655 ulong timeout = jiffies + TMOUT_INITOUTBOUND*HZ;
2656 u32* ptr;
2657 u32 outbound_frame; // This had to be a 32 bit address
2658 u32 m;
2659
2660 do {
2661 rmb();
2662 m = readl(pHba->post_port);
2663 if (m != EMPTY_QUEUE) {
2664 break;
2665 }
2666
2667 if(time_after(jiffies,timeout)){
2668 printk(KERN_WARNING"%s: Timeout waiting for message frame\n",pHba->name);
2669 return -ETIMEDOUT;
2670 }
2671 schedule_timeout_uninterruptible(1);
2672 } while(m == EMPTY_QUEUE);
2673
2674 msg=(u32 __iomem *)(pHba->msg_addr_virt+m);
2675
2676 status = kmalloc(4,GFP_KERNEL|ADDR32);
2677 if (status==NULL) {
2678 adpt_send_nop(pHba, m);
2679 printk(KERN_WARNING"%s: IOP reset failed - no free memory.\n",
2680 pHba->name);
2681 return -ENOMEM;
2682 }
2683 memset(status, 0, 4);
2684
2685 writel(EIGHT_WORD_MSG_SIZE| SGL_OFFSET_6, &msg[0]);
2686 writel(I2O_CMD_OUTBOUND_INIT<<24 | HOST_TID<<12 | ADAPTER_TID, &msg[1]);
2687 writel(0, &msg[2]);
2688 writel(0x0106, &msg[3]); /* Transaction context */
2689 writel(4096, &msg[4]); /* Host page frame size */
2690 writel((REPLY_FRAME_SIZE)<<16|0x80, &msg[5]); /* Outbound msg frame size and Initcode */
2691 writel(0xD0000004, &msg[6]); /* Simple SG LE, EOB */
2692 writel(virt_to_bus(status), &msg[7]);
2693
2694 writel(m, pHba->post_port);
2695 wmb();
2696
2697 // Wait for the reply status to come back
2698 do {
2699 if (*status) {
2700 if (*status != 0x01 /*I2O_EXEC_OUTBOUND_INIT_IN_PROGRESS*/) {
2701 break;
2702 }
2703 }
2704 rmb();
2705 if(time_after(jiffies,timeout)){
2706 printk(KERN_WARNING"%s: Timeout Initializing\n",pHba->name);
2707 return -ETIMEDOUT;
2708 }
2709 schedule_timeout_uninterruptible(1);
2710 } while (1);
2711
2712 // If the command was successful, fill the fifo with our reply
2713 // message packets
2714 if(*status != 0x04 /*I2O_EXEC_OUTBOUND_INIT_COMPLETE*/) {
2715 kfree(status);
2716 return -2;
2717 }
2718 kfree(status);
2719
2720 kfree(pHba->reply_pool);
2721
2722 pHba->reply_pool = kmalloc(pHba->reply_fifo_size * REPLY_FRAME_SIZE * 4, GFP_KERNEL|ADDR32);
2723 if(!pHba->reply_pool){
2724 printk(KERN_ERR"%s: Could not allocate reply pool\n",pHba->name);
2725 return -1;
2726 }
2727 memset(pHba->reply_pool, 0 , pHba->reply_fifo_size * REPLY_FRAME_SIZE * 4);
2728
2729 ptr = pHba->reply_pool;
2730 for(i = 0; i < pHba->reply_fifo_size; i++) {
2731 outbound_frame = (u32)virt_to_bus(ptr);
2732 writel(outbound_frame, pHba->reply_port);
2733 wmb();
2734 ptr += REPLY_FRAME_SIZE;
2735 }
2736 adpt_i2o_status_get(pHba);
2737 return 0;
2738 }
2739
2740
2741 /*
2742 * I2O System Table. Contains information about
2743 * all the IOPs in the system. Used to inform IOPs
2744 * about each other's existence.
2745 *
2746 * sys_tbl_ver is the CurrentChangeIndicator that is
2747 * used by IOPs to track changes.
2748 */
2749
2750
2751
2752 static s32 adpt_i2o_status_get(adpt_hba* pHba)
2753 {
2754 ulong timeout;
2755 u32 m;
2756 u32 __iomem *msg;
2757 u8 *status_block=NULL;
2758 ulong status_block_bus;
2759
2760 if(pHba->status_block == NULL) {
2761 pHba->status_block = (i2o_status_block*)
2762 kmalloc(sizeof(i2o_status_block),GFP_KERNEL|ADDR32);
2763 if(pHba->status_block == NULL) {
2764 printk(KERN_ERR
2765 "dpti%d: Get Status Block failed; Out of memory. \n",
2766 pHba->unit);
2767 return -ENOMEM;
2768 }
2769 }
2770 memset(pHba->status_block, 0, sizeof(i2o_status_block));
2771 status_block = (u8*)(pHba->status_block);
2772 status_block_bus = virt_to_bus(pHba->status_block);
2773 timeout = jiffies+TMOUT_GETSTATUS*HZ;
2774 do {
2775 rmb();
2776 m = readl(pHba->post_port);
2777 if (m != EMPTY_QUEUE) {
2778 break;
2779 }
2780 if(time_after(jiffies,timeout)){
2781 printk(KERN_ERR "%s: Timeout waiting for message !\n",
2782 pHba->name);
2783 return -ETIMEDOUT;
2784 }
2785 schedule_timeout_uninterruptible(1);
2786 } while(m==EMPTY_QUEUE);
2787
2788
2789 msg=(u32 __iomem *)(pHba->msg_addr_virt+m);
2790
2791 writel(NINE_WORD_MSG_SIZE|SGL_OFFSET_0, &msg[0]);
2792 writel(I2O_CMD_STATUS_GET<<24|HOST_TID<<12|ADAPTER_TID, &msg[1]);
2793 writel(1, &msg[2]);
2794 writel(0, &msg[3]);
2795 writel(0, &msg[4]);
2796 writel(0, &msg[5]);
2797 writel(((u32)status_block_bus)&0xffffffff, &msg[6]);
2798 writel(0, &msg[7]);
2799 writel(sizeof(i2o_status_block), &msg[8]); // 88 bytes
2800
2801 //post message
2802 writel(m, pHba->post_port);
2803 wmb();
2804
2805 while(status_block[87]!=0xff){
2806 if(time_after(jiffies,timeout)){
2807 printk(KERN_ERR"dpti%d: Get status timeout.\n",
2808 pHba->unit);
2809 return -ETIMEDOUT;
2810 }
2811 rmb();
2812 schedule_timeout_uninterruptible(1);
2813 }
2814
2815 // Set up our number of outbound and inbound messages
2816 pHba->post_fifo_size = pHba->status_block->max_inbound_frames;
2817 if (pHba->post_fifo_size > MAX_TO_IOP_MESSAGES) {
2818 pHba->post_fifo_size = MAX_TO_IOP_MESSAGES;
2819 }
2820
2821 pHba->reply_fifo_size = pHba->status_block->max_outbound_frames;
2822 if (pHba->reply_fifo_size > MAX_FROM_IOP_MESSAGES) {
2823 pHba->reply_fifo_size = MAX_FROM_IOP_MESSAGES;
2824 }
2825
2826 // Calculate the Scatter Gather list size
2827 pHba->sg_tablesize = (pHba->status_block->inbound_frame_size * 4 -40)/ sizeof(struct sg_simple_element);
2828 if (pHba->sg_tablesize > SG_LIST_ELEMENTS) {
2829 pHba->sg_tablesize = SG_LIST_ELEMENTS;
2830 }
2831
2832
2833 #ifdef DEBUG
2834 printk("dpti%d: State = ",pHba->unit);
2835 switch(pHba->status_block->iop_state) {
2836 case 0x01:
2837 printk("INIT\n");
2838 break;
2839 case 0x02:
2840 printk("RESET\n");
2841 break;
2842 case 0x04:
2843 printk("HOLD\n");
2844 break;
2845 case 0x05:
2846 printk("READY\n");
2847 break;
2848 case 0x08:
2849 printk("OPERATIONAL\n");
2850 break;
2851 case 0x10:
2852 printk("FAILED\n");
2853 break;
2854 case 0x11:
2855 printk("FAULTED\n");
2856 break;
2857 default:
2858 printk("%x (unknown!!)\n",pHba->status_block->iop_state);
2859 }
2860 #endif
2861 return 0;
2862 }
2863
2864 /*
2865 * Get the IOP's Logical Configuration Table
2866 */
2867 static int adpt_i2o_lct_get(adpt_hba* pHba)
2868 {
2869 u32 msg[8];
2870 int ret;
2871 u32 buf[16];
2872
2873 if ((pHba->lct_size == 0) || (pHba->lct == NULL)){
2874 pHba->lct_size = pHba->status_block->expected_lct_size;
2875 }
2876 do {
2877 if (pHba->lct == NULL) {
2878 pHba->lct = kmalloc(pHba->lct_size, GFP_KERNEL|ADDR32);
2879 if(pHba->lct == NULL) {
2880 printk(KERN_CRIT "%s: Lct Get failed. Out of memory.\n",
2881 pHba->name);
2882 return -ENOMEM;
2883 }
2884 }
2885 memset(pHba->lct, 0, pHba->lct_size);
2886
2887 msg[0] = EIGHT_WORD_MSG_SIZE|SGL_OFFSET_6;
2888 msg[1] = I2O_CMD_LCT_NOTIFY<<24 | HOST_TID<<12 | ADAPTER_TID;
2889 msg[2] = 0;
2890 msg[3] = 0;
2891 msg[4] = 0xFFFFFFFF; /* All devices */
2892 msg[5] = 0x00000000; /* Report now */
2893 msg[6] = 0xD0000000|pHba->lct_size;
2894 msg[7] = virt_to_bus(pHba->lct);
2895
2896 if ((ret=adpt_i2o_post_wait(pHba, msg, sizeof(msg), 360))) {
2897 printk(KERN_ERR "%s: LCT Get failed (status=%#10x.\n",
2898 pHba->name, ret);
2899 printk(KERN_ERR"Adaptec: Error Reading Hardware.\n");
2900 return ret;
2901 }
2902
2903 if ((pHba->lct->table_size << 2) > pHba->lct_size) {
2904 pHba->lct_size = pHba->lct->table_size << 2;
2905 kfree(pHba->lct);
2906 pHba->lct = NULL;
2907 }
2908 } while (pHba->lct == NULL);
2909
2910 PDEBUG("%s: Hardware resource table read.\n", pHba->name);
2911
2912
2913 // I2O_DPT_EXEC_IOP_BUFFERS_GROUP_NO;
2914 if(adpt_i2o_query_scalar(pHba, 0 , 0x8000, -1, buf, sizeof(buf))>=0) {
2915 pHba->FwDebugBufferSize = buf[1];
2916 pHba->FwDebugBuffer_P = pHba->base_addr_virt + buf[0];
2917 pHba->FwDebugFlags_P = pHba->FwDebugBuffer_P + FW_DEBUG_FLAGS_OFFSET;
2918 pHba->FwDebugBLEDvalue_P = pHba->FwDebugBuffer_P + FW_DEBUG_BLED_OFFSET;
2919 pHba->FwDebugBLEDflag_P = pHba->FwDebugBLEDvalue_P + 1;
2920 pHba->FwDebugStrLength_P = pHba->FwDebugBuffer_P + FW_DEBUG_STR_LENGTH_OFFSET;
2921 pHba->FwDebugBuffer_P += buf[2];
2922 pHba->FwDebugFlags = 0;
2923 }
2924
2925 return 0;
2926 }
2927
2928 static int adpt_i2o_build_sys_table(void)
2929 {
2930 adpt_hba* pHba = NULL;
2931 int count = 0;
2932
2933 sys_tbl_len = sizeof(struct i2o_sys_tbl) + // Header + IOPs
2934 (hba_count) * sizeof(struct i2o_sys_tbl_entry);
2935
2936 kfree(sys_tbl);
2937
2938 sys_tbl = kmalloc(sys_tbl_len, GFP_KERNEL|ADDR32);
2939 if(!sys_tbl) {
2940 printk(KERN_WARNING "SysTab Set failed. Out of memory.\n");
2941 return -ENOMEM;
2942 }
2943 memset(sys_tbl, 0, sys_tbl_len);
2944
2945 sys_tbl->num_entries = hba_count;
2946 sys_tbl->version = I2OVERSION;
2947 sys_tbl->change_ind = sys_tbl_ind++;
2948
2949 for(pHba = hba_chain; pHba; pHba = pHba->next) {
2950 // Get updated Status Block so we have the latest information
2951 if (adpt_i2o_status_get(pHba)) {
2952 sys_tbl->num_entries--;
2953 continue; // try next one
2954 }
2955
2956 sys_tbl->iops[count].org_id = pHba->status_block->org_id;
2957 sys_tbl->iops[count].iop_id = pHba->unit + 2;
2958 sys_tbl->iops[count].seg_num = 0;
2959 sys_tbl->iops[count].i2o_version = pHba->status_block->i2o_version;
2960 sys_tbl->iops[count].iop_state = pHba->status_block->iop_state;
2961 sys_tbl->iops[count].msg_type = pHba->status_block->msg_type;
2962 sys_tbl->iops[count].frame_size = pHba->status_block->inbound_frame_size;
2963 sys_tbl->iops[count].last_changed = sys_tbl_ind - 1; // ??
2964 sys_tbl->iops[count].iop_capabilities = pHba->status_block->iop_capabilities;
2965 sys_tbl->iops[count].inbound_low = (u32)virt_to_bus(pHba->post_port);
2966 sys_tbl->iops[count].inbound_high = (u32)((u64)virt_to_bus(pHba->post_port)>>32);
2967
2968 count++;
2969 }
2970
2971 #ifdef DEBUG
2972 {
2973 u32 *table = (u32*)sys_tbl;
2974 printk(KERN_DEBUG"sys_tbl_len=%d in 32bit words\n",(sys_tbl_len >>2));
2975 for(count = 0; count < (sys_tbl_len >>2); count++) {
2976 printk(KERN_INFO "sys_tbl[%d] = %0#10x\n",
2977 count, table[count]);
2978 }
2979 }
2980 #endif
2981
2982 return 0;
2983 }
2984
2985
2986 /*
2987 * Dump the information block associated with a given unit (TID)
2988 */
2989
2990 static void adpt_i2o_report_hba_unit(adpt_hba* pHba, struct i2o_device *d)
2991 {
2992 char buf[64];
2993 int unit = d->lct_data.tid;
2994
2995 printk(KERN_INFO "TID %3.3d ", unit);
2996
2997 if(adpt_i2o_query_scalar(pHba, unit, 0xF100, 3, buf, 16)>=0)
2998 {
2999 buf[16]=0;
3000 printk(" Vendor: %-12.12s", buf);
3001 }
3002 if(adpt_i2o_query_scalar(pHba, unit, 0xF100, 4, buf, 16)>=0)
3003 {
3004 buf[16]=0;
3005 printk(" Device: %-12.12s", buf);
3006 }
3007 if(adpt_i2o_query_scalar(pHba, unit, 0xF100, 6, buf, 8)>=0)
3008 {
3009 buf[8]=0;
3010 printk(" Rev: %-12.12s\n", buf);
3011 }
3012 #ifdef DEBUG
3013 printk(KERN_INFO "\tClass: %.21s\n", adpt_i2o_get_class_name(d->lct_data.class_id));
3014 printk(KERN_INFO "\tSubclass: 0x%04X\n", d->lct_data.sub_class);
3015 printk(KERN_INFO "\tFlags: ");
3016
3017 if(d->lct_data.device_flags&(1<<0))
3018 printk("C"); // ConfigDialog requested
3019 if(d->lct_data.device_flags&(1<<1))
3020 printk("U"); // Multi-user capable
3021 if(!(d->lct_data.device_flags&(1<<4)))
3022 printk("P"); // Peer service enabled!
3023 if(!(d->lct_data.device_flags&(1<<5)))
3024 printk("M"); // Mgmt service enabled!
3025 printk("\n");
3026 #endif
3027 }
3028
3029 #ifdef DEBUG
3030 /*
3031 * Do i2o class name lookup
3032 */
3033 static const char *adpt_i2o_get_class_name(int class)
3034 {
3035 int idx = 16;
3036 static char *i2o_class_name[] = {
3037 "Executive",
3038 "Device Driver Module",
3039 "Block Device",
3040 "Tape Device",
3041 "LAN Interface",
3042 "WAN Interface",
3043 "Fibre Channel Port",
3044 "Fibre Channel Device",
3045 "SCSI Device",
3046 "ATE Port",
3047 "ATE Device",
3048 "Floppy Controller",
3049 "Floppy Device",
3050 "Secondary Bus Port",
3051 "Peer Transport Agent",
3052 "Peer Transport",
3053 "Unknown"
3054 };
3055
3056 switch(class&0xFFF) {
3057 case I2O_CLASS_EXECUTIVE:
3058 idx = 0; break;
3059 case I2O_CLASS_DDM:
3060 idx = 1; break;
3061 case I2O_CLASS_RANDOM_BLOCK_STORAGE:
3062 idx = 2; break;
3063 case I2O_CLASS_SEQUENTIAL_STORAGE:
3064 idx = 3; break;
3065 case I2O_CLASS_LAN:
3066 idx = 4; break;
3067 case I2O_CLASS_WAN:
3068 idx = 5; break;
3069 case I2O_CLASS_FIBRE_CHANNEL_PORT:
3070 idx = 6; break;
3071 case I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL:
3072 idx = 7; break;
3073 case I2O_CLASS_SCSI_PERIPHERAL:
3074 idx = 8; break;
3075 case I2O_CLASS_ATE_PORT:
3076 idx = 9; break;
3077 case I2O_CLASS_ATE_PERIPHERAL:
3078 idx = 10; break;
3079 case I2O_CLASS_FLOPPY_CONTROLLER:
3080 idx = 11; break;
3081 case I2O_CLASS_FLOPPY_DEVICE:
3082 idx = 12; break;
3083 case I2O_CLASS_BUS_ADAPTER_PORT:
3084 idx = 13; break;
3085 case I2O_CLASS_PEER_TRANSPORT_AGENT:
3086 idx = 14; break;
3087 case I2O_CLASS_PEER_TRANSPORT:
3088 idx = 15; break;
3089 }
3090 return i2o_class_name[idx];
3091 }
3092 #endif
3093
3094
3095 static s32 adpt_i2o_hrt_get(adpt_hba* pHba)
3096 {
3097 u32 msg[6];
3098 int ret, size = sizeof(i2o_hrt);
3099
3100 do {
3101 if (pHba->hrt == NULL) {
3102 pHba->hrt=kmalloc(size, GFP_KERNEL|ADDR32);
3103 if (pHba->hrt == NULL) {
3104 printk(KERN_CRIT "%s: Hrt Get failed; Out of memory.\n", pHba->name);
3105 return -ENOMEM;
3106 }
3107 }
3108
3109 msg[0]= SIX_WORD_MSG_SIZE| SGL_OFFSET_4;
3110 msg[1]= I2O_CMD_HRT_GET<<24 | HOST_TID<<12 | ADAPTER_TID;
3111 msg[2]= 0;
3112 msg[3]= 0;
3113 msg[4]= (0xD0000000 | size); /* Simple transaction */
3114 msg[5]= virt_to_bus(pHba->hrt); /* Dump it here */
3115
3116 if ((ret = adpt_i2o_post_wait(pHba, msg, sizeof(msg),20))) {
3117 printk(KERN_ERR "%s: Unable to get HRT (status=%#10x)\n", pHba->name, ret);
3118 return ret;
3119 }
3120
3121 if (pHba->hrt->num_entries * pHba->hrt->entry_len << 2 > size) {
3122 size = pHba->hrt->num_entries * pHba->hrt->entry_len << 2;
3123 kfree(pHba->hrt);
3124 pHba->hrt = NULL;
3125 }
3126 } while(pHba->hrt == NULL);
3127 return 0;
3128 }
3129
3130 /*
3131 * Query one scalar group value or a whole scalar group.
3132 */
3133 static int adpt_i2o_query_scalar(adpt_hba* pHba, int tid,
3134 int group, int field, void *buf, int buflen)
3135 {
3136 u16 opblk[] = { 1, 0, I2O_PARAMS_FIELD_GET, group, 1, field };
3137 u8 *resblk;
3138
3139 int size;
3140
3141 /* 8 bytes for header */
3142 resblk = kmalloc(sizeof(u8) * (8+buflen), GFP_KERNEL|ADDR32);
3143 if (resblk == NULL) {
3144 printk(KERN_CRIT "%s: query scalar failed; Out of memory.\n", pHba->name);
3145 return -ENOMEM;
3146 }
3147
3148 if (field == -1) /* whole group */
3149 opblk[4] = -1;
3150
3151 size = adpt_i2o_issue_params(I2O_CMD_UTIL_PARAMS_GET, pHba, tid,
3152 opblk, sizeof(opblk), resblk, sizeof(u8)*(8+buflen));
3153 if (size == -ETIME) {
3154 printk(KERN_WARNING "%s: issue params failed; Timed out.\n", pHba->name);
3155 return -ETIME;
3156 } else if (size == -EINTR) {
3157 printk(KERN_WARNING "%s: issue params failed; Interrupted.\n", pHba->name);
3158 return -EINTR;
3159 }
3160
3161 memcpy(buf, resblk+8, buflen); /* cut off header */
3162
3163 kfree(resblk);
3164 if (size < 0)
3165 return size;
3166
3167 return buflen;
3168 }
3169
3170
3171 /* Issue UTIL_PARAMS_GET or UTIL_PARAMS_SET
3172 *
3173 * This function can be used for all UtilParamsGet/Set operations.
3174 * The OperationBlock is given in opblk-buffer,
3175 * and results are returned in resblk-buffer.
3176 * Note that the minimum sized resblk is 8 bytes and contains
3177 * ResultCount, ErrorInfoSize, BlockStatus and BlockSize.
3178 */
3179 static int adpt_i2o_issue_params(int cmd, adpt_hba* pHba, int tid,
3180 void *opblk, int oplen, void *resblk, int reslen)
3181 {
3182 u32 msg[9];
3183 u32 *res = (u32 *)resblk;
3184 int wait_status;
3185
3186 msg[0] = NINE_WORD_MSG_SIZE | SGL_OFFSET_5;
3187 msg[1] = cmd << 24 | HOST_TID << 12 | tid;
3188 msg[2] = 0;
3189 msg[3] = 0;
3190 msg[4] = 0;
3191 msg[5] = 0x54000000 | oplen; /* OperationBlock */
3192 msg[6] = virt_to_bus(opblk);
3193 msg[7] = 0xD0000000 | reslen; /* ResultBlock */
3194 msg[8] = virt_to_bus(resblk);
3195
3196 if ((wait_status = adpt_i2o_post_wait(pHba, msg, sizeof(msg), 20))) {
3197 printk("adpt_i2o_issue_params: post_wait failed (%p)\n", resblk);
3198 return wait_status; /* -DetailedStatus */
3199 }
3200
3201 if (res[1]&0x00FF0000) { /* BlockStatus != SUCCESS */
3202 printk(KERN_WARNING "%s: %s - Error:\n ErrorInfoSize = 0x%02x, "
3203 "BlockStatus = 0x%02x, BlockSize = 0x%04x\n",
3204 pHba->name,
3205 (cmd == I2O_CMD_UTIL_PARAMS_SET) ? "PARAMS_SET"
3206 : "PARAMS_GET",
3207 res[1]>>24, (res[1]>>16)&0xFF, res[1]&0xFFFF);
3208 return -((res[1] >> 16) & 0xFF); /* -BlockStatus */
3209 }
3210
3211 return 4 + ((res[1] & 0x0000FFFF) << 2); /* bytes used in resblk */
3212 }
3213
3214
3215 static s32 adpt_i2o_quiesce_hba(adpt_hba* pHba)
3216 {
3217 u32 msg[4];
3218 int ret;
3219
3220 adpt_i2o_status_get(pHba);
3221
3222 /* SysQuiesce discarded if IOP not in READY or OPERATIONAL state */
3223
3224 if((pHba->status_block->iop_state != ADAPTER_STATE_READY) &&
3225 (pHba->status_block->iop_state != ADAPTER_STATE_OPERATIONAL)){
3226 return 0;
3227 }
3228
3229 msg[0] = FOUR_WORD_MSG_SIZE|SGL_OFFSET_0;
3230 msg[1] = I2O_CMD_SYS_QUIESCE<<24|HOST_TID<<12|ADAPTER_TID;
3231 msg[2] = 0;
3232 msg[3] = 0;
3233
3234 if((ret = adpt_i2o_post_wait(pHba, msg, sizeof(msg), 240))) {
3235 printk(KERN_INFO"dpti%d: Unable to quiesce (status=%#x).\n",
3236 pHba->unit, -ret);
3237 } else {
3238 printk(KERN_INFO"dpti%d: Quiesced.\n",pHba->unit);
3239 }
3240
3241 adpt_i2o_status_get(pHba);
3242 return ret;
3243 }
3244
3245
3246 /*
3247 * Enable IOP. Allows the IOP to resume external operations.
3248 */
3249 static int adpt_i2o_enable_hba(adpt_hba* pHba)
3250 {
3251 u32 msg[4];
3252 int ret;
3253
3254 adpt_i2o_status_get(pHba);
3255 if(!pHba->status_block){
3256 return -ENOMEM;
3257 }
3258 /* Enable only allowed on READY state */
3259 if(pHba->status_block->iop_state == ADAPTER_STATE_OPERATIONAL)
3260 return 0;
3261
3262 if(pHba->status_block->iop_state != ADAPTER_STATE_READY)
3263 return -EINVAL;
3264
3265 msg[0]=FOUR_WORD_MSG_SIZE|SGL_OFFSET_0;
3266 msg[1]=I2O_CMD_SYS_ENABLE<<24|HOST_TID<<12|ADAPTER_TID;
3267 msg[2]= 0;
3268 msg[3]= 0;
3269
3270 if ((ret = adpt_i2o_post_wait(pHba, msg, sizeof(msg), 240))) {
3271 printk(KERN_WARNING"%s: Could not enable (status=%#10x).\n",
3272 pHba->name, ret);
3273 } else {
3274 PDEBUG("%s: Enabled.\n", pHba->name);
3275 }
3276
3277 adpt_i2o_status_get(pHba);
3278 return ret;
3279 }
3280
3281
3282 static int adpt_i2o_systab_send(adpt_hba* pHba)
3283 {
3284 u32 msg[12];
3285 int ret;
3286
3287 msg[0] = I2O_MESSAGE_SIZE(12) | SGL_OFFSET_6;
3288 msg[1] = I2O_CMD_SYS_TAB_SET<<24 | HOST_TID<<12 | ADAPTER_TID;
3289 msg[2] = 0;
3290 msg[3] = 0;
3291 msg[4] = (0<<16) | ((pHba->unit+2) << 12); /* Host 0 IOP ID (unit + 2) */
3292 msg[5] = 0; /* Segment 0 */
3293
3294 /*
3295 * Provide three SGL-elements:
3296 * System table (SysTab), Private memory space declaration and
3297 * Private i/o space declaration
3298 */
3299 msg[6] = 0x54000000 | sys_tbl_len;
3300 msg[7] = virt_to_phys(sys_tbl);
3301 msg[8] = 0x54000000 | 0;
3302 msg[9] = 0;
3303 msg[10] = 0xD4000000 | 0;
3304 msg[11] = 0;
3305
3306 if ((ret=adpt_i2o_post_wait(pHba, msg, sizeof(msg), 120))) {
3307 printk(KERN_INFO "%s: Unable to set SysTab (status=%#10x).\n",
3308 pHba->name, ret);
3309 }
3310 #ifdef DEBUG
3311 else {
3312 PINFO("%s: SysTab set.\n", pHba->name);
3313 }
3314 #endif
3315
3316 return ret;
3317 }
3318
3319
3320 /*============================================================================
3321 *
3322 *============================================================================
3323 */
3324
3325
3326 #ifdef UARTDELAY
3327
3328 static static void adpt_delay(int millisec)
3329 {
3330 int i;
3331 for (i = 0; i < millisec; i++) {
3332 udelay(1000); /* delay for one millisecond */
3333 }
3334 }
3335
3336 #endif
3337
3338 static struct scsi_host_template driver_template = {
3339 .name = "dpt_i2o",
3340 .proc_name = "dpt_i2o",
3341 .proc_info = adpt_proc_info,
3342 .detect = adpt_detect,
3343 .release = adpt_release,
3344 .info = adpt_info,
3345 .queuecommand = adpt_queue,
3346 .eh_abort_handler = adpt_abort,
3347 .eh_device_reset_handler = adpt_device_reset,
3348 .eh_bus_reset_handler = adpt_bus_reset,
3349 .eh_host_reset_handler = adpt_reset,
3350 .bios_param = adpt_bios_param,
3351 .slave_configure = adpt_slave_configure,
3352 .can_queue = MAX_TO_IOP_MESSAGES,
3353 .this_id = 7,
3354 .cmd_per_lun = 1,
3355 .use_clustering = ENABLE_CLUSTERING,
3356 };
3357 #include "scsi_module.c"
3358 MODULE_LICENSE("GPL");
Tomato firmware and modifications.