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