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