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