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