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 <asm/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 static struct pci_device_id dptids[] = {
 184         { PCI_DPT_VENDOR_ID, PCI_DPT_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
 185         { PCI_DPT_VENDOR_ID, PCI_DPT_RAPTOR_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
 186         { 0, }
 187 };
 188 MODULE_DEVICE_TABLE(pci,dptids);
 189
 190 static int adpt_detect(struct scsi_host_template* sht)
 191 {
 192         struct pci_dev *pDev = NULL;
 193         adpt_hba *pHba;
 194         adpt_hba *next;
 195
 196         PINFO("Detecting Adaptec I2O RAID controllers...\n");
 197
 198         /* search for all Adatpec I2O RAID cards */
 199         while ((pDev = pci_get_device( PCI_DPT_VENDOR_ID, PCI_ANY_ID, pDev))) {
 200                 if(pDev->device == PCI_DPT_DEVICE_ID ||
 201                    pDev->device == PCI_DPT_RAPTOR_DEVICE_ID){
 202                         if(adpt_install_hba(sht, pDev) ){
 203                                 PERROR("Could not Init an I2O RAID device\n");
 204                                 PERROR("Will not try to detect others.\n");
 205                                 return hba_count-1;
 206                         }
 207                         pci_dev_get(pDev);
 208                 }
 209         }
 210
 211         /* In INIT state, Activate IOPs */
 212         for (pHba = hba_chain; pHba; pHba = next) {
 213                 next = pHba->next;
 214                 // Activate does get status , init outbound, and get hrt
 215                 if (adpt_i2o_activate_hba(pHba) < 0) {
 216                         adpt_i2o_delete_hba(pHba);
 217                 }
 218         }
 219
 220
 221         /* Active IOPs in HOLD state */
 222
 223 rebuild_sys_tab:
 224         if (hba_chain == NULL)
 225                 return 0;
 226
 227         /*
 228          * If build_sys_table fails, we kill everything and bail
 229          * as we can't init the IOPs w/o a system table
 230          */
 231         if (adpt_i2o_build_sys_table() < 0) {
 232                 adpt_i2o_sys_shutdown();
 233                 return 0;
 234         }
 235
 236         PDEBUG("HBA's in HOLD state\n");
 237
 238         /* If IOP don't get online, we need to rebuild the System table */
 239         for (pHba = hba_chain; pHba; pHba = pHba->next) {
 240                 if (adpt_i2o_online_hba(pHba) < 0) {
 241                         adpt_i2o_delete_hba(pHba);
 242                         goto rebuild_sys_tab;
 243                 }
 244         }
 245
 246         /* Active IOPs now in OPERATIONAL state */
 247         PDEBUG("HBA's in OPERATIONAL state\n");
 248
 249         printk("dpti: If you have a lot of devices this could take a few minutes.\n");
 250         for (pHba = hba_chain; pHba; pHba = next) {
 251                 next = pHba->next;
 252                 printk(KERN_INFO"%s: Reading the hardware resource table.\n", pHba->name);
 253                 if (adpt_i2o_lct_get(pHba) < 0){
 254                         adpt_i2o_delete_hba(pHba);
 255                         continue;
 256                 }
 257
 258                 if (adpt_i2o_parse_lct(pHba) < 0){
 259                         adpt_i2o_delete_hba(pHba);
 260                         continue;
 261                 }
 262                 adpt_inquiry(pHba);
 263         }
 264
 265         adpt_sysfs_class = class_create(THIS_MODULE, "dpt_i2o");
 266         if (IS_ERR(adpt_sysfs_class)) {
 267                 printk(KERN_WARNING"dpti: unable to create dpt_i2o class\n");
 268                 adpt_sysfs_class = NULL;
 269         }
 270
 271         for (pHba = hba_chain; pHba; pHba = next) {
 272                 next = pHba->next;
 273                 if (adpt_scsi_host_alloc(pHba, sht) < 0){
 274                         adpt_i2o_delete_hba(pHba);
 275                         continue;
 276                 }
 277                 pHba->initialized = TRUE;
 278                 pHba->state &= ~DPTI_STATE_RESET;
 279                 if (adpt_sysfs_class) {
 280                         struct device *dev = device_create(adpt_sysfs_class,
 281                                 NULL, MKDEV(DPTI_I2O_MAJOR, pHba->unit), NULL,
 282                                 "dpti%d", pHba->unit);
 283                         if (IS_ERR(dev)) {
 284                                 printk(KERN_WARNING"dpti%d: unable to "
 285                                         "create device in dpt_i2o class\n",
 286                                         pHba->unit);
 287                         }
 288                 }
 289         }
 290
 291         // Register our control device node
 292         // nodes will need to be created in /dev to access this
 293         // the nodes can not be created from within the driver
 294         if (hba_count && register_chrdev(DPTI_I2O_MAJOR, DPT_DRIVER, &adpt_fops)) {
 295                 adpt_i2o_sys_shutdown();
 296                 return 0;
 297         }
 298         return hba_count;
 299 }
 300
 301
 302 /*
 303  * scsi_unregister will be called AFTER we return.
 304  */
 305 static int adpt_release(struct Scsi_Host *host)
 306 {
 307         adpt_hba* pHba = (adpt_hba*) host->hostdata[0];
 308 //      adpt_i2o_quiesce_hba(pHba);
 309         adpt_i2o_delete_hba(pHba);
 310         scsi_unregister(host);
 311         return 0;
 312 }
 313
 314
 315 static void adpt_inquiry(adpt_hba* pHba)
 316 {
 317         u32 msg[17];
 318         u32 *mptr;
 319         u32 *lenptr;
 320         int direction;
 321         int scsidir;
 322         u32 len;
 323         u32 reqlen;
 324         u8* buf;
 325         dma_addr_t addr;
 326         u8  scb[16];
 327         s32 rcode;
 328
 329         memset(msg, 0, sizeof(msg));
 330         buf = dma_alloc_coherent(&pHba->pDev->dev, 80, &addr, GFP_KERNEL);
 331         if(!buf){
 332                 printk(KERN_ERR"%s: Could not allocate buffer\n",pHba->name);
 333                 return;
 334         }
 335         memset((void*)buf, 0, 36);
 336
 337         len = 36;
 338         direction = 0x00000000;
 339         scsidir  =0x40000000;   // DATA IN  (iop<--dev)
 340
 341         if (dpt_dma64(pHba))
 342                 reqlen = 17;            // SINGLE SGE, 64 bit
 343         else
 344                 reqlen = 14;            // SINGLE SGE, 32 bit
 345         /* Stick the headers on */
 346         msg[0] = reqlen<<16 | SGL_OFFSET_12;
 347         msg[1] = (0xff<<24|HOST_TID<<12|ADAPTER_TID);
 348         msg[2] = 0;
 349         msg[3]  = 0;
 350         // Adaptec/DPT Private stuff
 351         msg[4] = I2O_CMD_SCSI_EXEC|DPT_ORGANIZATION_ID<<16;
 352         msg[5] = ADAPTER_TID | 1<<16 /* Interpret*/;
 353         /* Direction, disconnect ok | sense data | simple queue , CDBLen */
 354         // I2O_SCB_FLAG_ENABLE_DISCONNECT |
 355         // I2O_SCB_FLAG_SIMPLE_QUEUE_TAG |
 356         // I2O_SCB_FLAG_SENSE_DATA_IN_MESSAGE;
 357         msg[6] = scsidir|0x20a00000| 6 /* cmd len*/;
 358
 359         mptr=msg+7;
 360
 361         memset(scb, 0, sizeof(scb));
 362         // Write SCSI command into the message - always 16 byte block
 363         scb[0] = INQUIRY;
 364         scb[1] = 0;
 365         scb[2] = 0;
 366         scb[3] = 0;
 367         scb[4] = 36;
 368         scb[5] = 0;
 369         // Don't care about the rest of scb
 370
 371         memcpy(mptr, scb, sizeof(scb));
 372         mptr+=4;
 373         lenptr=mptr++;          /* Remember me - fill in when we know */
 374
 375         /* Now fill in the SGList and command */
 376         *lenptr = len;
 377         if (dpt_dma64(pHba)) {
 378                 *mptr++ = (0x7C<<24)+(2<<16)+0x02; /* Enable 64 bit */
 379                 *mptr++ = 1 << PAGE_SHIFT;
 380                 *mptr++ = 0xD0000000|direction|len;
 381                 *mptr++ = dma_low(addr);
 382                 *mptr++ = dma_high(addr);
 383         } else {
 384                 *mptr++ = 0xD0000000|direction|len;
 385                 *mptr++ = addr;
 386         }
 387
 388         // Send it on it's way
 389         rcode = adpt_i2o_post_wait(pHba, msg, reqlen<<2, 120);
 390         if (rcode != 0) {
 391                 sprintf(pHba->detail, "Adaptec I2O RAID");
 392                 printk(KERN_INFO "%s: Inquiry Error (%d)\n",pHba->name,rcode);
 393                 if (rcode != -ETIME && rcode != -EINTR)
 394                         dma_free_coherent(&pHba->pDev->dev, 80, buf, addr);
 395         } else {
 396                 memset(pHba->detail, 0, sizeof(pHba->detail));
 397                 memcpy(&(pHba->detail), "Vendor: Adaptec ", 16);
 398                 memcpy(&(pHba->detail[16]), " Model: ", 8);
 399                 memcpy(&(pHba->detail[24]), (u8*) &buf[16], 16);
 400                 memcpy(&(pHba->detail[40]), " FW: ", 4);
 401                 memcpy(&(pHba->detail[44]), (u8*) &buf[32], 4);
 402                 pHba->detail[48] = '\0';        /* precautionary */
 403                 dma_free_coherent(&pHba->pDev->dev, 80, buf, addr);
 404         }
 405         adpt_i2o_status_get(pHba);
 406         return ;
 407 }
 408
 409
 410 static int adpt_slave_configure(struct scsi_device * device)
 411 {
 412         struct Scsi_Host *host = device->host;
 413         adpt_hba* pHba;
 414
 415         pHba = (adpt_hba *) host->hostdata[0];
 416
 417         if (host->can_queue && device->tagged_supported) {
 418                 scsi_adjust_queue_depth(device, MSG_SIMPLE_TAG,
 419                                 host->can_queue - 1);
 420         } else {
 421                 scsi_adjust_queue_depth(device, 0, 1);
 422         }
 423         return 0;
 424 }
 425
 426 static int adpt_queue_lck(struct scsi_cmnd * cmd, void (*done) (struct scsi_cmnd *))
 427 {
 428         adpt_hba* pHba = NULL;
 429         struct adpt_device* pDev = NULL;        /* dpt per device information */
 430
 431         cmd->scsi_done = done;
 432         /*
 433          * SCSI REQUEST_SENSE commands will be executed automatically by the
 434          * Host Adapter for any errors, so they should not be executed
 435          * explicitly unless the Sense Data is zero indicating that no error
 436          * occurred.
 437          */
 438
 439         if ((cmd->cmnd[0] == REQUEST_SENSE) && (cmd->sense_buffer[0] != 0)) {
 440                 cmd->result = (DID_OK << 16);
 441                 cmd->scsi_done(cmd);
 442                 return 0;
 443         }
 444
 445         pHba = (adpt_hba*)cmd->device->host->hostdata[0];
 446         if (!pHba) {
 447                 return FAILED;
 448         }
 449
 450         rmb();
 451         if ((pHba->state) & DPTI_STATE_RESET)
 452                 return SCSI_MLQUEUE_HOST_BUSY;
 453
 454         // TODO if the cmd->device if offline then I may need to issue a bus rescan
 455         // followed by a get_lct to see if the device is there anymore
 456         if((pDev = (struct adpt_device*) (cmd->device->hostdata)) == NULL) {
 457                 /*
 458                  * First command request for this device.  Set up a pointer
 459                  * to the device structure.  This should be a TEST_UNIT_READY
 460                  * command from scan_scsis_single.
 461                  */
 462                 if ((pDev = adpt_find_device(pHba, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun)) == NULL) {
 463                         // TODO: if any luns are at this bus, scsi id then fake a TEST_UNIT_READY and INQUIRY response
 464                         // with type 7F (for all luns less than the max for this bus,id) so the lun scan will continue.
 465                         cmd->result = (DID_NO_CONNECT << 16);
 466                         cmd->scsi_done(cmd);
 467                         return 0;
 468                 }
 469                 cmd->device->hostdata = pDev;
 470         }
 471         pDev->pScsi_dev = cmd->device;
 472
 473         /*
 474          * If we are being called from when the device is being reset,
 475          * delay processing of the command until later.
 476          */
 477         if (pDev->state & DPTI_DEV_RESET ) {
 478                 return FAILED;
 479         }
 480         return adpt_scsi_to_i2o(pHba, cmd, pDev);
 481 }
 482
 483 static DEF_SCSI_QCMD(adpt_queue)
 484
 485 static int adpt_bios_param(struct scsi_device *sdev, struct block_device *dev,
 486                 sector_t capacity, int geom[])
 487 {
 488         int heads=-1;
 489         int sectors=-1;
 490         int cylinders=-1;
 491
 492         // *** First lets set the default geometry ****
 493
 494         // If the capacity is less than ox2000
 495         if (capacity < 0x2000 ) {       // floppy
 496                 heads = 18;
 497                 sectors = 2;
 498         }
 499         // else if between 0x2000 and 0x20000
 500         else if (capacity < 0x20000) {
 501                 heads = 64;
 502                 sectors = 32;
 503         }
 504         // else if between 0x20000 and 0x40000
 505         else if (capacity < 0x40000) {
 506                 heads = 65;
 507                 sectors = 63;
 508         }
 509         // else if between 0x4000 and 0x80000
 510         else if (capacity < 0x80000) {
 511                 heads = 128;
 512                 sectors = 63;
 513         }
 514         // else if greater than 0x80000
 515         else {
 516                 heads = 255;
 517                 sectors = 63;
 518         }
 519         cylinders = sector_div(capacity, heads * sectors);
 520
 521         // Special case if CDROM
 522         if(sdev->type == 5) {  // CDROM
 523                 heads = 252;
 524                 sectors = 63;
 525                 cylinders = 1111;
 526         }
 527
 528         geom[0] = heads;
 529         geom[1] = sectors;
 530         geom[2] = cylinders;
 531
 532         PDEBUG("adpt_bios_param: exit\n");
 533         return 0;
 534 }
 535
 536
 537 static const char *adpt_info(struct Scsi_Host *host)
 538 {
 539         adpt_hba* pHba;
 540
 541         pHba = (adpt_hba *) host->hostdata[0];
 542         return (char *) (pHba->detail);
 543 }
 544
 545 static int adpt_show_info(struct seq_file *m, struct Scsi_Host *host)
 546 {
 547         struct adpt_device* d;
 548         int id;
 549         int chan;
 550         adpt_hba* pHba;
 551         int unit;
 552
 553         // Find HBA (host bus adapter) we are looking for
 554         mutex_lock(&adpt_configuration_lock);
 555         for (pHba = hba_chain; pHba; pHba = pHba->next) {
 556                 if (pHba->host == host) {
 557                         break;  /* found adapter */
 558                 }
 559         }
 560         mutex_unlock(&adpt_configuration_lock);
 561         if (pHba == NULL) {
 562                 return 0;
 563         }
 564         host = pHba->host;
 565
 566         seq_printf(m, "Adaptec I2O RAID Driver Version: %s\n\n", DPT_I2O_VERSION);
 567         seq_printf(m, "%s\n", pHba->detail);
 568         seq_printf(m, "SCSI Host=scsi%d  Control Node=/dev/%s  irq=%d\n",
 569                         pHba->host->host_no, pHba->name, host->irq);
 570         seq_printf(m, "\tpost fifo size  = %d\n\treply fifo size = %d\n\tsg table size   = %d\n\n",
 571                         host->can_queue, (int) pHba->reply_fifo_size , host->sg_tablesize);
 572
 573         seq_printf(m, "Devices:\n");
 574         for(chan = 0; chan < MAX_CHANNEL; chan++) {
 575                 for(id = 0; id < MAX_ID; id++) {
 576                         d = pHba->channel[chan].device[id];
 577                         while(d) {
 578                                 seq_printf(m,"\t%-24.24s", d->pScsi_dev->vendor);
 579                                 seq_printf(m," Rev: %-8.8s\n", d->pScsi_dev->rev);
 580
 581                                 unit = d->pI2o_dev->lct_data.tid;
 582                                 seq_printf(m, "\tTID=%d, (Channel=%d, Target=%d, Lun=%d)  (%s)\n\n",
 583                                                unit, (int)d->scsi_channel, (int)d->scsi_id, (int)d->scsi_lun,
 584                                                scsi_device_online(d->pScsi_dev)? "online":"offline");
 585                                 d = d->next_lun;
 586                         }
 587                 }
 588         }
 589         return 0;
 590 }
 591
 592 /*
 593  *      Turn a struct scsi_cmnd * into a unique 32 bit 'context'.
 594  */
 595 static u32 adpt_cmd_to_context(struct scsi_cmnd *cmd)
 596 {
 597         return (u32)cmd->serial_number;
 598 }
 599
 600 /*
 601  *      Go from a u32 'context' to a struct scsi_cmnd * .
 602  *      This could probably be made more efficient.
 603  */
 604 static struct scsi_cmnd *
 605         adpt_cmd_from_context(adpt_hba * pHba, u32 context)
 606 {
 607         struct scsi_cmnd * cmd;
 608         struct scsi_device * d;
 609
 610         if (context == 0)
 611                 return NULL;
 612
 613         spin_unlock(pHba->host->host_lock);
 614         shost_for_each_device(d, pHba->host) {
 615                 unsigned long flags;
 616                 spin_lock_irqsave(&d->list_lock, flags);
 617                 list_for_each_entry(cmd, &d->cmd_list, list) {
 618                         if (((u32)cmd->serial_number == context)) {
 619                                 spin_unlock_irqrestore(&d->list_lock, flags);
 620                                 scsi_device_put(d);
 621                                 spin_lock(pHba->host->host_lock);
 622                                 return cmd;
 623                         }
 624                 }
 625                 spin_unlock_irqrestore(&d->list_lock, flags);
 626         }
 627         spin_lock(pHba->host->host_lock);
 628
 629         return NULL;
 630 }
 631
 632 /*
 633  *      Turn a pointer to ioctl reply data into an u32 'context'
 634  */
 635 static u32 adpt_ioctl_to_context(adpt_hba * pHba, void *reply)
 636 {
 637 #if BITS_PER_LONG == 32
 638         return (u32)(unsigned long)reply;
 639 #else
 640         ulong flags = 0;
 641         u32 nr, i;
 642
 643         spin_lock_irqsave(pHba->host->host_lock, flags);
 644         nr = ARRAY_SIZE(pHba->ioctl_reply_context);
 645         for (i = 0; i < nr; i++) {
 646                 if (pHba->ioctl_reply_context[i] == NULL) {
 647                         pHba->ioctl_reply_context[i] = reply;
 648                         break;
 649                 }
 650         }
 651         spin_unlock_irqrestore(pHba->host->host_lock, flags);
 652         if (i >= nr) {
 653                 kfree (reply);
 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, u32 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         s16 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 = (buf[2]>>8 )&0xff;
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 = (buf[2]>>8 )&0xff;
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                 return -EBUSY;
1758
1759         memset(sg_list,0, sizeof(sg_list[0])*pHba->sg_tablesize);
1760         if(sg_offset) {
1761                 // TODO add 64 bit API
1762                 struct sg_simple_element *sg =  (struct sg_simple_element*) (msg+sg_offset);
1763                 sg_count = (size - sg_offset*4) / sizeof(struct sg_simple_element);
1764                 if (sg_count > pHba->sg_tablesize){
1765                         printk(KERN_DEBUG"%s:IOCTL SG List too large (%u)\n", pHba->name,sg_count);
1766                         kfree (reply);
1767                         return -EINVAL;
1768                 }
1769
1770                 for(i = 0; i < sg_count; i++) {
1771                         int sg_size;
1772
1773                         if (!(sg[i].flag_count & 0x10000000 /*I2O_SGL_FLAGS_SIMPLE_ADDRESS_ELEMENT*/)) {
1774                                 printk(KERN_DEBUG"%s:Bad SG element %d - not simple (%x)\n",pHba->name,i,  sg[i].flag_count);
1775                                 rcode = -EINVAL;
1776                                 goto cleanup;
1777                         }
1778                         sg_size = sg[i].flag_count & 0xffffff;
1779                         /* Allocate memory for the transfer */
1780                         p = dma_alloc_coherent(&pHba->pDev->dev, sg_size, &addr, GFP_KERNEL);
1781                         if(!p) {
1782                                 printk(KERN_DEBUG"%s: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
1783                                                 pHba->name,sg_size,i,sg_count);
1784                                 rcode = -ENOMEM;
1785                                 goto cleanup;
1786                         }
1787                         sg_list[sg_index++] = p; // sglist indexed with input frame, not our internal frame.
1788                         /* Copy in the user's SG buffer if necessary */
1789                         if(sg[i].flag_count & 0x04000000 /*I2O_SGL_FLAGS_DIR*/) {
1790                                 // sg_simple_element API is 32 bit
1791                                 if (copy_from_user(p,(void __user *)(ulong)sg[i].addr_bus, sg_size)) {
1792                                         printk(KERN_DEBUG"%s: Could not copy SG buf %d FROM user\n",pHba->name,i);
1793                                         rcode = -EFAULT;
1794                                         goto cleanup;
1795                                 }
1796                         }
1797                         /* sg_simple_element API is 32 bit, but addr < 4GB */
1798                         sg[i].addr_bus = addr;
1799                 }
1800         }
1801
1802         do {
1803                 /*
1804                  * Stop any new commands from enterring the
1805                  * controller while processing the ioctl
1806                  */
1807                 if (pHba->host) {
1808                         scsi_block_requests(pHba->host);
1809                         spin_lock_irqsave(pHba->host->host_lock, flags);
1810                 }
1811                 rcode = adpt_i2o_post_wait(pHba, msg, size, FOREVER);
1812                 if (rcode != 0)
1813                         printk("adpt_i2o_passthru: post wait failed %d %p\n",
1814                                         rcode, reply);
1815                 if (pHba->host) {
1816                         spin_unlock_irqrestore(pHba->host->host_lock, flags);
1817                         scsi_unblock_requests(pHba->host);
1818                 }
1819         } while (rcode == -ETIMEDOUT);
1820
1821         if(rcode){
1822                 goto cleanup;
1823         }
1824
1825         if(sg_offset) {
1826         /* Copy back the Scatter Gather buffers back to user space */
1827                 u32 j;
1828                 // TODO add 64 bit API
1829                 struct sg_simple_element* sg;
1830                 int sg_size;
1831
1832                 // re-acquire the original message to handle correctly the sg copy operation
1833                 memset(&msg, 0, MAX_MESSAGE_SIZE*4);
1834                 // get user msg size in u32s
1835                 if(get_user(size, &user_msg[0])){
1836                         rcode = -EFAULT;
1837                         goto cleanup;
1838                 }
1839                 size = size>>16;
1840                 size *= 4;
1841                 if (size > MAX_MESSAGE_SIZE) {
1842                         rcode = -EINVAL;
1843                         goto cleanup;
1844                 }
1845                 /* Copy in the user's I2O command */
1846                 if (copy_from_user (msg, user_msg, size)) {
1847                         rcode = -EFAULT;
1848                         goto cleanup;
1849                 }
1850                 sg_count = (size - sg_offset*4) / sizeof(struct sg_simple_element);
1851
1852                 // TODO add 64 bit API
1853                 sg       = (struct sg_simple_element*)(msg + sg_offset);
1854                 for (j = 0; j < sg_count; j++) {
1855                         /* Copy out the SG list to user's buffer if necessary */
1856                         if(! (sg[j].flag_count & 0x4000000 /*I2O_SGL_FLAGS_DIR*/)) {
1857                                 sg_size = sg[j].flag_count & 0xffffff;
1858                                 // sg_simple_element API is 32 bit
1859                                 if (copy_to_user((void __user *)(ulong)sg[j].addr_bus,sg_list[j], sg_size)) {
1860                                         printk(KERN_WARNING"%s: Could not copy %p TO user %x\n",pHba->name, sg_list[j], sg[j].addr_bus);
1861                                         rcode = -EFAULT;
1862                                         goto cleanup;
1863                                 }
1864                         }
1865                 }
1866         }
1867
1868         /* Copy back the reply to user space */
1869         if (reply_size) {
1870                 // we wrote our own values for context - now restore the user supplied ones
1871                 if(copy_from_user(reply+2, user_msg+2, sizeof(u32)*2)) {
1872                         printk(KERN_WARNING"%s: Could not copy message context FROM user\n",pHba->name);
1873                         rcode = -EFAULT;
1874                 }
1875                 if(copy_to_user(user_reply, reply, reply_size)) {
1876                         printk(KERN_WARNING"%s: Could not copy reply TO user\n",pHba->name);
1877                         rcode = -EFAULT;
1878                 }
1879         }
1880
1881
1882 cleanup:
1883         if (rcode != -ETIME && rcode != -EINTR) {
1884                 struct sg_simple_element *sg =
1885                                 (struct sg_simple_element*) (msg +sg_offset);
1886                 kfree (reply);
1887                 while(sg_index) {
1888                         if(sg_list[--sg_index]) {
1889                                 dma_free_coherent(&pHba->pDev->dev,
1890                                         sg[sg_index].flag_count & 0xffffff,
1891                                         sg_list[sg_index],
1892                                         sg[sg_index].addr_bus);
1893                         }
1894                 }
1895         }
1896         return rcode;
1897 }
1898
1899 #if defined __ia64__
1900 static void adpt_ia64_info(sysInfo_S* si)
1901 {
1902         // This is all the info we need for now
1903         // We will add more info as our new
1904         // managmenent utility requires it
1905         si->processorType = PROC_IA64;
1906 }
1907 #endif
1908
1909 #if defined __sparc__
1910 static void adpt_sparc_info(sysInfo_S* si)
1911 {
1912         // This is all the info we need for now
1913         // We will add more info as our new
1914         // managmenent utility requires it
1915         si->processorType = PROC_ULTRASPARC;
1916 }
1917 #endif
1918 #if defined __alpha__
1919 static void adpt_alpha_info(sysInfo_S* si)
1920 {
1921         // This is all the info we need for now
1922         // We will add more info as our new
1923         // managmenent utility requires it
1924         si->processorType = PROC_ALPHA;
1925 }
1926 #endif
1927
1928 #if defined __i386__
1929 static void adpt_i386_info(sysInfo_S* si)
1930 {
1931         // This is all the info we need for now
1932         // We will add more info as our new
1933         // managmenent utility requires it
1934         switch (boot_cpu_data.x86) {
1935         case CPU_386:
1936                 si->processorType = PROC_386;
1937                 break;
1938         case CPU_486:
1939                 si->processorType = PROC_486;
1940                 break;
1941         case CPU_586:
1942                 si->processorType = PROC_PENTIUM;
1943                 break;
1944         default:  // Just in case
1945                 si->processorType = PROC_PENTIUM;
1946                 break;
1947         }
1948 }
1949 #endif
1950
1951 /*
1952  * This routine returns information about the system.  This does not effect
1953  * any logic and if the info is wrong - it doesn't matter.
1954  */
1955
1956 /* Get all the info we can not get from kernel services */
1957 static int adpt_system_info(void __user *buffer)
1958 {
1959         sysInfo_S si;
1960
1961         memset(&si, 0, sizeof(si));
1962
1963         si.osType = OS_LINUX;
1964         si.osMajorVersion = 0;
1965         si.osMinorVersion = 0;
1966         si.osRevision = 0;
1967         si.busType = SI_PCI_BUS;
1968         si.processorFamily = DPTI_sig.dsProcessorFamily;
1969
1970 #if defined __i386__
1971         adpt_i386_info(&si);
1972 #elif defined (__ia64__)
1973         adpt_ia64_info(&si);
1974 #elif defined(__sparc__)
1975         adpt_sparc_info(&si);
1976 #elif defined (__alpha__)
1977         adpt_alpha_info(&si);
1978 #else
1979         si.processorType = 0xff ;
1980 #endif
1981         if (copy_to_user(buffer, &si, sizeof(si))){
1982                 printk(KERN_WARNING"dpti: Could not copy buffer TO user\n");
1983                 return -EFAULT;
1984         }
1985
1986         return 0;
1987 }
1988
1989 static int adpt_ioctl(struct inode *inode, struct file *file, uint cmd, ulong arg)
1990 {
1991         int minor;
1992         int error = 0;
1993         adpt_hba* pHba;
1994         ulong flags = 0;
1995         void __user *argp = (void __user *)arg;
1996
1997         minor = iminor(inode);
1998         if (minor >= DPTI_MAX_HBA){
1999                 return -ENXIO;
2000         }
2001         mutex_lock(&adpt_configuration_lock);
2002         for (pHba = hba_chain; pHba; pHba = pHba->next) {
2003                 if (pHba->unit == minor) {
2004                         break;  /* found adapter */
2005                 }
2006         }
2007         mutex_unlock(&adpt_configuration_lock);
2008         if(pHba == NULL){
2009                 return -ENXIO;
2010         }
2011
2012         while((volatile u32) pHba->state & DPTI_STATE_RESET )
2013                 schedule_timeout_uninterruptible(2);
2014
2015         switch (cmd) {
2016         // TODO: handle 3 cases
2017         case DPT_SIGNATURE:
2018                 if (copy_to_user(argp, &DPTI_sig, sizeof(DPTI_sig))) {
2019                         return -EFAULT;
2020                 }
2021                 break;
2022         case I2OUSRCMD:
2023                 return adpt_i2o_passthru(pHba, argp);
2024
2025         case DPT_CTRLINFO:{
2026                 drvrHBAinfo_S HbaInfo;
2027
2028 #define FLG_OSD_PCI_VALID 0x0001
2029 #define FLG_OSD_DMA       0x0002
2030 #define FLG_OSD_I2O       0x0004
2031                 memset(&HbaInfo, 0, sizeof(HbaInfo));
2032                 HbaInfo.drvrHBAnum = pHba->unit;
2033                 HbaInfo.baseAddr = (ulong) pHba->base_addr_phys;
2034                 HbaInfo.blinkState = adpt_read_blink_led(pHba);
2035                 HbaInfo.pciBusNum =  pHba->pDev->bus->number;
2036                 HbaInfo.pciDeviceNum=PCI_SLOT(pHba->pDev->devfn);
2037                 HbaInfo.Interrupt = pHba->pDev->irq;
2038                 HbaInfo.hbaFlags = FLG_OSD_PCI_VALID | FLG_OSD_DMA | FLG_OSD_I2O;
2039                 if(copy_to_user(argp, &HbaInfo, sizeof(HbaInfo))){
2040                         printk(KERN_WARNING"%s: Could not copy HbaInfo TO user\n",pHba->name);
2041                         return -EFAULT;
2042                 }
2043                 break;
2044                 }
2045         case DPT_SYSINFO:
2046                 return adpt_system_info(argp);
2047         case DPT_BLINKLED:{
2048                 u32 value;
2049                 value = (u32)adpt_read_blink_led(pHba);
2050                 if (copy_to_user(argp, &value, sizeof(value))) {
2051                         return -EFAULT;
2052                 }
2053                 break;
2054                 }
2055         case I2ORESETCMD:
2056                 if(pHba->host)
2057                         spin_lock_irqsave(pHba->host->host_lock, flags);
2058                 adpt_hba_reset(pHba);
2059                 if(pHba->host)
2060                         spin_unlock_irqrestore(pHba->host->host_lock, flags);
2061                 break;
2062         case I2ORESCANCMD:
2063                 adpt_rescan(pHba);
2064                 break;
2065         default:
2066                 return -EINVAL;
2067         }
2068
2069         return error;
2070 }
2071
2072 static long adpt_unlocked_ioctl(struct file *file, uint cmd, ulong arg)
2073 {
2074         struct inode *inode;
2075         long ret;
2076
2077         inode = file_inode(file);
2078
2079         mutex_lock(&adpt_mutex);
2080         ret = adpt_ioctl(inode, file, cmd, arg);
2081         mutex_unlock(&adpt_mutex);
2082
2083         return ret;
2084 }
2085
2086 #ifdef CONFIG_COMPAT
2087 static long compat_adpt_ioctl(struct file *file,
2088                                 unsigned int cmd, unsigned long arg)
2089 {
2090         struct inode *inode;
2091         long ret;
2092
2093         inode = file_inode(file);
2094
2095         mutex_lock(&adpt_mutex);
2096
2097         switch(cmd) {
2098                 case DPT_SIGNATURE:
2099                 case I2OUSRCMD:
2100                 case DPT_CTRLINFO:
2101                 case DPT_SYSINFO:
2102                 case DPT_BLINKLED:
2103                 case I2ORESETCMD:
2104                 case I2ORESCANCMD:
2105                 case (DPT_TARGET_BUSY & 0xFFFF):
2106                 case DPT_TARGET_BUSY:
2107                         ret = adpt_ioctl(inode, file, cmd, arg);
2108                         break;
2109                 default:
2110                         ret =  -ENOIOCTLCMD;
2111         }
2112
2113         mutex_unlock(&adpt_mutex);
2114
2115         return ret;
2116 }
2117 #endif
2118
2119 static irqreturn_t adpt_isr(int irq, void *dev_id)
2120 {
2121         struct scsi_cmnd* cmd;
2122         adpt_hba* pHba = dev_id;
2123         u32 m;
2124         void __iomem *reply;
2125         u32 status=0;
2126         u32 context;
2127         ulong flags = 0;
2128         int handled = 0;
2129
2130         if (pHba == NULL){
2131                 printk(KERN_WARNING"adpt_isr: NULL dev_id\n");
2132                 return IRQ_NONE;
2133         }
2134         if(pHba->host)
2135                 spin_lock_irqsave(pHba->host->host_lock, flags);
2136
2137         while( readl(pHba->irq_mask) & I2O_INTERRUPT_PENDING_B) {
2138                 m = readl(pHba->reply_port);
2139                 if(m == EMPTY_QUEUE){
2140                         // Try twice then give up
2141                         rmb();
2142                         m = readl(pHba->reply_port);
2143                         if(m == EMPTY_QUEUE){
2144                                 // This really should not happen
2145                                 printk(KERN_ERR"dpti: Could not get reply frame\n");
2146                                 goto out;
2147                         }
2148                 }
2149                 if (pHba->reply_pool_pa <= m &&
2150                     m < pHba->reply_pool_pa +
2151                         (pHba->reply_fifo_size * REPLY_FRAME_SIZE * 4)) {
2152                         reply = (u8 *)pHba->reply_pool +
2153                                                 (m - pHba->reply_pool_pa);
2154                 } else {
2155                         /* Ick, we should *never* be here */
2156                         printk(KERN_ERR "dpti: reply frame not from pool\n");
2157                         reply = (u8 *)bus_to_virt(m);
2158                 }
2159
2160                 if (readl(reply) & MSG_FAIL) {
2161                         u32 old_m = readl(reply+28);
2162                         void __iomem *msg;
2163                         u32 old_context;
2164                         PDEBUG("%s: Failed message\n",pHba->name);
2165                         if(old_m >= 0x100000){
2166                                 printk(KERN_ERR"%s: Bad preserved MFA (%x)- dropping frame\n",pHba->name,old_m);
2167                                 writel(m,pHba->reply_port);
2168                                 continue;
2169                         }
2170                         // Transaction context is 0 in failed reply frame
2171                         msg = pHba->msg_addr_virt + old_m;
2172                         old_context = readl(msg+12);
2173                         writel(old_context, reply+12);
2174                         adpt_send_nop(pHba, old_m);
2175                 }
2176                 context = readl(reply+8);
2177                 if(context & 0x40000000){ // IOCTL
2178                         void *p = adpt_ioctl_from_context(pHba, readl(reply+12));
2179                         if( p != NULL) {
2180                                 memcpy_fromio(p, reply, REPLY_FRAME_SIZE * 4);
2181                         }
2182                         // All IOCTLs will also be post wait
2183                 }
2184                 if(context & 0x80000000){ // Post wait message
2185                         status = readl(reply+16);
2186                         if(status  >> 24){
2187                                 status &=  0xffff; /* Get detail status */
2188                         } else {
2189                                 status = I2O_POST_WAIT_OK;
2190                         }
2191                         if(!(context & 0x40000000)) {
2192                                 cmd = adpt_cmd_from_context(pHba,
2193                                                         readl(reply+12));
2194                                 if(cmd != NULL) {
2195                                         printk(KERN_WARNING"%s: Apparent SCSI cmd in Post Wait Context - cmd=%p context=%x\n", pHba->name, cmd, context);
2196                                 }
2197                         }
2198                         adpt_i2o_post_wait_complete(context, status);
2199                 } else { // SCSI message
2200                         cmd = adpt_cmd_from_context (pHba, readl(reply+12));
2201                         if(cmd != NULL){
2202                                 scsi_dma_unmap(cmd);
2203                                 if(cmd->serial_number != 0) { // If not timedout
2204                                         adpt_i2o_to_scsi(reply, cmd);
2205                                 }
2206                         }
2207                 }
2208                 writel(m, pHba->reply_port);
2209                 wmb();
2210                 rmb();
2211         }
2212         handled = 1;
2213 out:    if(pHba->host)
2214                 spin_unlock_irqrestore(pHba->host->host_lock, flags);
2215         return IRQ_RETVAL(handled);
2216 }
2217
2218 static s32 adpt_scsi_to_i2o(adpt_hba* pHba, struct scsi_cmnd* cmd, struct adpt_device* d)
2219 {
2220         int i;
2221         u32 msg[MAX_MESSAGE_SIZE];
2222         u32* mptr;
2223         u32* lptr;
2224         u32 *lenptr;
2225         int direction;
2226         int scsidir;
2227         int nseg;
2228         u32 len;
2229         u32 reqlen;
2230         s32 rcode;
2231         dma_addr_t addr;
2232
2233         memset(msg, 0 , sizeof(msg));
2234         len = scsi_bufflen(cmd);
2235         direction = 0x00000000;
2236
2237         scsidir = 0x00000000;                   // DATA NO XFER
2238         if(len) {
2239                 /*
2240                  * Set SCBFlags to indicate if data is being transferred
2241                  * in or out, or no data transfer
2242                  * Note:  Do not have to verify index is less than 0 since
2243                  * cmd->cmnd[0] is an unsigned char
2244                  */
2245                 switch(cmd->sc_data_direction){
2246                 case DMA_FROM_DEVICE:
2247                         scsidir  =0x40000000;   // DATA IN  (iop<--dev)
2248                         break;
2249                 case DMA_TO_DEVICE:
2250                         direction=0x04000000;   // SGL OUT
2251                         scsidir  =0x80000000;   // DATA OUT (iop-->dev)
2252                         break;
2253                 case DMA_NONE:
2254                         break;
2255                 case DMA_BIDIRECTIONAL:
2256                         scsidir  =0x40000000;   // DATA IN  (iop<--dev)
2257                         // Assume In - and continue;
2258                         break;
2259                 default:
2260                         printk(KERN_WARNING"%s: scsi opcode 0x%x not supported.\n",
2261                              pHba->name, cmd->cmnd[0]);
2262                         cmd->result = (DID_OK <<16) | (INITIATOR_ERROR << 8);
2263                         cmd->scsi_done(cmd);
2264                         return  0;
2265                 }
2266         }
2267         // msg[0] is set later
2268         // I2O_CMD_SCSI_EXEC
2269         msg[1] = ((0xff<<24)|(HOST_TID<<12)|d->tid);
2270         msg[2] = 0;
2271         msg[3] = adpt_cmd_to_context(cmd);  /* Want SCSI control block back */
2272         // Our cards use the transaction context as the tag for queueing
2273         // Adaptec/DPT Private stuff
2274         msg[4] = I2O_CMD_SCSI_EXEC|(DPT_ORGANIZATION_ID<<16);
2275         msg[5] = d->tid;
2276         /* Direction, disconnect ok | sense data | simple queue , CDBLen */
2277         // I2O_SCB_FLAG_ENABLE_DISCONNECT |
2278         // I2O_SCB_FLAG_SIMPLE_QUEUE_TAG |
2279         // I2O_SCB_FLAG_SENSE_DATA_IN_MESSAGE;
2280         msg[6] = scsidir|0x20a00000|cmd->cmd_len;
2281
2282         mptr=msg+7;
2283
2284         // Write SCSI command into the message - always 16 byte block
2285         memset(mptr, 0,  16);
2286         memcpy(mptr, cmd->cmnd, cmd->cmd_len);
2287         mptr+=4;
2288         lenptr=mptr++;          /* Remember me - fill in when we know */
2289         if (dpt_dma64(pHba)) {
2290                 reqlen = 16;            // SINGLE SGE
2291                 *mptr++ = (0x7C<<24)+(2<<16)+0x02; /* Enable 64 bit */
2292                 *mptr++ = 1 << PAGE_SHIFT;
2293         } else {
2294                 reqlen = 14;            // SINGLE SGE
2295         }
2296         /* Now fill in the SGList and command */
2297
2298         nseg = scsi_dma_map(cmd);
2299         BUG_ON(nseg < 0);
2300         if (nseg) {
2301                 struct scatterlist *sg;
2302
2303                 len = 0;
2304                 scsi_for_each_sg(cmd, sg, nseg, i) {
2305                         lptr = mptr;
2306                         *mptr++ = direction|0x10000000|sg_dma_len(sg);
2307                         len+=sg_dma_len(sg);
2308                         addr = sg_dma_address(sg);
2309                         *mptr++ = dma_low(addr);
2310                         if (dpt_dma64(pHba))
2311                                 *mptr++ = dma_high(addr);
2312                         /* Make this an end of list */
2313                         if (i == nseg - 1)
2314                                 *lptr = direction|0xD0000000|sg_dma_len(sg);
2315                 }
2316                 reqlen = mptr - msg;
2317                 *lenptr = len;
2318
2319                 if(cmd->underflow && len != cmd->underflow){
2320                         printk(KERN_WARNING"Cmd len %08X Cmd underflow %08X\n",
2321                                 len, cmd->underflow);
2322                 }
2323         } else {
2324                 *lenptr = len = 0;
2325                 reqlen = 12;
2326         }
2327
2328         /* Stick the headers on */
2329         msg[0] = reqlen<<16 | ((reqlen > 12) ? SGL_OFFSET_12 : SGL_OFFSET_0);
2330
2331         // Send it on it's way
2332         rcode = adpt_i2o_post_this(pHba, msg, reqlen<<2);
2333         if (rcode == 0) {
2334                 return 0;
2335         }
2336         return rcode;
2337 }
2338
2339
2340 static s32 adpt_scsi_host_alloc(adpt_hba* pHba, struct scsi_host_template *sht)
2341 {
2342         struct Scsi_Host *host;
2343
2344         host = scsi_host_alloc(sht, sizeof(adpt_hba*));
2345         if (host == NULL) {
2346                 printk("%s: scsi_host_alloc returned NULL\n", pHba->name);
2347                 return -1;
2348         }
2349         host->hostdata[0] = (unsigned long)pHba;
2350         pHba->host = host;
2351
2352         host->irq = pHba->pDev->irq;
2353         /* no IO ports, so don't have to set host->io_port and
2354          * host->n_io_port
2355          */
2356         host->io_port = 0;
2357         host->n_io_port = 0;
2358                                 /* see comments in scsi_host.h */
2359         host->max_id = 16;
2360         host->max_lun = 256;
2361         host->max_channel = pHba->top_scsi_channel + 1;
2362         host->cmd_per_lun = 1;
2363         host->unique_id = (u32)sys_tbl_pa + pHba->unit;
2364         host->sg_tablesize = pHba->sg_tablesize;
2365         host->can_queue = pHba->post_fifo_size;
2366
2367         return 0;
2368 }
2369
2370
2371 static s32 adpt_i2o_to_scsi(void __iomem *reply, struct scsi_cmnd* cmd)
2372 {
2373         adpt_hba* pHba;
2374         u32 hba_status;
2375         u32 dev_status;
2376         u32 reply_flags = readl(reply) & 0xff00; // Leave it shifted up 8 bits
2377         // I know this would look cleaner if I just read bytes
2378         // but the model I have been using for all the rest of the
2379         // io is in 4 byte words - so I keep that model
2380         u16 detailed_status = readl(reply+16) &0xffff;
2381         dev_status = (detailed_status & 0xff);
2382         hba_status = detailed_status >> 8;
2383
2384         // calculate resid for sg
2385         scsi_set_resid(cmd, scsi_bufflen(cmd) - readl(reply+20));
2386
2387         pHba = (adpt_hba*) cmd->device->host->hostdata[0];
2388
2389         cmd->sense_buffer[0] = '\0';  // initialize sense valid flag to false
2390
2391         if(!(reply_flags & MSG_FAIL)) {
2392                 switch(detailed_status & I2O_SCSI_DSC_MASK) {
2393                 case I2O_SCSI_DSC_SUCCESS:
2394                         cmd->result = (DID_OK << 16);
2395                         // handle underflow
2396                         if (readl(reply+20) < cmd->underflow) {
2397                                 cmd->result = (DID_ERROR <<16);
2398                                 printk(KERN_WARNING"%s: SCSI CMD underflow\n",pHba->name);
2399                         }
2400                         break;
2401                 case I2O_SCSI_DSC_REQUEST_ABORTED:
2402                         cmd->result = (DID_ABORT << 16);
2403                         break;
2404                 case I2O_SCSI_DSC_PATH_INVALID:
2405                 case I2O_SCSI_DSC_DEVICE_NOT_PRESENT:
2406                 case I2O_SCSI_DSC_SELECTION_TIMEOUT:
2407                 case I2O_SCSI_DSC_COMMAND_TIMEOUT:
2408                 case I2O_SCSI_DSC_NO_ADAPTER:
2409                 case I2O_SCSI_DSC_RESOURCE_UNAVAILABLE:
2410                         printk(KERN_WARNING"%s: SCSI Timeout-Device (%d,%d,%d) hba status=0x%x, dev status=0x%x, cmd=0x%x\n",
2411                                 pHba->name, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun, hba_status, dev_status, cmd->cmnd[0]);
2412                         cmd->result = (DID_TIME_OUT << 16);
2413                         break;
2414                 case I2O_SCSI_DSC_ADAPTER_BUSY:
2415                 case I2O_SCSI_DSC_BUS_BUSY:
2416                         cmd->result = (DID_BUS_BUSY << 16);
2417                         break;
2418                 case I2O_SCSI_DSC_SCSI_BUS_RESET:
2419                 case I2O_SCSI_DSC_BDR_MESSAGE_SENT:
2420                         cmd->result = (DID_RESET << 16);
2421                         break;
2422                 case I2O_SCSI_DSC_PARITY_ERROR_FAILURE:
2423                         printk(KERN_WARNING"%s: SCSI CMD parity error\n",pHba->name);
2424                         cmd->result = (DID_PARITY << 16);
2425                         break;
2426                 case I2O_SCSI_DSC_UNABLE_TO_ABORT:
2427                 case I2O_SCSI_DSC_COMPLETE_WITH_ERROR:
2428                 case I2O_SCSI_DSC_UNABLE_TO_TERMINATE:
2429                 case I2O_SCSI_DSC_MR_MESSAGE_RECEIVED:
2430                 case I2O_SCSI_DSC_AUTOSENSE_FAILED:
2431                 case I2O_SCSI_DSC_DATA_OVERRUN:
2432                 case I2O_SCSI_DSC_UNEXPECTED_BUS_FREE:
2433                 case I2O_SCSI_DSC_SEQUENCE_FAILURE:
2434                 case I2O_SCSI_DSC_REQUEST_LENGTH_ERROR:
2435                 case I2O_SCSI_DSC_PROVIDE_FAILURE:
2436                 case I2O_SCSI_DSC_REQUEST_TERMINATED:
2437                 case I2O_SCSI_DSC_IDE_MESSAGE_SENT:
2438                 case I2O_SCSI_DSC_UNACKNOWLEDGED_EVENT:
2439                 case I2O_SCSI_DSC_MESSAGE_RECEIVED:
2440                 case I2O_SCSI_DSC_INVALID_CDB:
2441                 case I2O_SCSI_DSC_LUN_INVALID:
2442                 case I2O_SCSI_DSC_SCSI_TID_INVALID:
2443                 case I2O_SCSI_DSC_FUNCTION_UNAVAILABLE:
2444                 case I2O_SCSI_DSC_NO_NEXUS:
2445                 case I2O_SCSI_DSC_CDB_RECEIVED:
2446                 case I2O_SCSI_DSC_LUN_ALREADY_ENABLED:
2447                 case I2O_SCSI_DSC_QUEUE_FROZEN:
2448                 case I2O_SCSI_DSC_REQUEST_INVALID:
2449                 default:
2450                         printk(KERN_WARNING"%s: SCSI error %0x-Device(%d,%d,%d) hba_status=0x%x, dev_status=0x%x, cmd=0x%x\n",
2451                                 pHba->name, detailed_status & I2O_SCSI_DSC_MASK, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun,
2452                                hba_status, dev_status, cmd->cmnd[0]);
2453                         cmd->result = (DID_ERROR << 16);
2454                         break;
2455                 }
2456
2457                 // copy over the request sense data if it was a check
2458                 // condition status
2459                 if (dev_status == SAM_STAT_CHECK_CONDITION) {
2460                         u32 len = min(SCSI_SENSE_BUFFERSIZE, 40);
2461                         // Copy over the sense data
2462                         memcpy_fromio(cmd->sense_buffer, (reply+28) , len);
2463                         if(cmd->sense_buffer[0] == 0x70 /* class 7 */ &&
2464                            cmd->sense_buffer[2] == DATA_PROTECT ){
2465                                 /* This is to handle an array failed */
2466                                 cmd->result = (DID_TIME_OUT << 16);
2467                                 printk(KERN_WARNING"%s: SCSI Data Protect-Device (%d,%d,%d) hba_status=0x%x, dev_status=0x%x, cmd=0x%x\n",
2468                                         pHba->name, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun,
2469                                         hba_status, dev_status, cmd->cmnd[0]);
2470
2471                         }
2472                 }
2473         } else {
2474                 /* In this condtion we could not talk to the tid
2475                  * the card rejected it.  We should signal a retry
2476                  * for a limitted number of retries.
2477                  */
2478                 cmd->result = (DID_TIME_OUT << 16);
2479                 printk(KERN_WARNING"%s: I2O MSG_FAIL - Device (%d,%d,%d) tid=%d, cmd=0x%x\n",
2480                         pHba->name, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun,
2481                         ((struct adpt_device*)(cmd->device->hostdata))->tid, cmd->cmnd[0]);
2482         }
2483
2484         cmd->result |= (dev_status);
2485
2486         if(cmd->scsi_done != NULL){
2487                 cmd->scsi_done(cmd);
2488         }
2489         return cmd->result;
2490 }
2491
2492
2493 static s32 adpt_rescan(adpt_hba* pHba)
2494 {
2495         s32 rcode;
2496         ulong flags = 0;
2497
2498         if(pHba->host)
2499                 spin_lock_irqsave(pHba->host->host_lock, flags);
2500         if ((rcode=adpt_i2o_lct_get(pHba)) < 0)
2501                 goto out;
2502         if ((rcode=adpt_i2o_reparse_lct(pHba)) < 0)
2503                 goto out;
2504         rcode = 0;
2505 out:    if(pHba->host)
2506                 spin_unlock_irqrestore(pHba->host->host_lock, flags);
2507         return rcode;
2508 }
2509
2510
2511 static s32 adpt_i2o_reparse_lct(adpt_hba* pHba)
2512 {
2513         int i;
2514         int max;
2515         int tid;
2516         struct i2o_device *d;
2517         i2o_lct *lct = pHba->lct;
2518         u8 bus_no = 0;
2519         s16 scsi_id;
2520         s16 scsi_lun;
2521         u32 buf[10]; // at least 8 u32's
2522         struct adpt_device* pDev = NULL;
2523         struct i2o_device* pI2o_dev = NULL;
2524
2525         if (lct == NULL) {
2526                 printk(KERN_ERR "%s: LCT is empty???\n",pHba->name);
2527                 return -1;
2528         }
2529
2530         max = lct->table_size;
2531         max -= 3;
2532         max /= 9;
2533
2534         // Mark each drive as unscanned
2535         for (d = pHba->devices; d; d = d->next) {
2536                 pDev =(struct adpt_device*) d->owner;
2537                 if(!pDev){
2538                         continue;
2539                 }
2540                 pDev->state |= DPTI_DEV_UNSCANNED;
2541         }
2542
2543         printk(KERN_INFO "%s: LCT has %d entries.\n", pHba->name,max);
2544
2545         for(i=0;i<max;i++) {
2546                 if( lct->lct_entry[i].user_tid != 0xfff){
2547                         continue;
2548                 }
2549
2550                 if( lct->lct_entry[i].class_id == I2O_CLASS_RANDOM_BLOCK_STORAGE ||
2551                     lct->lct_entry[i].class_id == I2O_CLASS_SCSI_PERIPHERAL ||
2552                     lct->lct_entry[i].class_id == I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL ){
2553                         tid = lct->lct_entry[i].tid;
2554                         if(adpt_i2o_query_scalar(pHba, tid, 0x8000, -1, buf, 32)<0) {
2555                                 printk(KERN_ERR"%s: Could not query device\n",pHba->name);
2556                                 continue;
2557                         }
2558                         bus_no = buf[0]>>16;
2559                         if (bus_no >= MAX_CHANNEL) {    /* Something wrong skip it */
2560                                 printk(KERN_WARNING
2561                                         "%s: Channel number %d out of range\n",
2562                                         pHba->name, bus_no);
2563                                 continue;
2564                         }
2565
2566                         scsi_id = buf[1];
2567                         scsi_lun = (buf[2]>>8 )&0xff;
2568                         pDev = pHba->channel[bus_no].device[scsi_id];
2569                         /* da lun */
2570                         while(pDev) {
2571                                 if(pDev->scsi_lun == scsi_lun) {
2572                                         break;
2573                                 }
2574                                 pDev = pDev->next_lun;
2575                         }
2576                         if(!pDev ) { // Something new add it
2577                                 d = kmalloc(sizeof(struct i2o_device),
2578                                             GFP_ATOMIC);
2579                                 if(d==NULL)
2580                                 {
2581                                         printk(KERN_CRIT "Out of memory for I2O device data.\n");
2582                                         return -ENOMEM;
2583                                 }
2584
2585                                 d->controller = pHba;
2586                                 d->next = NULL;
2587
2588                                 memcpy(&d->lct_data, &lct->lct_entry[i], sizeof(i2o_lct_entry));
2589
2590                                 d->flags = 0;
2591                                 adpt_i2o_report_hba_unit(pHba, d);
2592                                 adpt_i2o_install_device(pHba, d);
2593
2594                                 pDev = pHba->channel[bus_no].device[scsi_id];
2595                                 if( pDev == NULL){
2596                                         pDev =
2597                                           kzalloc(sizeof(struct adpt_device),
2598                                                   GFP_ATOMIC);
2599                                         if(pDev == NULL) {
2600                                                 return -ENOMEM;
2601                                         }
2602                                         pHba->channel[bus_no].device[scsi_id] = pDev;
2603                                 } else {
2604                                         while (pDev->next_lun) {
2605                                                 pDev = pDev->next_lun;
2606                                         }
2607                                         pDev = pDev->next_lun =
2608                                           kzalloc(sizeof(struct adpt_device),
2609                                                   GFP_ATOMIC);
2610                                         if(pDev == NULL) {
2611                                                 return -ENOMEM;
2612                                         }
2613                                 }
2614                                 pDev->tid = d->lct_data.tid;
2615                                 pDev->scsi_channel = bus_no;
2616                                 pDev->scsi_id = scsi_id;
2617                                 pDev->scsi_lun = scsi_lun;
2618                                 pDev->pI2o_dev = d;
2619                                 d->owner = pDev;
2620                                 pDev->type = (buf[0])&0xff;
2621                                 pDev->flags = (buf[0]>>8)&0xff;
2622                                 // Too late, SCSI system has made up it's mind, but what the hey ...
2623                                 if(scsi_id > pHba->top_scsi_id){
2624                                         pHba->top_scsi_id = scsi_id;
2625                                 }
2626                                 if(scsi_lun > pHba->top_scsi_lun){
2627                                         pHba->top_scsi_lun = scsi_lun;
2628                                 }
2629                                 continue;
2630                         } // end of new i2o device
2631
2632                         // We found an old device - check it
2633                         while(pDev) {
2634                                 if(pDev->scsi_lun == scsi_lun) {
2635                                         if(!scsi_device_online(pDev->pScsi_dev)) {
2636                                                 printk(KERN_WARNING"%s: Setting device (%d,%d,%d) back online\n",
2637                                                                 pHba->name,bus_no,scsi_id,scsi_lun);
2638                                                 if (pDev->pScsi_dev) {
2639                                                         scsi_device_set_state(pDev->pScsi_dev, SDEV_RUNNING);
2640                                                 }
2641                                         }
2642                                         d = pDev->pI2o_dev;
2643                                         if(d->lct_data.tid != tid) { // something changed
2644                                                 pDev->tid = tid;
2645                                                 memcpy(&d->lct_data, &lct->lct_entry[i], sizeof(i2o_lct_entry));
2646                                                 if (pDev->pScsi_dev) {
2647                                                         pDev->pScsi_dev->changed = TRUE;
2648                                                         pDev->pScsi_dev->removable = TRUE;
2649                                                 }
2650                                         }
2651                                         // Found it - mark it scanned
2652                                         pDev->state = DPTI_DEV_ONLINE;
2653                                         break;
2654                                 }
2655                                 pDev = pDev->next_lun;
2656                         }
2657                 }
2658         }
2659         for (pI2o_dev = pHba->devices; pI2o_dev; pI2o_dev = pI2o_dev->next) {
2660                 pDev =(struct adpt_device*) pI2o_dev->owner;
2661                 if(!pDev){
2662                         continue;
2663                 }
2664                 // Drive offline drives that previously existed but could not be found
2665                 // in the LCT table
2666                 if (pDev->state & DPTI_DEV_UNSCANNED){
2667                         pDev->state = DPTI_DEV_OFFLINE;
2668                         printk(KERN_WARNING"%s: Device (%d,%d,%d) offline\n",pHba->name,pDev->scsi_channel,pDev->scsi_id,pDev->scsi_lun);
2669                         if (pDev->pScsi_dev) {
2670                                 scsi_device_set_state(pDev->pScsi_dev, SDEV_OFFLINE);
2671                         }
2672                 }
2673         }
2674         return 0;
2675 }
2676
2677 static void adpt_fail_posted_scbs(adpt_hba* pHba)
2678 {
2679         struct scsi_cmnd*       cmd = NULL;
2680         struct scsi_device*     d = NULL;
2681
2682         shost_for_each_device(d, pHba->host) {
2683                 unsigned long flags;
2684                 spin_lock_irqsave(&d->list_lock, flags);
2685                 list_for_each_entry(cmd, &d->cmd_list, list) {
2686                         if(cmd->serial_number == 0){
2687                                 continue;
2688                         }
2689                         cmd->result = (DID_OK << 16) | (QUEUE_FULL <<1);
2690                         cmd->scsi_done(cmd);
2691                 }
2692                 spin_unlock_irqrestore(&d->list_lock, flags);
2693         }
2694 }
2695
2696
2697 /*============================================================================
2698  *  Routines from i2o subsystem
2699  *============================================================================
2700  */
2701
2702
2703
2704 /*
2705  *      Bring an I2O controller into HOLD state. See the spec.
2706  */
2707 static int adpt_i2o_activate_hba(adpt_hba* pHba)
2708 {
2709         int rcode;
2710
2711         if(pHba->initialized ) {
2712                 if (adpt_i2o_status_get(pHba) < 0) {
2713                         if((rcode = adpt_i2o_reset_hba(pHba)) != 0){
2714                                 printk(KERN_WARNING"%s: Could NOT reset.\n", pHba->name);
2715                                 return rcode;
2716                         }
2717                         if (adpt_i2o_status_get(pHba) < 0) {
2718                                 printk(KERN_INFO "HBA not responding.\n");
2719                                 return -1;
2720                         }
2721                 }
2722
2723                 if(pHba->status_block->iop_state == ADAPTER_STATE_FAULTED) {
2724                         printk(KERN_CRIT "%s: hardware fault\n", pHba->name);
2725                         return -1;
2726                 }
2727
2728                 if (pHba->status_block->iop_state == ADAPTER_STATE_READY ||
2729                     pHba->status_block->iop_state == ADAPTER_STATE_OPERATIONAL ||
2730                     pHba->status_block->iop_state == ADAPTER_STATE_HOLD ||
2731                     pHba->status_block->iop_state == ADAPTER_STATE_FAILED) {
2732                         adpt_i2o_reset_hba(pHba);
2733                         if (adpt_i2o_status_get(pHba) < 0 || pHba->status_block->iop_state != ADAPTER_STATE_RESET) {
2734                                 printk(KERN_ERR "%s: Failed to initialize.\n", pHba->name);
2735                                 return -1;
2736                         }
2737                 }
2738         } else {
2739                 if((rcode = adpt_i2o_reset_hba(pHba)) != 0){
2740                         printk(KERN_WARNING"%s: Could NOT reset.\n", pHba->name);
2741                         return rcode;
2742                 }
2743
2744         }
2745
2746         if (adpt_i2o_init_outbound_q(pHba) < 0) {
2747                 return -1;
2748         }
2749
2750         /* In HOLD state */
2751
2752         if (adpt_i2o_hrt_get(pHba) < 0) {
2753                 return -1;
2754         }
2755
2756         return 0;
2757 }
2758
2759 /*
2760  *      Bring a controller online into OPERATIONAL state.
2761  */
2762
2763 static int adpt_i2o_online_hba(adpt_hba* pHba)
2764 {
2765         if (adpt_i2o_systab_send(pHba) < 0) {
2766                 adpt_i2o_delete_hba(pHba);
2767                 return -1;
2768         }
2769         /* In READY state */
2770
2771         if (adpt_i2o_enable_hba(pHba) < 0) {
2772                 adpt_i2o_delete_hba(pHba);
2773                 return -1;
2774         }
2775
2776         /* In OPERATIONAL state  */
2777         return 0;
2778 }
2779
2780 static s32 adpt_send_nop(adpt_hba*pHba,u32 m)
2781 {
2782         u32 __iomem *msg;
2783         ulong timeout = jiffies + 5*HZ;
2784
2785         while(m == EMPTY_QUEUE){
2786                 rmb();
2787                 m = readl(pHba->post_port);
2788                 if(m != EMPTY_QUEUE){
2789                         break;
2790                 }
2791                 if(time_after(jiffies,timeout)){
2792                         printk(KERN_ERR "%s: Timeout waiting for message frame!\n",pHba->name);
2793                         return 2;
2794                 }
2795                 schedule_timeout_uninterruptible(1);
2796         }
2797         msg = (u32 __iomem *)(pHba->msg_addr_virt + m);
2798         writel( THREE_WORD_MSG_SIZE | SGL_OFFSET_0,&msg[0]);
2799         writel( I2O_CMD_UTIL_NOP << 24 | HOST_TID << 12 | 0,&msg[1]);
2800         writel( 0,&msg[2]);
2801         wmb();
2802
2803         writel(m, pHba->post_port);
2804         wmb();
2805         return 0;
2806 }
2807
2808 static s32 adpt_i2o_init_outbound_q(adpt_hba* pHba)
2809 {
2810         u8 *status;
2811         dma_addr_t addr;
2812         u32 __iomem *msg = NULL;
2813         int i;
2814         ulong timeout = jiffies + TMOUT_INITOUTBOUND*HZ;
2815         u32 m;
2816
2817         do {
2818                 rmb();
2819                 m = readl(pHba->post_port);
2820                 if (m != EMPTY_QUEUE) {
2821                         break;
2822                 }
2823
2824                 if(time_after(jiffies,timeout)){
2825                         printk(KERN_WARNING"%s: Timeout waiting for message frame\n",pHba->name);
2826                         return -ETIMEDOUT;
2827                 }
2828                 schedule_timeout_uninterruptible(1);
2829         } while(m == EMPTY_QUEUE);
2830
2831         msg=(u32 __iomem *)(pHba->msg_addr_virt+m);
2832
2833         status = dma_alloc_coherent(&pHba->pDev->dev, 4, &addr, GFP_KERNEL);
2834         if (!status) {
2835                 adpt_send_nop(pHba, m);
2836                 printk(KERN_WARNING"%s: IOP reset failed - no free memory.\n",
2837                         pHba->name);
2838                 return -ENOMEM;
2839         }
2840         memset(status, 0, 4);
2841
2842         writel(EIGHT_WORD_MSG_SIZE| SGL_OFFSET_6, &msg[0]);
2843         writel(I2O_CMD_OUTBOUND_INIT<<24 | HOST_TID<<12 | ADAPTER_TID, &msg[1]);
2844         writel(0, &msg[2]);
2845         writel(0x0106, &msg[3]);        /* Transaction context */
2846         writel(4096, &msg[4]);          /* Host page frame size */
2847         writel((REPLY_FRAME_SIZE)<<16|0x80, &msg[5]);   /* Outbound msg frame size and Initcode */
2848         writel(0xD0000004, &msg[6]);            /* Simple SG LE, EOB */
2849         writel((u32)addr, &msg[7]);
2850
2851         writel(m, pHba->post_port);
2852         wmb();
2853
2854         // Wait for the reply status to come back
2855         do {
2856                 if (*status) {
2857                         if (*status != 0x01 /*I2O_EXEC_OUTBOUND_INIT_IN_PROGRESS*/) {
2858                                 break;
2859                         }
2860                 }
2861                 rmb();
2862                 if(time_after(jiffies,timeout)){
2863                         printk(KERN_WARNING"%s: Timeout Initializing\n",pHba->name);
2864                         /* We lose 4 bytes of "status" here, but we
2865                            cannot free these because controller may
2866                            awake and corrupt those bytes at any time */
2867                         /* dma_free_coherent(&pHba->pDev->dev, 4, status, addr); */
2868                         return -ETIMEDOUT;
2869                 }
2870                 schedule_timeout_uninterruptible(1);
2871         } while (1);
2872
2873         // If the command was successful, fill the fifo with our reply
2874         // message packets
2875         if(*status != 0x04 /*I2O_EXEC_OUTBOUND_INIT_COMPLETE*/) {
2876                 dma_free_coherent(&pHba->pDev->dev, 4, status, addr);
2877                 return -2;
2878         }
2879         dma_free_coherent(&pHba->pDev->dev, 4, status, addr);
2880
2881         if(pHba->reply_pool != NULL) {
2882                 dma_free_coherent(&pHba->pDev->dev,
2883                         pHba->reply_fifo_size * REPLY_FRAME_SIZE * 4,
2884                         pHba->reply_pool, pHba->reply_pool_pa);
2885         }
2886
2887         pHba->reply_pool = dma_alloc_coherent(&pHba->pDev->dev,
2888                                 pHba->reply_fifo_size * REPLY_FRAME_SIZE * 4,
2889                                 &pHba->reply_pool_pa, GFP_KERNEL);
2890         if (!pHba->reply_pool) {
2891                 printk(KERN_ERR "%s: Could not allocate reply pool\n", pHba->name);
2892                 return -ENOMEM;
2893         }
2894         memset(pHba->reply_pool, 0 , pHba->reply_fifo_size * REPLY_FRAME_SIZE * 4);
2895
2896         for(i = 0; i < pHba->reply_fifo_size; i++) {
2897                 writel(pHba->reply_pool_pa + (i * REPLY_FRAME_SIZE * 4),
2898                         pHba->reply_port);
2899                 wmb();
2900         }
2901         adpt_i2o_status_get(pHba);
2902         return 0;
2903 }
2904
2905
2906 /*
2907  * I2O System Table.  Contains information about
2908  * all the IOPs in the system.  Used to inform IOPs
2909  * about each other's existence.
2910  *
2911  * sys_tbl_ver is the CurrentChangeIndicator that is
2912  * used by IOPs to track changes.
2913  */
2914
2915
2916
2917 static s32 adpt_i2o_status_get(adpt_hba* pHba)
2918 {
2919         ulong timeout;
2920         u32 m;
2921         u32 __iomem *msg;
2922         u8 *status_block=NULL;
2923
2924         if(pHba->status_block == NULL) {
2925                 pHba->status_block = dma_alloc_coherent(&pHba->pDev->dev,
2926                                         sizeof(i2o_status_block),
2927                                         &pHba->status_block_pa, GFP_KERNEL);
2928                 if(pHba->status_block == NULL) {
2929                         printk(KERN_ERR
2930                         "dpti%d: Get Status Block failed; Out of memory. \n",
2931                         pHba->unit);
2932                         return -ENOMEM;
2933                 }
2934         }
2935         memset(pHba->status_block, 0, sizeof(i2o_status_block));
2936         status_block = (u8*)(pHba->status_block);
2937         timeout = jiffies+TMOUT_GETSTATUS*HZ;
2938         do {
2939                 rmb();
2940                 m = readl(pHba->post_port);
2941                 if (m != EMPTY_QUEUE) {
2942                         break;
2943                 }
2944                 if(time_after(jiffies,timeout)){
2945                         printk(KERN_ERR "%s: Timeout waiting for message !\n",
2946                                         pHba->name);
2947                         return -ETIMEDOUT;
2948                 }
2949                 schedule_timeout_uninterruptible(1);
2950         } while(m==EMPTY_QUEUE);
2951
2952
2953         msg=(u32 __iomem *)(pHba->msg_addr_virt+m);
2954
2955         writel(NINE_WORD_MSG_SIZE|SGL_OFFSET_0, &msg[0]);
2956         writel(I2O_CMD_STATUS_GET<<24|HOST_TID<<12|ADAPTER_TID, &msg[1]);
2957         writel(1, &msg[2]);
2958         writel(0, &msg[3]);
2959         writel(0, &msg[4]);
2960         writel(0, &msg[5]);
2961         writel( dma_low(pHba->status_block_pa), &msg[6]);
2962         writel( dma_high(pHba->status_block_pa), &msg[7]);
2963         writel(sizeof(i2o_status_block), &msg[8]); // 88 bytes
2964
2965         //post message
2966         writel(m, pHba->post_port);
2967         wmb();
2968
2969         while(status_block[87]!=0xff){
2970                 if(time_after(jiffies,timeout)){
2971                         printk(KERN_ERR"dpti%d: Get status timeout.\n",
2972                                 pHba->unit);
2973                         return -ETIMEDOUT;
2974                 }
2975                 rmb();
2976                 schedule_timeout_uninterruptible(1);
2977         }
2978
2979         // Set up our number of outbound and inbound messages
2980         pHba->post_fifo_size = pHba->status_block->max_inbound_frames;
2981         if (pHba->post_fifo_size > MAX_TO_IOP_MESSAGES) {
2982                 pHba->post_fifo_size = MAX_TO_IOP_MESSAGES;
2983         }
2984
2985         pHba->reply_fifo_size = pHba->status_block->max_outbound_frames;
2986         if (pHba->reply_fifo_size > MAX_FROM_IOP_MESSAGES) {
2987                 pHba->reply_fifo_size = MAX_FROM_IOP_MESSAGES;
2988         }
2989
2990         // Calculate the Scatter Gather list size
2991         if (dpt_dma64(pHba)) {
2992                 pHba->sg_tablesize
2993                   = ((pHba->status_block->inbound_frame_size * 4
2994                   - 14 * sizeof(u32))
2995                   / (sizeof(struct sg_simple_element) + sizeof(u32)));
2996         } else {
2997                 pHba->sg_tablesize
2998                   = ((pHba->status_block->inbound_frame_size * 4
2999                   - 12 * sizeof(u32))
3000                   / sizeof(struct sg_simple_element));
3001         }
3002         if (pHba->sg_tablesize > SG_LIST_ELEMENTS) {
3003                 pHba->sg_tablesize = SG_LIST_ELEMENTS;
3004         }
3005
3006
3007 #ifdef DEBUG
3008         printk("dpti%d: State = ",pHba->unit);
3009         switch(pHba->status_block->iop_state) {
3010                 case 0x01:
3011                         printk("INIT\n");
3012                         break;
3013                 case 0x02:
3014                         printk("RESET\n");
3015                         break;
3016                 case 0x04:
3017                         printk("HOLD\n");
3018                         break;
3019                 case 0x05:
3020                         printk("READY\n");
3021                         break;
3022                 case 0x08:
3023                         printk("OPERATIONAL\n");
3024                         break;
3025                 case 0x10:
3026                         printk("FAILED\n");
3027                         break;
3028                 case 0x11:
3029                         printk("FAULTED\n");
3030                         break;
3031                 default:
3032                         printk("%x (unknown!!)\n",pHba->status_block->iop_state);
3033         }
3034 #endif
3035         return 0;
3036 }
3037
3038 /*
3039  * Get the IOP's Logical Configuration Table
3040  */
3041 static int adpt_i2o_lct_get(adpt_hba* pHba)
3042 {
3043         u32 msg[8];
3044         int ret;
3045         u32 buf[16];
3046
3047         if ((pHba->lct_size == 0) || (pHba->lct == NULL)){
3048                 pHba->lct_size = pHba->status_block->expected_lct_size;
3049         }
3050         do {
3051                 if (pHba->lct == NULL) {
3052                         pHba->lct = dma_alloc_coherent(&pHba->pDev->dev,
3053                                         pHba->lct_size, &pHba->lct_pa,
3054                                         GFP_ATOMIC);
3055                         if(pHba->lct == NULL) {
3056                                 printk(KERN_CRIT "%s: Lct Get failed. Out of memory.\n",
3057                                         pHba->name);
3058                                 return -ENOMEM;
3059                         }
3060                 }
3061                 memset(pHba->lct, 0, pHba->lct_size);
3062
3063                 msg[0] = EIGHT_WORD_MSG_SIZE|SGL_OFFSET_6;
3064                 msg[1] = I2O_CMD_LCT_NOTIFY<<24 | HOST_TID<<12 | ADAPTER_TID;
3065                 msg[2] = 0;
3066                 msg[3] = 0;
3067                 msg[4] = 0xFFFFFFFF;    /* All devices */
3068                 msg[5] = 0x00000000;    /* Report now */
3069                 msg[6] = 0xD0000000|pHba->lct_size;
3070                 msg[7] = (u32)pHba->lct_pa;
3071
3072                 if ((ret=adpt_i2o_post_wait(pHba, msg, sizeof(msg), 360))) {
3073                         printk(KERN_ERR "%s: LCT Get failed (status=%#10x.\n",
3074                                 pHba->name, ret);
3075                         printk(KERN_ERR"Adaptec: Error Reading Hardware.\n");
3076                         return ret;
3077                 }
3078
3079                 if ((pHba->lct->table_size << 2) > pHba->lct_size) {
3080                         pHba->lct_size = pHba->lct->table_size << 2;
3081                         dma_free_coherent(&pHba->pDev->dev, pHba->lct_size,
3082                                         pHba->lct, pHba->lct_pa);
3083                         pHba->lct = NULL;
3084                 }
3085         } while (pHba->lct == NULL);
3086
3087         PDEBUG("%s: Hardware resource table read.\n", pHba->name);
3088
3089
3090         // I2O_DPT_EXEC_IOP_BUFFERS_GROUP_NO;
3091         if(adpt_i2o_query_scalar(pHba, 0 , 0x8000, -1, buf, sizeof(buf))>=0) {
3092                 pHba->FwDebugBufferSize = buf[1];
3093                 pHba->FwDebugBuffer_P = ioremap(pHba->base_addr_phys + buf[0],
3094                                                 pHba->FwDebugBufferSize);
3095                 if (pHba->FwDebugBuffer_P) {
3096                         pHba->FwDebugFlags_P     = pHba->FwDebugBuffer_P +
3097                                                         FW_DEBUG_FLAGS_OFFSET;
3098                         pHba->FwDebugBLEDvalue_P = pHba->FwDebugBuffer_P +
3099                                                         FW_DEBUG_BLED_OFFSET;
3100                         pHba->FwDebugBLEDflag_P  = pHba->FwDebugBLEDvalue_P + 1;
3101                         pHba->FwDebugStrLength_P = pHba->FwDebugBuffer_P +
3102                                                 FW_DEBUG_STR_LENGTH_OFFSET;
3103                         pHba->FwDebugBuffer_P += buf[2];
3104                         pHba->FwDebugFlags = 0;
3105                 }
3106         }
3107
3108         return 0;
3109 }
3110
3111 static int adpt_i2o_build_sys_table(void)
3112 {
3113         adpt_hba* pHba = hba_chain;
3114         int count = 0;
3115
3116         if (sys_tbl)
3117                 dma_free_coherent(&pHba->pDev->dev, sys_tbl_len,
3118                                         sys_tbl, sys_tbl_pa);
3119
3120         sys_tbl_len = sizeof(struct i2o_sys_tbl) +      // Header + IOPs
3121                                 (hba_count) * sizeof(struct i2o_sys_tbl_entry);
3122
3123         sys_tbl = dma_alloc_coherent(&pHba->pDev->dev,
3124                                 sys_tbl_len, &sys_tbl_pa, GFP_KERNEL);
3125         if (!sys_tbl) {
3126                 printk(KERN_WARNING "SysTab Set failed. Out of memory.\n");
3127                 return -ENOMEM;
3128         }
3129         memset(sys_tbl, 0, sys_tbl_len);
3130
3131         sys_tbl->num_entries = hba_count;
3132         sys_tbl->version = I2OVERSION;
3133         sys_tbl->change_ind = sys_tbl_ind++;
3134
3135         for(pHba = hba_chain; pHba; pHba = pHba->next) {
3136                 u64 addr;
3137                 // Get updated Status Block so we have the latest information
3138                 if (adpt_i2o_status_get(pHba)) {
3139                         sys_tbl->num_entries--;
3140                         continue; // try next one
3141                 }
3142
3143                 sys_tbl->iops[count].org_id = pHba->status_block->org_id;
3144                 sys_tbl->iops[count].iop_id = pHba->unit + 2;
3145                 sys_tbl->iops[count].seg_num = 0;
3146                 sys_tbl->iops[count].i2o_version = pHba->status_block->i2o_version;
3147                 sys_tbl->iops[count].iop_state = pHba->status_block->iop_state;
3148                 sys_tbl->iops[count].msg_type = pHba->status_block->msg_type;
3149                 sys_tbl->iops[count].frame_size = pHba->status_block->inbound_frame_size;
3150                 sys_tbl->iops[count].last_changed = sys_tbl_ind - 1; // ??
3151                 sys_tbl->iops[count].iop_capabilities = pHba->status_block->iop_capabilities;
3152                 addr = pHba->base_addr_phys + 0x40;
3153                 sys_tbl->iops[count].inbound_low = dma_low(addr);
3154                 sys_tbl->iops[count].inbound_high = dma_high(addr);
3155
3156                 count++;
3157         }
3158
3159 #ifdef DEBUG
3160 {
3161         u32 *table = (u32*)sys_tbl;
3162         printk(KERN_DEBUG"sys_tbl_len=%d in 32bit words\n",(sys_tbl_len >>2));
3163         for(count = 0; count < (sys_tbl_len >>2); count++) {
3164                 printk(KERN_INFO "sys_tbl[%d] = %0#10x\n",
3165                         count, table[count]);
3166         }
3167 }
3168 #endif
3169
3170         return 0;
3171 }
3172
3173
3174 /*
3175  *       Dump the information block associated with a given unit (TID)
3176  */
3177
3178 static void adpt_i2o_report_hba_unit(adpt_hba* pHba, struct i2o_device *d)
3179 {
3180         char buf[64];
3181         int unit = d->lct_data.tid;
3182
3183         printk(KERN_INFO "TID %3.3d ", unit);
3184
3185         if(adpt_i2o_query_scalar(pHba, unit, 0xF100, 3, buf, 16)>=0)
3186         {
3187                 buf[16]=0;
3188                 printk(" Vendor: %-12.12s", buf);
3189         }
3190         if(adpt_i2o_query_scalar(pHba, unit, 0xF100, 4, buf, 16)>=0)
3191         {
3192                 buf[16]=0;
3193                 printk(" Device: %-12.12s", buf);
3194         }
3195         if(adpt_i2o_query_scalar(pHba, unit, 0xF100, 6, buf, 8)>=0)
3196         {
3197                 buf[8]=0;
3198                 printk(" Rev: %-12.12s\n", buf);
3199         }
3200 #ifdef DEBUG
3201          printk(KERN_INFO "\tClass: %.21s\n", adpt_i2o_get_class_name(d->lct_data.class_id));
3202          printk(KERN_INFO "\tSubclass: 0x%04X\n", d->lct_data.sub_class);
3203          printk(KERN_INFO "\tFlags: ");
3204
3205          if(d->lct_data.device_flags&(1<<0))
3206                   printk("C");       // ConfigDialog requested
3207          if(d->lct_data.device_flags&(1<<1))
3208                   printk("U");       // Multi-user capable
3209          if(!(d->lct_data.device_flags&(1<<4)))
3210                   printk("P");       // Peer service enabled!
3211          if(!(d->lct_data.device_flags&(1<<5)))
3212                   printk("M");       // Mgmt service enabled!
3213          printk("\n");
3214 #endif
3215 }
3216
3217 #ifdef DEBUG
3218 /*
3219  *      Do i2o class name lookup
3220  */
3221 static const char *adpt_i2o_get_class_name(int class)
3222 {
3223         int idx = 16;
3224         static char *i2o_class_name[] = {
3225                 "Executive",
3226                 "Device Driver Module",
3227                 "Block Device",
3228                 "Tape Device",
3229                 "LAN Interface",
3230                 "WAN Interface",
3231                 "Fibre Channel Port",
3232                 "Fibre Channel Device",
3233                 "SCSI Device",
3234                 "ATE Port",
3235                 "ATE Device",
3236                 "Floppy Controller",
3237                 "Floppy Device",
3238                 "Secondary Bus Port",
3239                 "Peer Transport Agent",
3240                 "Peer Transport",
3241                 "Unknown"
3242         };
3243
3244         switch(class&0xFFF) {
3245         case I2O_CLASS_EXECUTIVE:
3246                 idx = 0; break;
3247         case I2O_CLASS_DDM:
3248                 idx = 1; break;
3249         case I2O_CLASS_RANDOM_BLOCK_STORAGE:
3250                 idx = 2; break;
3251         case I2O_CLASS_SEQUENTIAL_STORAGE:
3252                 idx = 3; break;
3253         case I2O_CLASS_LAN:
3254                 idx = 4; break;
3255         case I2O_CLASS_WAN:
3256                 idx = 5; break;
3257         case I2O_CLASS_FIBRE_CHANNEL_PORT:
3258                 idx = 6; break;
3259         case I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL:
3260                 idx = 7; break;
3261         case I2O_CLASS_SCSI_PERIPHERAL:
3262                 idx = 8; break;
3263         case I2O_CLASS_ATE_PORT:
3264                 idx = 9; break;
3265         case I2O_CLASS_ATE_PERIPHERAL:
3266                 idx = 10; break;
3267         case I2O_CLASS_FLOPPY_CONTROLLER:
3268                 idx = 11; break;
3269         case I2O_CLASS_FLOPPY_DEVICE:
3270                 idx = 12; break;
3271         case I2O_CLASS_BUS_ADAPTER_PORT:
3272                 idx = 13; break;
3273         case I2O_CLASS_PEER_TRANSPORT_AGENT:
3274                 idx = 14; break;
3275         case I2O_CLASS_PEER_TRANSPORT:
3276                 idx = 15; break;
3277         }
3278         return i2o_class_name[idx];
3279 }
3280 #endif
3281
3282
3283 static s32 adpt_i2o_hrt_get(adpt_hba* pHba)
3284 {
3285         u32 msg[6];
3286         int ret, size = sizeof(i2o_hrt);
3287
3288         do {
3289                 if (pHba->hrt == NULL) {
3290                         pHba->hrt = dma_alloc_coherent(&pHba->pDev->dev,
3291                                         size, &pHba->hrt_pa, GFP_KERNEL);
3292                         if (pHba->hrt == NULL) {
3293                                 printk(KERN_CRIT "%s: Hrt Get failed; Out of memory.\n", pHba->name);
3294                                 return -ENOMEM;
3295                         }
3296                 }
3297
3298                 msg[0]= SIX_WORD_MSG_SIZE| SGL_OFFSET_4;
3299                 msg[1]= I2O_CMD_HRT_GET<<24 | HOST_TID<<12 | ADAPTER_TID;
3300                 msg[2]= 0;
3301                 msg[3]= 0;
3302                 msg[4]= (0xD0000000 | size);    /* Simple transaction */
3303                 msg[5]= (u32)pHba->hrt_pa;      /* Dump it here */
3304
3305                 if ((ret = adpt_i2o_post_wait(pHba, msg, sizeof(msg),20))) {
3306                         printk(KERN_ERR "%s: Unable to get HRT (status=%#10x)\n", pHba->name, ret);
3307                         return ret;
3308                 }
3309
3310                 if (pHba->hrt->num_entries * pHba->hrt->entry_len << 2 > size) {
3311                         int newsize = pHba->hrt->num_entries * pHba->hrt->entry_len << 2;
3312                         dma_free_coherent(&pHba->pDev->dev, size,
3313                                 pHba->hrt, pHba->hrt_pa);
3314                         size = newsize;
3315                         pHba->hrt = NULL;
3316                 }
3317         } while(pHba->hrt == NULL);
3318         return 0;
3319 }
3320
3321 /*
3322  *       Query one scalar group value or a whole scalar group.
3323  */
3324 static int adpt_i2o_query_scalar(adpt_hba* pHba, int tid,
3325                         int group, int field, void *buf, int buflen)
3326 {
3327         u16 opblk[] = { 1, 0, I2O_PARAMS_FIELD_GET, group, 1, field };
3328         u8 *opblk_va;
3329         dma_addr_t opblk_pa;
3330         u8 *resblk_va;
3331         dma_addr_t resblk_pa;
3332
3333         int size;
3334
3335         /* 8 bytes for header */
3336         resblk_va = dma_alloc_coherent(&pHba->pDev->dev,
3337                         sizeof(u8) * (8 + buflen), &resblk_pa, GFP_KERNEL);
3338         if (resblk_va == NULL) {
3339                 printk(KERN_CRIT "%s: query scalar failed; Out of memory.\n", pHba->name);
3340                 return -ENOMEM;
3341         }
3342
3343         opblk_va = dma_alloc_coherent(&pHba->pDev->dev,
3344                         sizeof(opblk), &opblk_pa, GFP_KERNEL);
3345         if (opblk_va == NULL) {
3346                 dma_free_coherent(&pHba->pDev->dev, sizeof(u8) * (8+buflen),
3347                         resblk_va, resblk_pa);
3348                 printk(KERN_CRIT "%s: query operatio failed; Out of memory.\n",
3349                         pHba->name);
3350                 return -ENOMEM;
3351         }
3352         if (field == -1)                /* whole group */
3353                         opblk[4] = -1;
3354
3355         memcpy(opblk_va, opblk, sizeof(opblk));
3356         size = adpt_i2o_issue_params(I2O_CMD_UTIL_PARAMS_GET, pHba, tid,
3357                 opblk_va, opblk_pa, sizeof(opblk),
3358                 resblk_va, resblk_pa, sizeof(u8)*(8+buflen));
3359         dma_free_coherent(&pHba->pDev->dev, sizeof(opblk), opblk_va, opblk_pa);
3360         if (size == -ETIME) {
3361                 dma_free_coherent(&pHba->pDev->dev, sizeof(u8) * (8+buflen),
3362                                                         resblk_va, resblk_pa);
3363                 printk(KERN_WARNING "%s: issue params failed; Timed out.\n", pHba->name);
3364                 return -ETIME;
3365         } else if (size == -EINTR) {
3366                 dma_free_coherent(&pHba->pDev->dev, sizeof(u8) * (8+buflen),
3367                                                         resblk_va, resblk_pa);
3368                 printk(KERN_WARNING "%s: issue params failed; Interrupted.\n", pHba->name);
3369                 return -EINTR;
3370         }
3371
3372         memcpy(buf, resblk_va+8, buflen);  /* cut off header */
3373
3374         dma_free_coherent(&pHba->pDev->dev, sizeof(u8) * (8+buflen),
3375                                                 resblk_va, resblk_pa);
3376         if (size < 0)
3377                 return size;
3378
3379         return buflen;
3380 }
3381
3382
3383 /*      Issue UTIL_PARAMS_GET or UTIL_PARAMS_SET
3384  *
3385  *      This function can be used for all UtilParamsGet/Set operations.
3386  *      The OperationBlock is given in opblk-buffer,
3387  *      and results are returned in resblk-buffer.
3388  *      Note that the minimum sized resblk is 8 bytes and contains
3389  *      ResultCount, ErrorInfoSize, BlockStatus and BlockSize.
3390  */
3391 static int adpt_i2o_issue_params(int cmd, adpt_hba* pHba, int tid,
3392                   void *opblk_va,  dma_addr_t opblk_pa, int oplen,
3393                 void *resblk_va, dma_addr_t resblk_pa, int reslen)
3394 {
3395         u32 msg[9];
3396         u32 *res = (u32 *)resblk_va;
3397         int wait_status;
3398
3399         msg[0] = NINE_WORD_MSG_SIZE | SGL_OFFSET_5;
3400         msg[1] = cmd << 24 | HOST_TID << 12 | tid;
3401         msg[2] = 0;
3402         msg[3] = 0;
3403         msg[4] = 0;
3404         msg[5] = 0x54000000 | oplen;    /* OperationBlock */
3405         msg[6] = (u32)opblk_pa;
3406         msg[7] = 0xD0000000 | reslen;   /* ResultBlock */
3407         msg[8] = (u32)resblk_pa;
3408
3409         if ((wait_status = adpt_i2o_post_wait(pHba, msg, sizeof(msg), 20))) {
3410                 printk("adpt_i2o_issue_params: post_wait failed (%p)\n", resblk_va);
3411                 return wait_status;     /* -DetailedStatus */
3412         }
3413
3414         if (res[1]&0x00FF0000) {        /* BlockStatus != SUCCESS */
3415                 printk(KERN_WARNING "%s: %s - Error:\n  ErrorInfoSize = 0x%02x, "
3416                         "BlockStatus = 0x%02x, BlockSize = 0x%04x\n",
3417                         pHba->name,
3418                         (cmd == I2O_CMD_UTIL_PARAMS_SET) ? "PARAMS_SET"
3419                                                          : "PARAMS_GET",
3420                         res[1]>>24, (res[1]>>16)&0xFF, res[1]&0xFFFF);
3421                 return -((res[1] >> 16) & 0xFF); /* -BlockStatus */
3422         }
3423
3424          return 4 + ((res[1] & 0x0000FFFF) << 2); /* bytes used in resblk */
3425 }
3426
3427
3428 static s32 adpt_i2o_quiesce_hba(adpt_hba* pHba)
3429 {
3430         u32 msg[4];
3431         int ret;
3432
3433         adpt_i2o_status_get(pHba);
3434
3435         /* SysQuiesce discarded if IOP not in READY or OPERATIONAL state */
3436
3437         if((pHba->status_block->iop_state != ADAPTER_STATE_READY) &&
3438            (pHba->status_block->iop_state != ADAPTER_STATE_OPERATIONAL)){
3439                 return 0;
3440         }
3441
3442         msg[0] = FOUR_WORD_MSG_SIZE|SGL_OFFSET_0;
3443         msg[1] = I2O_CMD_SYS_QUIESCE<<24|HOST_TID<<12|ADAPTER_TID;
3444         msg[2] = 0;
3445         msg[3] = 0;
3446
3447         if((ret = adpt_i2o_post_wait(pHba, msg, sizeof(msg), 240))) {
3448                 printk(KERN_INFO"dpti%d: Unable to quiesce (status=%#x).\n",
3449                                 pHba->unit, -ret);
3450         } else {
3451                 printk(KERN_INFO"dpti%d: Quiesced.\n",pHba->unit);
3452         }
3453
3454         adpt_i2o_status_get(pHba);
3455         return ret;
3456 }
3457
3458
3459 /*
3460  * Enable IOP. Allows the IOP to resume external operations.
3461  */
3462 static int adpt_i2o_enable_hba(adpt_hba* pHba)
3463 {
3464         u32 msg[4];
3465         int ret;
3466
3467         adpt_i2o_status_get(pHba);
3468         if(!pHba->status_block){
3469                 return -ENOMEM;
3470         }
3471         /* Enable only allowed on READY state */
3472         if(pHba->status_block->iop_state == ADAPTER_STATE_OPERATIONAL)
3473                 return 0;
3474
3475         if(pHba->status_block->iop_state != ADAPTER_STATE_READY)
3476                 return -EINVAL;
3477
3478         msg[0]=FOUR_WORD_MSG_SIZE|SGL_OFFSET_0;
3479         msg[1]=I2O_CMD_SYS_ENABLE<<24|HOST_TID<<12|ADAPTER_TID;
3480         msg[2]= 0;
3481         msg[3]= 0;
3482
3483         if ((ret = adpt_i2o_post_wait(pHba, msg, sizeof(msg), 240))) {
3484                 printk(KERN_WARNING"%s: Could not enable (status=%#10x).\n",
3485                         pHba->name, ret);
3486         } else {
3487                 PDEBUG("%s: Enabled.\n", pHba->name);
3488         }
3489
3490         adpt_i2o_status_get(pHba);
3491         return ret;
3492 }
3493
3494
3495 static int adpt_i2o_systab_send(adpt_hba* pHba)
3496 {
3497          u32 msg[12];
3498          int ret;
3499
3500         msg[0] = I2O_MESSAGE_SIZE(12) | SGL_OFFSET_6;
3501         msg[1] = I2O_CMD_SYS_TAB_SET<<24 | HOST_TID<<12 | ADAPTER_TID;
3502         msg[2] = 0;
3503         msg[3] = 0;
3504         msg[4] = (0<<16) | ((pHba->unit+2) << 12); /* Host 0 IOP ID (unit + 2) */
3505         msg[5] = 0;                                /* Segment 0 */
3506
3507         /*
3508          * Provide three SGL-elements:
3509          * System table (SysTab), Private memory space declaration and
3510          * Private i/o space declaration
3511          */
3512         msg[6] = 0x54000000 | sys_tbl_len;
3513         msg[7] = (u32)sys_tbl_pa;
3514         msg[8] = 0x54000000 | 0;
3515         msg[9] = 0;
3516         msg[10] = 0xD4000000 | 0;
3517         msg[11] = 0;
3518
3519         if ((ret=adpt_i2o_post_wait(pHba, msg, sizeof(msg), 120))) {
3520                 printk(KERN_INFO "%s: Unable to set SysTab (status=%#10x).\n",
3521                         pHba->name, ret);
3522         }
3523 #ifdef DEBUG
3524         else {
3525                 PINFO("%s: SysTab set.\n", pHba->name);
3526         }
3527 #endif
3528
3529         return ret;
3530  }
3531
3532
3533 /*============================================================================
3534  *
3535  *============================================================================
3536  */
3537
3538
3539 #ifdef UARTDELAY
3540
3541 static static void adpt_delay(int millisec)
3542 {
3543         int i;
3544         for (i = 0; i < millisec; i++) {
3545                 udelay(1000);   /* delay for one millisecond */
3546         }
3547 }
3548
3549 #endif
3550
3551 static struct scsi_host_template driver_template = {
3552         .module                 = THIS_MODULE,
3553         .name                   = "dpt_i2o",
3554         .proc_name              = "dpt_i2o",
3555         .show_info              = adpt_show_info,
3556         .info                   = adpt_info,
3557         .queuecommand           = adpt_queue,
3558         .eh_abort_handler       = adpt_abort,
3559         .eh_device_reset_handler = adpt_device_reset,
3560         .eh_bus_reset_handler   = adpt_bus_reset,
3561         .eh_host_reset_handler  = adpt_reset,
3562         .bios_param             = adpt_bios_param,
3563         .slave_configure        = adpt_slave_configure,
3564         .can_queue              = MAX_TO_IOP_MESSAGES,
3565         .this_id                = 7,
3566         .cmd_per_lun            = 1,
3567         .use_clustering         = ENABLE_CLUSTERING,
3568 };
3569
3570 static int __init adpt_init(void)
3571 {
3572         int             error;
3573         adpt_hba        *pHba, *next;
3574
3575         printk("Loading Adaptec I2O RAID: Version " DPT_I2O_VERSION "\n");
3576
3577         error = adpt_detect(&driver_template);
3578         if (error < 0)
3579                 return error;
3580         if (hba_chain == NULL)
3581                 return -ENODEV;
3582
3583         for (pHba = hba_chain; pHba; pHba = pHba->next) {
3584                 error = scsi_add_host(pHba->host, &pHba->pDev->dev);
3585                 if (error)
3586                         goto fail;
3587                 scsi_scan_host(pHba->host);
3588         }
3589         return 0;
3590 fail:
3591         for (pHba = hba_chain; pHba; pHba = next) {
3592                 next = pHba->next;
3593                 scsi_remove_host(pHba->host);
3594         }
3595         return error;
3596 }
3597
3598 static void __exit adpt_exit(void)
3599 {
3600         adpt_hba        *pHba, *next;
3601
3602         for (pHba = hba_chain; pHba; pHba = pHba->next)
3603                 scsi_remove_host(pHba->host);
3604         for (pHba = hba_chain; pHba; pHba = next) {
3605                 next = pHba->next;
3606                 adpt_release(pHba->host);
3607         }
3608 }
3609
3610 module_init(adpt_init);
3611 module_exit(adpt_exit);
3612
3613 MODULE_LICENSE("GPL");