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