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