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