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