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