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