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