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