drivers/scsi/dpt_i2o.c

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