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