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