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