Merge master.kernel.org:/pub/scm/linux/kernel/git/jejb/scsi-misc-2.6

* master.kernel.org:/pub/scm/linux/kernel/git/jejb/scsi-misc-2.6: (87 commits)
  [SCSI] fusion: fix domain validation loops
  [SCSI] qla2xxx: fix regression on sparc64
  [SCSI] modalias for scsi devices
  [SCSI] sg: cap reserved_size values at max_sectors
  [SCSI] BusLogic: stop using check_region
  [SCSI] tgt: fix rdma transfer bugs
  [SCSI] aacraid: fix aacraid not finding device
  [SCSI] aacraid: Correct SMC products in aacraid.txt
  [SCSI] scsi_error.c: Add EH Start Unit retry
  [SCSI] aacraid: [Fastboot] Panics for AACRAID driver during 'insmod' for kexec test.
  [SCSI] ipr: Driver version to 2.3.2
  [SCSI] ipr: Faster sg list fetch
  [SCSI] ipr: Return better qc_issue errors
  [SCSI] ipr: Disrupt device error
  [SCSI] ipr: Improve async error logging level control
  [SCSI] ipr: PCI unblock config access fix
  [SCSI] ipr: Fix for oops following SATA request sense
  [SCSI] ipr: Log error for SAS dual path switch
  [SCSI] ipr: Enable logging of debug error data for all devices
  [SCSI] ipr: Add new PCI-E IDs to device table
  ...

10 files changed, 640 insertions, 461 deletions

diff --git a/drivers/scsi/aacraid/aachba.c b/drivers/scsi/aacraid/aachba.c
index d789e61bdc49..1e82c69b36b0 100644
--- a/drivers/scsi/aacraid/aachba.c
+++ b/drivers/scsi/aacraid/aachba.c
@@ -5,7 +5,7 @@
  * based on the old aacraid driver that is..
  * Adaptec aacraid device driver for Linux.
  *
- * Copyright (c) 2000 Adaptec, Inc. (aacraid@adaptec.com)
+ * Copyright (c) 2000-2007 Adaptec, Inc. (aacraid@adaptec.com)
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -172,6 +172,30 @@ MODULE_PARM_DESC(acbsize, "Request a specific adapter control block (FIB) size.
 int expose_physicals = -1;
 module_param(expose_physicals, int, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(expose_physicals, "Expose physical components of the arrays. -1=protect 0=off, 1=on");
+
+
+static inline int aac_valid_context(struct scsi_cmnd *scsicmd,
+                struct fib *fibptr) {
+        struct scsi_device *device;
+
+        if (unlikely(!scsicmd || !scsicmd->scsi_done )) {
+                dprintk((KERN_WARNING "aac_valid_context: scsi command corrupt\n"))
+;
+                aac_fib_complete(fibptr);
+                aac_fib_free(fibptr);
+                return 0;
+        }
+        scsicmd->SCp.phase = AAC_OWNER_MIDLEVEL;
+        device = scsicmd->device;
+        if (unlikely(!device || !scsi_device_online(device))) {
+                dprintk((KERN_WARNING "aac_valid_context: scsi device corrupt\n"));
+                aac_fib_complete(fibptr);
+                aac_fib_free(fibptr);
+                return 0;
+        }
+        return 1;
+}
+
 /**
  *      aac_get_config_status   -       check the adapter configuration
  *      @common: adapter to query
@@ -258,13 +282,10 @@ int aac_get_containers(struct aac_dev *dev)
         u32 index; 
         int status = 0;
         struct fib * fibptr;
-        unsigned instance;
         struct aac_get_container_count *dinfo;
         struct aac_get_container_count_resp *dresp;
         int maximum_num_containers = MAXIMUM_NUM_CONTAINERS;
 
-        instance = dev->scsi_host_ptr->unique_id;
-
         if (!(fibptr = aac_fib_alloc(dev)))
                 return -ENOMEM;
 
@@ -284,88 +305,35 @@ int aac_get_containers(struct aac_dev *dev)
                 maximum_num_containers = le32_to_cpu(dresp->ContainerSwitchEntries);
                 aac_fib_complete(fibptr);
         }
+        aac_fib_free(fibptr);
 
         if (maximum_num_containers < MAXIMUM_NUM_CONTAINERS)
                 maximum_num_containers = MAXIMUM_NUM_CONTAINERS;
-        fsa_dev_ptr = kmalloc(
-          sizeof(*fsa_dev_ptr) * maximum_num_containers, GFP_KERNEL);
-        if (!fsa_dev_ptr) {
-                aac_fib_free(fibptr);
+        fsa_dev_ptr =  kmalloc(sizeof(*fsa_dev_ptr) * maximum_num_containers,
+                        GFP_KERNEL);
+        if (!fsa_dev_ptr)
                 return -ENOMEM;
-        }
         memset(fsa_dev_ptr, 0, sizeof(*fsa_dev_ptr) * maximum_num_containers);
 
         dev->fsa_dev = fsa_dev_ptr;
         dev->maximum_num_containers = maximum_num_containers;
 
-        for (index = 0; index < dev->maximum_num_containers; index++) {
-                struct aac_query_mount *dinfo;
-                struct aac_mount *dresp;
-
+        for (index = 0; index < dev->maximum_num_containers; ) {
                 fsa_dev_ptr[index].devname[0] = '\0';
 
-                aac_fib_init(fibptr);
-                dinfo = (struct aac_query_mount *) fib_data(fibptr);
-
-                dinfo->command = cpu_to_le32(VM_NameServe);
-                dinfo->count = cpu_to_le32(index);
-                dinfo->type = cpu_to_le32(FT_FILESYS);
+                status = aac_probe_container(dev, index);
 
-                status = aac_fib_send(ContainerCommand,
-                                    fibptr,
-                                    sizeof (struct aac_query_mount),
-                                    FsaNormal,
-                                    1, 1,
-                                    NULL, NULL);
-                if (status < 0 ) {
+                if (status < 0) {
                         printk(KERN_WARNING "aac_get_containers: SendFIB failed.\n");
                         break;
                 }
-                dresp = (struct aac_mount *)fib_data(fibptr);
 
-                if ((le32_to_cpu(dresp->status) == ST_OK) &&
-                    (le32_to_cpu(dresp->mnt[0].vol) == CT_NONE)) {
-                        dinfo->command = cpu_to_le32(VM_NameServe64);
-                        dinfo->count = cpu_to_le32(index);
-                        dinfo->type = cpu_to_le32(FT_FILESYS);
-
-                        if (aac_fib_send(ContainerCommand,
-                                    fibptr,
-                                    sizeof(struct aac_query_mount),
-                                    FsaNormal,
-                                    1, 1,
-                                    NULL, NULL) < 0)
-                                continue;
-                } else
-                        dresp->mnt[0].capacityhigh = 0;
-
-                dprintk ((KERN_DEBUG
-                  "VM_NameServe cid=%d status=%d vol=%d state=%d cap=%llu\n",
-                  (int)index, (int)le32_to_cpu(dresp->status),
-                  (int)le32_to_cpu(dresp->mnt[0].vol),
-                  (int)le32_to_cpu(dresp->mnt[0].state),
-                  ((u64)le32_to_cpu(dresp->mnt[0].capacity)) +
-                    (((u64)le32_to_cpu(dresp->mnt[0].capacityhigh)) << 32)));
-                if ((le32_to_cpu(dresp->status) == ST_OK) &&
-                    (le32_to_cpu(dresp->mnt[0].vol) != CT_NONE) &&
-                    (le32_to_cpu(dresp->mnt[0].state) != FSCS_HIDDEN)) {
-                        fsa_dev_ptr[index].valid = 1;
-                        fsa_dev_ptr[index].type = le32_to_cpu(dresp->mnt[0].vol);
-                        fsa_dev_ptr[index].size
-                          = ((u64)le32_to_cpu(dresp->mnt[0].capacity)) +
-                            (((u64)le32_to_cpu(dresp->mnt[0].capacityhigh)) << 32);
-                        if (le32_to_cpu(dresp->mnt[0].state) & FSCS_READONLY)
-                                    fsa_dev_ptr[index].ro = 1;
-                }
-                aac_fib_complete(fibptr);
                 /*
                  *      If there are no more containers, then stop asking.
                  */
-                if ((index + 1) >= le32_to_cpu(dresp->count)){
+                if (++index >= status)
                         break;
-                }
         }
-        aac_fib_free(fibptr);
         return status;
 }
 
@@ -382,8 +350,9 @@ static void aac_internal_transfer(struct scsi_cmnd *scsicmd, void *data, unsigne
                 buf = scsicmd->request_buffer;
                 transfer_len = min(scsicmd->request_bufflen, len + offset);
         }
-
-        memcpy(buf + offset, data, transfer_len - offset);
+        transfer_len -= offset;
+        if (buf && transfer_len)
+                memcpy(buf + offset, data, transfer_len);
 
         if (scsicmd->use_sg) 
                 kunmap_atomic(buf - sg->offset, KM_IRQ0);
@@ -396,7 +365,9 @@ static void get_container_name_callback(void *context, struct fib * fibptr)
         struct scsi_cmnd * scsicmd;
 
         scsicmd = (struct scsi_cmnd *) context;
-        scsicmd->SCp.phase = AAC_OWNER_MIDLEVEL;
+
+        if (!aac_valid_context(scsicmd, fibptr))
+                return;
 
         dprintk((KERN_DEBUG "get_container_name_callback[cpu %d]: t = %ld.\n", smp_processor_id(), jiffies));
         BUG_ON(fibptr == NULL);
@@ -431,7 +402,7 @@ static void get_container_name_callback(void *context, struct fib * fibptr)
 /**
  *      aac_get_container_name  -       get container name, none blocking.
  */
-static int aac_get_container_name(struct scsi_cmnd * scsicmd, int cid)
+static int aac_get_container_name(struct scsi_cmnd * scsicmd)
 {
         int status;
         struct aac_get_name *dinfo;
@@ -448,7 +419,7 @@ static int aac_get_container_name(struct scsi_cmnd * scsicmd, int cid)
 
         dinfo->command = cpu_to_le32(VM_ContainerConfig);
         dinfo->type = cpu_to_le32(CT_READ_NAME);
-        dinfo->cid = cpu_to_le32(cid);
+        dinfo->cid = cpu_to_le32(scmd_id(scsicmd));
         dinfo->count = cpu_to_le32(sizeof(((struct aac_get_name_resp *)NULL)->data));
 
         status = aac_fib_send(ContainerCommand,
@@ -473,85 +444,192 @@ static int aac_get_container_name(struct scsi_cmnd * scsicmd, int cid)
         return -1;
 }
 
-/**
- *      aac_probe_container             -       query a logical volume
- *      @dev: device to query
- *      @cid: container identifier
- *
- *      Queries the controller about the given volume. The volume information
- *      is updated in the struct fsa_dev_info structure rather than returned.
- */
- 
-int aac_probe_container(struct aac_dev *dev, int cid)
+static int aac_probe_container_callback2(struct scsi_cmnd * scsicmd)
+{
+        struct fsa_dev_info *fsa_dev_ptr = ((struct aac_dev *)(scsicmd->device->host->hostdata))->fsa_dev;
+
+        if (fsa_dev_ptr[scmd_id(scsicmd)].valid)
+                return aac_scsi_cmd(scsicmd);
+
+        scsicmd->result = DID_NO_CONNECT << 16;
+        scsicmd->scsi_done(scsicmd);
+        return 0;
+}
+
+static int _aac_probe_container2(void * context, struct fib * fibptr)
 {
         struct fsa_dev_info *fsa_dev_ptr;
-        int status;
+        int (*callback)(struct scsi_cmnd *);
+        struct scsi_cmnd * scsicmd = (struct scsi_cmnd *)context;
+
+        if (!aac_valid_context(scsicmd, fibptr))
+                return 0;
+
+        fsa_dev_ptr = ((struct aac_dev *)(scsicmd->device->host->hostdata))->fsa_dev;
+
+        scsicmd->SCp.Status = 0;
+        if (fsa_dev_ptr) {
+                struct aac_mount * dresp = (struct aac_mount *) fib_data(fibptr);
+                fsa_dev_ptr += scmd_id(scsicmd);
+
+                if ((le32_to_cpu(dresp->status) == ST_OK) &&
+                    (le32_to_cpu(dresp->mnt[0].vol) != CT_NONE) &&
+                    (le32_to_cpu(dresp->mnt[0].state) != FSCS_HIDDEN)) {
+                        fsa_dev_ptr->valid = 1;
+                        fsa_dev_ptr->type = le32_to_cpu(dresp->mnt[0].vol);
+                        fsa_dev_ptr->size
+                          = ((u64)le32_to_cpu(dresp->mnt[0].capacity)) +
+                            (((u64)le32_to_cpu(dresp->mnt[0].capacityhigh)) << 32);
+                        fsa_dev_ptr->ro = ((le32_to_cpu(dresp->mnt[0].state) & FSCS_READONLY) != 0);
+                }
+                if ((fsa_dev_ptr->valid & 1) == 0)
+                        fsa_dev_ptr->valid = 0;
+                scsicmd->SCp.Status = le32_to_cpu(dresp->count);
+        }
+        aac_fib_complete(fibptr);
+        aac_fib_free(fibptr);
+        callback = (int (*)(struct scsi_cmnd *))(scsicmd->SCp.ptr);
+        scsicmd->SCp.ptr = NULL;
+        return (*callback)(scsicmd);
+}
+
+static int _aac_probe_container1(void * context, struct fib * fibptr)
+{
+        struct scsi_cmnd * scsicmd;
+        struct aac_mount * dresp;
         struct aac_query_mount *dinfo;
-        struct aac_mount *dresp;
-        struct fib * fibptr;
-        unsigned instance;
+        int status;
 
-        fsa_dev_ptr = dev->fsa_dev;
-        if (!fsa_dev_ptr)
-                return -ENOMEM;
-        instance = dev->scsi_host_ptr->unique_id;
+        dresp = (struct aac_mount *) fib_data(fibptr);
+        dresp->mnt[0].capacityhigh = 0;
+        if ((le32_to_cpu(dresp->status) != ST_OK) ||
+            (le32_to_cpu(dresp->mnt[0].vol) != CT_NONE))
+                return _aac_probe_container2(context, fibptr);
+        scsicmd = (struct scsi_cmnd *) context;
+        scsicmd->SCp.phase = AAC_OWNER_MIDLEVEL;
 
-        if (!(fibptr = aac_fib_alloc(dev)))
-                return -ENOMEM;
+        if (!aac_valid_context(scsicmd, fibptr))
+                return 0;
 
         aac_fib_init(fibptr);
 
         dinfo = (struct aac_query_mount *)fib_data(fibptr);
 
-        dinfo->command = cpu_to_le32(VM_NameServe);
-        dinfo->count = cpu_to_le32(cid);
+        dinfo->command = cpu_to_le32(VM_NameServe64);
+        dinfo->count = cpu_to_le32(scmd_id(scsicmd));
         dinfo->type = cpu_to_le32(FT_FILESYS);
 
         status = aac_fib_send(ContainerCommand,
-                            fibptr,
-                            sizeof(struct aac_query_mount),
-                            FsaNormal,
-                            1, 1,
-                            NULL, NULL);
+                          fibptr,
+                          sizeof(struct aac_query_mount),
+                          FsaNormal,
+                          0, 1,
+                          (fib_callback) _aac_probe_container2,
+                          (void *) scsicmd);
+        /*
+         *      Check that the command queued to the controller
+         */
+        if (status == -EINPROGRESS) {
+                scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
+                return 0;
+        }
         if (status < 0) {
-                printk(KERN_WARNING "aacraid: aac_probe_container query failed.\n");
-                goto error;
+                /* Inherit results from VM_NameServe, if any */
+                dresp->status = cpu_to_le32(ST_OK);
+                return _aac_probe_container2(context, fibptr);
         }
+        return 0;
+}
 
-        dresp = (struct aac_mount *) fib_data(fibptr);
+static int _aac_probe_container(struct scsi_cmnd * scsicmd, int (*callback)(struct scsi_cmnd *))
+{
+        struct fib * fibptr;
+        int status = -ENOMEM;
 
-        if ((le32_to_cpu(dresp->status) == ST_OK) &&
-            (le32_to_cpu(dresp->mnt[0].vol) == CT_NONE)) {
-                dinfo->command = cpu_to_le32(VM_NameServe64);
-                dinfo->count = cpu_to_le32(cid);
-                dinfo->type = cpu_to_le32(FT_FILESYS);
+        if ((fibptr = aac_fib_alloc((struct aac_dev *)scsicmd->device->host->hostdata))) {
+                struct aac_query_mount *dinfo;
 
-                if (aac_fib_send(ContainerCommand,
-                            fibptr,
-                            sizeof(struct aac_query_mount),
-                            FsaNormal,
-                            1, 1,
-                            NULL, NULL) < 0)
-                        goto error;
-        } else
-                dresp->mnt[0].capacityhigh = 0;
+                aac_fib_init(fibptr);
+
+                dinfo = (struct aac_query_mount *)fib_data(fibptr);
+
+                dinfo->command = cpu_to_le32(VM_NameServe);
+                dinfo->count = cpu_to_le32(scmd_id(scsicmd));
+                dinfo->type = cpu_to_le32(FT_FILESYS);
+                scsicmd->SCp.ptr = (char *)callback;
 
-        if ((le32_to_cpu(dresp->status) == ST_OK) &&
-            (le32_to_cpu(dresp->mnt[0].vol) != CT_NONE) &&
-            (le32_to_cpu(dresp->mnt[0].state) != FSCS_HIDDEN)) {
-                fsa_dev_ptr[cid].valid = 1;
-                fsa_dev_ptr[cid].type = le32_to_cpu(dresp->mnt[0].vol);
-                fsa_dev_ptr[cid].size
-                  = ((u64)le32_to_cpu(dresp->mnt[0].capacity)) +
-                    (((u64)le32_to_cpu(dresp->mnt[0].capacityhigh)) << 32);
-                if (le32_to_cpu(dresp->mnt[0].state) & FSCS_READONLY)
-                        fsa_dev_ptr[cid].ro = 1;
+                status = aac_fib_send(ContainerCommand,
+                          fibptr,
+                          sizeof(struct aac_query_mount),
+                          FsaNormal,
+                          0, 1,
+                          (fib_callback) _aac_probe_container1,
+                          (void *) scsicmd);
+                /*
+                 *      Check that the command queued to the controller
+                 */
+                if (status == -EINPROGRESS) {
+                        scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
+                        return 0;
+                }
+                if (status < 0) {
+                        scsicmd->SCp.ptr = NULL;
+                        aac_fib_complete(fibptr);
+                        aac_fib_free(fibptr);
+                }
         }
+        if (status < 0) {
+                struct fsa_dev_info *fsa_dev_ptr = ((struct aac_dev *)(scsicmd->device->host->hostdata))->fsa_dev;
+                if (fsa_dev_ptr) {
+                        fsa_dev_ptr += scmd_id(scsicmd);
+                        if ((fsa_dev_ptr->valid & 1) == 0) {
+                                fsa_dev_ptr->valid = 0;
+                                return (*callback)(scsicmd);
+                        }
+                }
+        }
+        return status;
+}
 
-error:
-        aac_fib_complete(fibptr);
-        aac_fib_free(fibptr);
+/**
+ *      aac_probe_container             -       query a logical volume
+ *      @dev: device to query
+ *      @cid: container identifier
+ *
+ *      Queries the controller about the given volume. The volume information
+ *      is updated in the struct fsa_dev_info structure rather than returned.
+ */
+static int aac_probe_container_callback1(struct scsi_cmnd * scsicmd)
+{
+        scsicmd->device = NULL;
+        return 0;
+}
+
+int aac_probe_container(struct aac_dev *dev, int cid)
+{
+        struct scsi_cmnd *scsicmd = kmalloc(sizeof(*scsicmd), GFP_KERNEL);
+        struct scsi_device *scsidev = kmalloc(sizeof(*scsidev), GFP_KERNEL);
+        int status;
 
+        if (!scsicmd || !scsidev) {
+                kfree(scsicmd);
+                kfree(scsidev);
+                return -ENOMEM;
+        }
+        scsicmd->list.next = NULL;
+        scsicmd->scsi_done = (void (*)(struct scsi_cmnd*))_aac_probe_container1;
+
+        scsicmd->device = scsidev;
+        scsidev->sdev_state = 0;
+        scsidev->id = cid;
+        scsidev->host = dev->scsi_host_ptr;
+
+        if (_aac_probe_container(scsicmd, aac_probe_container_callback1) == 0)
+                while (scsicmd->device == scsidev)
+                        schedule();
+        kfree(scsidev);
+        status = scsicmd->SCp.Status;
+        kfree(scsicmd);
         return status;
 }
 
@@ -1115,6 +1193,12 @@ int aac_get_adapter_info(struct aac_dev* dev)
                         printk(KERN_INFO "%s%d: serial %x\n",
                                 dev->name, dev->id,
                                 le32_to_cpu(dev->adapter_info.serial[0]));
+                if (dev->supplement_adapter_info.VpdInfo.Tsid[0]) {
+                        printk(KERN_INFO "%s%d: TSID %.*s\n",
+                          dev->name, dev->id,
+                          (int)sizeof(dev->supplement_adapter_info.VpdInfo.Tsid),
+                          dev->supplement_adapter_info.VpdInfo.Tsid);
+                }
         }
 
         dev->nondasd_support = 0;
@@ -1241,7 +1325,9 @@ static void io_callback(void *context, struct fib * fibptr)
         u32 cid;
 
         scsicmd = (struct scsi_cmnd *) context;
-        scsicmd->SCp.phase = AAC_OWNER_MIDLEVEL;
+
+        if (!aac_valid_context(scsicmd, fibptr))
+                return;
 
         dev = (struct aac_dev *)scsicmd->device->host->hostdata;
         cid = scmd_id(scsicmd);
@@ -1317,7 +1403,7 @@ static void io_callback(void *context, struct fib * fibptr)
         scsicmd->scsi_done(scsicmd);
 }
 
-static int aac_read(struct scsi_cmnd * scsicmd, int cid)
+static int aac_read(struct scsi_cmnd * scsicmd)
 {
         u64 lba;
         u32 count;
@@ -1331,7 +1417,7 @@ static int aac_read(struct scsi_cmnd * scsicmd, int cid)
          */
         switch (scsicmd->cmnd[0]) {
         case READ_6:
-                dprintk((KERN_DEBUG "aachba: received a read(6) command on id %d.\n", cid));
+                dprintk((KERN_DEBUG "aachba: received a read(6) command on id %d.\n", scmd_id(scsicmd)));
 
                 lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | 
                         (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3];
@@ -1341,7 +1427,7 @@ static int aac_read(struct scsi_cmnd * scsicmd, int cid)
                         count = 256;
                 break;
         case READ_16:
-                dprintk((KERN_DEBUG "aachba: received a read(16) command on id %d.\n", cid));
+                dprintk((KERN_DEBUG "aachba: received a read(16) command on id %d.\n", scmd_id(scsicmd)));
 
                 lba =   ((u64)scsicmd->cmnd[2] << 56) |
                         ((u64)scsicmd->cmnd[3] << 48) |
@@ -1355,7 +1441,7 @@ static int aac_read(struct scsi_cmnd * scsicmd, int cid)
                         (scsicmd->cmnd[12] << 8) | scsicmd->cmnd[13];
                 break;
         case READ_12:
-                dprintk((KERN_DEBUG "aachba: received a read(12) command on id %d.\n", cid));
+                dprintk((KERN_DEBUG "aachba: received a read(12) command on id %d.\n", scmd_id(scsicmd)));
 
                 lba = ((u64)scsicmd->cmnd[2] << 24) | 
                         (scsicmd->cmnd[3] << 16) |
@@ -1365,7 +1451,7 @@ static int aac_read(struct scsi_cmnd * scsicmd, int cid)
                         (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9];
                 break;
         default:
-                dprintk((KERN_DEBUG "aachba: received a read(10) command on id %d.\n", cid));
+                dprintk((KERN_DEBUG "aachba: received a read(10) command on id %d.\n", scmd_id(scsicmd)));
 
                 lba = ((u64)scsicmd->cmnd[2] << 24) | 
                         (scsicmd->cmnd[3] << 16) | 
@@ -1405,7 +1491,7 @@ static int aac_read(struct scsi_cmnd * scsicmd, int cid)
         return 0;
 }
 
-static int aac_write(struct scsi_cmnd * scsicmd, int cid)
+static int aac_write(struct scsi_cmnd * scsicmd)
 {
         u64 lba;
         u32 count;
@@ -1424,7 +1510,7 @@ static int aac_write(struct scsi_cmnd * scsicmd, int cid)
                 if (count == 0)
                         count = 256;
         } else if (scsicmd->cmnd[0] == WRITE_16) { /* 16 byte command */
-                dprintk((KERN_DEBUG "aachba: received a write(16) command on id %d.\n", cid));
+                dprintk((KERN_DEBUG "aachba: received a write(16) command on id %d.\n", scmd_id(scsicmd)));
 
                 lba =   ((u64)scsicmd->cmnd[2] << 56) |
                         ((u64)scsicmd->cmnd[3] << 48) |
@@ -1436,14 +1522,14 @@ static int aac_write(struct scsi_cmnd * scsicmd, int cid)
                 count = (scsicmd->cmnd[10] << 24) | (scsicmd->cmnd[11] << 16) |
                         (scsicmd->cmnd[12] << 8) | scsicmd->cmnd[13];
         } else if (scsicmd->cmnd[0] == WRITE_12) { /* 12 byte command */
-                dprintk((KERN_DEBUG "aachba: received a write(12) command on id %d.\n", cid));
+                dprintk((KERN_DEBUG "aachba: received a write(12) command on id %d.\n", scmd_id(scsicmd)));
 
                 lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16)
                     | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5];
                 count = (scsicmd->cmnd[6] << 24) | (scsicmd->cmnd[7] << 16)
                       | (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9];
         } else {
-                dprintk((KERN_DEBUG "aachba: received a write(10) command on id %d.\n", cid));
+                dprintk((KERN_DEBUG "aachba: received a write(10) command on id %d.\n", scmd_id(scsicmd)));
                 lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5];
                 count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8];
         }
@@ -1488,7 +1574,9 @@ static void synchronize_callback(void *context, struct fib *fibptr)
         struct scsi_cmnd *cmd;
 
         cmd = context;
-        cmd->SCp.phase = AAC_OWNER_MIDLEVEL;
+
+        if (!aac_valid_context(cmd, fibptr))
+                return;
 
         dprintk((KERN_DEBUG "synchronize_callback[cpu %d]: t = %ld.\n", 
                                 smp_processor_id(), jiffies));
@@ -1523,7 +1611,7 @@ static void synchronize_callback(void *context, struct fib *fibptr)
         cmd->scsi_done(cmd);
 }
 
-static int aac_synchronize(struct scsi_cmnd *scsicmd, int cid)
+static int aac_synchronize(struct scsi_cmnd *scsicmd)
 {
         int status;
         struct fib *cmd_fibcontext;
@@ -1568,7 +1656,7 @@ static int aac_synchronize(struct scsi_cmnd *scsicmd, int cid)
         synchronizecmd = fib_data(cmd_fibcontext);
         synchronizecmd->command = cpu_to_le32(VM_ContainerConfig);
         synchronizecmd->type = cpu_to_le32(CT_FLUSH_CACHE);
-        synchronizecmd->cid = cpu_to_le32(cid);
+        synchronizecmd->cid = cpu_to_le32(scmd_id(scsicmd));
         synchronizecmd->count = 
              cpu_to_le32(sizeof(((struct aac_synchronize_reply *)NULL)->data));
 
@@ -1646,29 +1734,12 @@ int aac_scsi_cmd(struct scsi_cmnd * scsicmd)
                                 case TEST_UNIT_READY:
                                         if (dev->in_reset)
                                                 return -1;
-                                        spin_unlock_irq(host->host_lock);
-                                        aac_probe_container(dev, cid);
-                                        if ((fsa_dev_ptr[cid].valid & 1) == 0)
-                                                fsa_dev_ptr[cid].valid = 0;
-                                        spin_lock_irq(host->host_lock);
-                                        if (fsa_dev_ptr[cid].valid == 0) {
-                                                scsicmd->result = DID_NO_CONNECT << 16;
-                                                scsicmd->scsi_done(scsicmd);
-                                                return 0;
-                                        }
+                                        return _aac_probe_container(scsicmd,
+                                                        aac_probe_container_callback2);
                                 default:
                                         break;
                                 }
                         }
-                        /*
-                         *      If the target container still doesn't exist, 
-                         *      return failure
-                         */
-                        if (fsa_dev_ptr[cid].valid == 0) {
-                                scsicmd->result = DID_BAD_TARGET << 16;
-                                scsicmd->scsi_done(scsicmd);
-                                return 0;
-                        }
                 } else {  /* check for physical non-dasd devices */
                         if ((dev->nondasd_support == 1) || expose_physicals) {
                                 if (dev->in_reset)
@@ -1733,7 +1804,7 @@ int aac_scsi_cmd(struct scsi_cmnd * scsicmd)
                 setinqstr(dev, (void *) (inq_data.inqd_vid), fsa_dev_ptr[cid].type);
                 inq_data.inqd_pdt = INQD_PDT_DA;        /* Direct/random access device */
                 aac_internal_transfer(scsicmd, &inq_data, 0, sizeof(inq_data));
-                return aac_get_container_name(scsicmd, cid);
+                return aac_get_container_name(scsicmd);
         }
         case SERVICE_ACTION_IN:
                 if (!(dev->raw_io_interface) ||
@@ -1899,7 +1970,7 @@ int aac_scsi_cmd(struct scsi_cmnd * scsicmd)
                                 min(sizeof(fsa_dev_ptr[cid].devname),
                                 sizeof(scsicmd->request->rq_disk->disk_name) + 1));
 
-                        return aac_read(scsicmd, cid);
+                        return aac_read(scsicmd);
 
                 case WRITE_6:
                 case WRITE_10:
@@ -1907,11 +1978,11 @@ int aac_scsi_cmd(struct scsi_cmnd * scsicmd)
                 case WRITE_16:
                         if (dev->in_reset)
                                 return -1;
-                        return aac_write(scsicmd, cid);
+                        return aac_write(scsicmd);
 
                 case SYNCHRONIZE_CACHE:
                         /* Issue FIB to tell Firmware to flush it's cache */
-                        return aac_synchronize(scsicmd, cid);
+                        return aac_synchronize(scsicmd);
                         
                 default:
                         /*
@@ -2058,7 +2129,10 @@ static void aac_srb_callback(void *context, struct fib * fibptr)
         struct scsi_cmnd *scsicmd;
 
         scsicmd = (struct scsi_cmnd *) context;
-        scsicmd->SCp.phase = AAC_OWNER_MIDLEVEL;
+
+        if (!aac_valid_context(scsicmd, fibptr))
+                return;
+
         dev = (struct aac_dev *)scsicmd->device->host->hostdata;
 
         BUG_ON(fibptr == NULL);
diff --git a/drivers/scsi/aacraid/aacraid.h b/drivers/scsi/aacraid/aacraid.h
index 39ecd0d22eb0..45ca3e801619 100644
--- a/drivers/scsi/aacraid/aacraid.h
+++ b/drivers/scsi/aacraid/aacraid.h
@@ -12,8 +12,8 @@
  *----------------------------------------------------------------------------*/
 
 #ifndef AAC_DRIVER_BUILD
-# define AAC_DRIVER_BUILD 2423
-# define AAC_DRIVER_BRANCH "-mh3"
+# define AAC_DRIVER_BUILD 2437
+# define AAC_DRIVER_BRANCH "-mh4"
 #endif
 #define MAXIMUM_NUM_CONTAINERS  32
 
@@ -48,49 +48,13 @@ struct diskparm
 
 
 /*
- *      DON'T CHANGE THE ORDER, this is set by the firmware
+ *      Firmware constants
  */
  
 #define         CT_NONE                 0
-#define         CT_VOLUME               1
-#define         CT_MIRROR               2
-#define         CT_STRIPE               3
-#define         CT_RAID5                4
-#define         CT_SSRW                 5
-#define         CT_SSRO                 6
-#define         CT_MORPH                7
-#define         CT_PASSTHRU             8
-#define         CT_RAID4                9
-#define         CT_RAID10               10      /* stripe of mirror */
-#define         CT_RAID00               11      /* stripe of stripe */
-#define         CT_VOLUME_OF_MIRRORS    12      /* volume of mirror */
-#define         CT_PSEUDO_RAID          13      /* really raid4 */
-#define         CT_LAST_VOLUME_TYPE     14
 #define         CT_OK                   218
-
-/*
- *      Types of objects addressable in some fashion by the client.
- *      This is a superset of those objects handled just by the filesystem
- *      and includes "raw" objects that an administrator would use to
- *      configure containers and filesystems.
- */
-
-#define         FT_REG          1       /* regular file */
-#define         FT_DIR          2       /* directory */
-#define         FT_BLK          3       /* "block" device - reserved */
-#define         FT_CHR          4       /* "character special" device - reserved */
-#define         FT_LNK          5       /* symbolic link */
-#define         FT_SOCK         6       /* socket */
-#define         FT_FIFO         7       /* fifo */
 #define         FT_FILESYS      8       /* ADAPTEC's "FSA"(tm) filesystem */
 #define         FT_DRIVE        9       /* physical disk - addressable in scsi by bus/id/lun */
-#define         FT_SLICE        10      /* virtual disk - raw volume - slice */
-#define         FT_PARTITION    11      /* FSA partition - carved out of a slice - building block for containers */
-#define         FT_VOLUME       12      /* Container - Volume Set */
-#define         FT_STRIPE       13      /* Container - Stripe Set */
-#define         FT_MIRROR       14      /* Container - Mirror Set */
-#define         FT_RAID5        15      /* Container - Raid 5 Set */
-#define         FT_DATABASE     16      /* Storage object with "foreign" content manager */
 
 /*
  *      Host side memory scatter gather list
@@ -497,6 +461,7 @@ struct adapter_ops
         void (*adapter_enable_int)(struct aac_dev *dev);
         int  (*adapter_sync_cmd)(struct aac_dev *dev, u32 command, u32 p1, u32 p2, u32 p3, u32 p4, u32 p5, u32 p6, u32 *status, u32 *r1, u32 *r2, u32 *r3, u32 *r4);
         int  (*adapter_check_health)(struct aac_dev *dev);
+        int  (*adapter_restart)(struct aac_dev *dev, int bled);
         /* Transport operations */
         int  (*adapter_ioremap)(struct aac_dev * dev, u32 size);
         irqreturn_t (*adapter_intr)(int irq, void *dev_id);
@@ -833,7 +798,7 @@ struct fib {
          */
         struct list_head        fiblink;
         void                    *data;
-        struct hw_fib           *hw_fib;                /* Actual shared object */
+        struct hw_fib           *hw_fib_va;             /* Actual shared object */
         dma_addr_t              hw_fib_pa;              /* physical address of hw_fib*/
 };
 
@@ -878,10 +843,25 @@ struct aac_supplement_adapter_info
         __le32  Version;
         __le32  FeatureBits;
         u8      SlotNumber;
-        u8      ReservedPad0[0];
+        u8      ReservedPad0[3];
         u8      BuildDate[12];
         __le32  CurrentNumberPorts;
-        __le32  ReservedGrowth[24];
+        struct {
+                u8      AssemblyPn[8];
+                u8      FruPn[8];
+                u8      BatteryFruPn[8];
+                u8      EcVersionString[8];
+                u8      Tsid[12];
+        }       VpdInfo;
+        __le32  FlashFirmwareRevision;
+        __le32  FlashFirmwareBuild;
+        __le32  RaidTypeMorphOptions;
+        __le32  FlashFirmwareBootRevision;
+        __le32  FlashFirmwareBootBuild;
+        u8      MfgPcbaSerialNo[12];
+        u8      MfgWWNName[8];
+        __le32  MoreFeatureBits;
+        __le32  ReservedGrowth[1];
 };
 #define AAC_FEATURE_FALCON      0x00000010
 #define AAC_SIS_VERSION_V3      3
@@ -970,7 +950,6 @@ struct aac_dev
         struct fib              *fibs;
 
         struct fib              *free_fib;
-        struct fib              *timeout_fib;
         spinlock_t              fib_lock;
         
         struct aac_queue_block *queues;
@@ -1060,6 +1039,9 @@ struct aac_dev
 #define aac_adapter_check_health(dev) \
         (dev)->a_ops.adapter_check_health(dev)
 
+#define aac_adapter_restart(dev,bled) \
+        (dev)->a_ops.adapter_restart(dev,bled)
+
 #define aac_adapter_ioremap(dev, size) \
         (dev)->a_ops.adapter_ioremap(dev, size)
 
@@ -1516,8 +1498,7 @@ struct aac_mntent {
         struct creation_info    create_info;    /* if applicable */
         __le32                  capacity;
         __le32                  vol;            /* substrate structure */
-        __le32                  obj;            /* FT_FILESYS, 
-                                                   FT_DATABASE, etc. */
+        __le32                  obj;            /* FT_FILESYS, etc. */
         __le32                  state;          /* unready for mounting, 
                                                    readonly, etc. */
         union aac_contentinfo   fileinfo;       /* Info specific to content 
@@ -1817,7 +1798,7 @@ int aac_fib_send(u16 command, struct fib * context, unsigned long size, int prio
 int aac_consumer_get(struct aac_dev * dev, struct aac_queue * q, struct aac_entry **entry);
 void aac_consumer_free(struct aac_dev * dev, struct aac_queue * q, u32 qnum);
 int aac_fib_complete(struct fib * context);
-#define fib_data(fibctx) ((void *)(fibctx)->hw_fib->data)
+#define fib_data(fibctx) ((void *)(fibctx)->hw_fib_va->data)
 struct aac_dev *aac_init_adapter(struct aac_dev *dev);
 int aac_get_config_status(struct aac_dev *dev, int commit_flag);
 int aac_get_containers(struct aac_dev *dev);
@@ -1840,8 +1821,11 @@ struct aac_driver_ident* aac_get_driver_ident(int devtype);
 int aac_get_adapter_info(struct aac_dev* dev);
 int aac_send_shutdown(struct aac_dev *dev);
 int aac_probe_container(struct aac_dev *dev, int cid);
+int _aac_rx_init(struct aac_dev *dev);
+int aac_rx_select_comm(struct aac_dev *dev, int comm);
 extern int numacb;
 extern int acbsize;
 extern char aac_driver_version[];
 extern int startup_timeout;
 extern int aif_timeout;
+extern int expose_physicals;
diff --git a/drivers/scsi/aacraid/commctrl.c b/drivers/scsi/aacraid/commctrl.c
index e21070f4eac1..72b0393b4596 100644
--- a/drivers/scsi/aacraid/commctrl.c
+++ b/drivers/scsi/aacraid/commctrl.c
@@ -5,7 +5,7 @@
  * based on the old aacraid driver that is..
  * Adaptec aacraid device driver for Linux.
  *
- * Copyright (c) 2000 Adaptec, Inc. (aacraid@adaptec.com)
+ * Copyright (c) 2000-2007 Adaptec, Inc. (aacraid@adaptec.com)
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -64,12 +64,15 @@ static int ioctl_send_fib(struct aac_dev * dev, void __user *arg)
         unsigned size;
         int retval;
 
+        if (dev->in_reset) {
+                return -EBUSY;
+        }
         fibptr = aac_fib_alloc(dev);
         if(fibptr == NULL) {
                 return -ENOMEM;
         }
                 
-        kfib = fibptr->hw_fib;
+        kfib = fibptr->hw_fib_va;
         /*
          *      First copy in the header so that we can check the size field.
          */
@@ -91,9 +94,9 @@ static int ioctl_send_fib(struct aac_dev * dev, void __user *arg)
                         goto cleanup;
                 }
                 /* Highjack the hw_fib */
-                hw_fib = fibptr->hw_fib;
+                hw_fib = fibptr->hw_fib_va;
                 hw_fib_pa = fibptr->hw_fib_pa;
-                fibptr->hw_fib = kfib = pci_alloc_consistent(dev->pdev, size, &fibptr->hw_fib_pa);
+                fibptr->hw_fib_va = kfib = pci_alloc_consistent(dev->pdev, size, &fibptr->hw_fib_pa);
                 memset(((char *)kfib) + dev->max_fib_size, 0, size - dev->max_fib_size);
                 memcpy(kfib, hw_fib, dev->max_fib_size);
         }
@@ -137,7 +140,7 @@ cleanup:
         if (hw_fib) {
                 pci_free_consistent(dev->pdev, size, kfib, fibptr->hw_fib_pa);
                 fibptr->hw_fib_pa = hw_fib_pa;
-                fibptr->hw_fib = hw_fib;
+                fibptr->hw_fib_va = hw_fib;
         }
         if (retval != -EINTR)
                 aac_fib_free(fibptr);
@@ -282,15 +285,15 @@ return_fib:
                 fib = list_entry(entry, struct fib, fiblink);
                 fibctx->count--;
                 spin_unlock_irqrestore(&dev->fib_lock, flags);
-                if (copy_to_user(f.fib, fib->hw_fib, sizeof(struct hw_fib))) {
-                        kfree(fib->hw_fib);
+                if (copy_to_user(f.fib, fib->hw_fib_va, sizeof(struct hw_fib))) {
+                        kfree(fib->hw_fib_va);
                         kfree(fib);
                         return -EFAULT;
                 }       
                 /*
                  *      Free the space occupied by this copy of the fib.
                  */
-                kfree(fib->hw_fib);
+                kfree(fib->hw_fib_va);
                 kfree(fib);
                 status = 0;
         } else {
@@ -340,7 +343,7 @@ int aac_close_fib_context(struct aac_dev * dev, struct aac_fib_context * fibctx)
                 /*
                  *      Free the space occupied by this copy of the fib.
                  */
-                kfree(fib->hw_fib);
+                kfree(fib->hw_fib_va);
                 kfree(fib);
         }
         /*
@@ -388,10 +391,8 @@ static int close_getadapter_fib(struct aac_dev * dev, void __user *arg)
                 /*
                  *      Extract the fibctx from the input parameters
                  */
-                if (fibctx->unique == (u32)(unsigned long)arg) {   
-                        /* We found a winner */
+                if (fibctx->unique == (u32)(ptrdiff_t)arg) /* We found a winner */
                         break;
-                }
                 entry = entry->next;
                 fibctx = NULL;
         }
@@ -465,16 +466,20 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
         void *sg_list[32];
         u32   sg_indx = 0;
         u32 byte_count = 0;
-        u32 actual_fibsize = 0;
+        u32 actual_fibsize64, actual_fibsize = 0;
         int i;
 
 
+        if (dev->in_reset) {
+                dprintk((KERN_DEBUG"aacraid: send raw srb -EBUSY\n"));
+                return -EBUSY;
+        }
         if (!capable(CAP_SYS_ADMIN)){
                 dprintk((KERN_DEBUG"aacraid: No permission to send raw srb\n")); 
                 return -EPERM;
         }
         /*
-         *      Allocate and initialize a Fib then setup a BlockWrite command
+         *      Allocate and initialize a Fib then setup a SRB command
          */
         if (!(srbfib = aac_fib_alloc(dev))) {
                 return -ENOMEM;
@@ -541,129 +546,183 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
                 rcode = -EINVAL;
                 goto cleanup;
         }
-        if (dev->dac_support == 1) {
+        actual_fibsize = sizeof(struct aac_srb) - sizeof(struct sgentry) +
+                ((user_srbcmd->sg.count & 0xff) * sizeof(struct sgentry));
+        actual_fibsize64 = actual_fibsize + (user_srbcmd->sg.count & 0xff) *
+          (sizeof(struct sgentry64) - sizeof(struct sgentry));
+        /* User made a mistake - should not continue */
+        if ((actual_fibsize != fibsize) && (actual_fibsize64 != fibsize)) {
+                dprintk((KERN_DEBUG"aacraid: Bad Size specified in "
+                  "Raw SRB command calculated fibsize=%lu;%lu "
+                  "user_srbcmd->sg.count=%d aac_srb=%lu sgentry=%lu;%lu "
+                  "issued fibsize=%d\n",
+                  actual_fibsize, actual_fibsize64, user_srbcmd->sg.count,
+                  sizeof(struct aac_srb), sizeof(struct sgentry),
+                  sizeof(struct sgentry64), fibsize));
+                rcode = -EINVAL;
+                goto cleanup;
+        }
+        if ((data_dir == DMA_NONE) && user_srbcmd->sg.count) {
+                dprintk((KERN_DEBUG"aacraid: SG with no direction specified in Raw SRB command\n"));
+                rcode = -EINVAL;
+                goto cleanup;
+        }
+        byte_count = 0;
+        if (dev->adapter_info.options & AAC_OPT_SGMAP_HOST64) {
                 struct user_sgmap64* upsg = (struct user_sgmap64*)&user_srbcmd->sg;
                 struct sgmap64* psg = (struct sgmap64*)&srbcmd->sg;
-                struct user_sgmap* usg;
-                byte_count = 0;
 
                 /*
                  * This should also catch if user used the 32 bit sgmap
                  */
-                actual_fibsize = sizeof(struct aac_srb) - 
-                        sizeof(struct sgentry) +
-                        ((upsg->count & 0xff) * 
-                        sizeof(struct sgentry));
-                if(actual_fibsize != fibsize){ // User made a mistake - should not continue
-                        dprintk((KERN_DEBUG"aacraid: Bad Size specified in Raw SRB command\n"));
-                        rcode = -EINVAL;
-                        goto cleanup;
-                }
-                usg = kmalloc(actual_fibsize - sizeof(struct aac_srb)
-                  + sizeof(struct sgmap), GFP_KERNEL);
-                if (!usg) {
-                        dprintk((KERN_DEBUG"aacraid: Allocation error in Raw SRB command\n"));
-                        rcode = -ENOMEM;
-                        goto cleanup;
-                }
-                memcpy (usg, upsg, actual_fibsize - sizeof(struct aac_srb)
-                  + sizeof(struct sgmap));
-                actual_fibsize = sizeof(struct aac_srb) - 
-                        sizeof(struct sgentry) + ((usg->count & 0xff) * 
-                                sizeof(struct sgentry64));
-                if ((data_dir == DMA_NONE) && upsg->count) {
-                        kfree (usg);
-                        dprintk((KERN_DEBUG"aacraid: SG with no direction specified in Raw SRB command\n"));
-                        rcode = -EINVAL;
-                        goto cleanup;
-                }
+                if (actual_fibsize64 == fibsize) {
+                        actual_fibsize = actual_fibsize64;
+                        for (i = 0; i < upsg->count; i++) {
+                                u64 addr;
+                                void* p;
+                                /* Does this really need to be GFP_DMA? */
+                                p = kmalloc(upsg->sg[i].count,GFP_KERNEL|__GFP_DMA);
+                                if(p == 0) {
+                                        dprintk((KERN_DEBUG"aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
+                                          upsg->sg[i].count,i,upsg->count));
+                                        rcode = -ENOMEM;
+                                        goto cleanup;
+                                }
+                                addr = (u64)upsg->sg[i].addr[0];
+                                addr += ((u64)upsg->sg[i].addr[1]) << 32;
+                                sg_user[i] = (void __user *)(ptrdiff_t)addr;
+                                sg_list[i] = p; // save so we can clean up later
+                                sg_indx = i;
+
+                                if( flags & SRB_DataOut ){
+                                        if(copy_from_user(p,sg_user[i],upsg->sg[i].count)){
+                                                dprintk((KERN_DEBUG"aacraid: Could not copy sg data from user\n"));
+                                                rcode = -EFAULT;
+                                                goto cleanup;
+                                        }
+                                }
+                                addr = pci_map_single(dev->pdev, p, upsg->sg[i].count, data_dir);
 
-                for (i = 0; i < usg->count; i++) {
-                        u64 addr;
-                        void* p;
-                        /* Does this really need to be GFP_DMA? */
-                        p = kmalloc(usg->sg[i].count,GFP_KERNEL|__GFP_DMA);
-                        if(p == 0) {
-                                kfree (usg);
-                                dprintk((KERN_DEBUG"aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
-                                  usg->sg[i].count,i,usg->count));
+                                psg->sg[i].addr[0] = cpu_to_le32(addr & 0xffffffff);
+                                psg->sg[i].addr[1] = cpu_to_le32(addr>>32);
+                                byte_count += upsg->sg[i].count;
+                                psg->sg[i].count = cpu_to_le32(upsg->sg[i].count);
+                        }
+                } else {
+                        struct user_sgmap* usg;
+                        usg = kmalloc(actual_fibsize - sizeof(struct aac_srb)
+                          + sizeof(struct sgmap), GFP_KERNEL);
+                        if (!usg) {
+                                dprintk((KERN_DEBUG"aacraid: Allocation error in Raw SRB command\n"));
                                 rcode = -ENOMEM;
                                 goto cleanup;
                         }
-                        sg_user[i] = (void __user *)(long)usg->sg[i].addr;
-                        sg_list[i] = p; // save so we can clean up later
-                        sg_indx = i;
-
-                        if( flags & SRB_DataOut ){
-                                if(copy_from_user(p,sg_user[i],upsg->sg[i].count)){
+                        memcpy (usg, upsg, actual_fibsize - sizeof(struct aac_srb)
+                          + sizeof(struct sgmap));
+                        actual_fibsize = actual_fibsize64;
+
+                        for (i = 0; i < usg->count; i++) {
+                                u64 addr;
+                                void* p;
+                                /* Does this really need to be GFP_DMA? */
+                                p = kmalloc(usg->sg[i].count,GFP_KERNEL|__GFP_DMA);
+                                if(p == 0) {
                                         kfree (usg);
-                                        dprintk((KERN_DEBUG"aacraid: Could not copy sg data from user\n")); 
-                                        rcode = -EFAULT;
+                                        dprintk((KERN_DEBUG"aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
+                                          usg->sg[i].count,i,usg->count));
+                                        rcode = -ENOMEM;
                                         goto cleanup;
                                 }
-                        }
-                        addr = pci_map_single(dev->pdev, p, usg->sg[i].count, data_dir);
+                                sg_user[i] = (void __user *)(ptrdiff_t)usg->sg[i].addr;
+                                sg_list[i] = p; // save so we can clean up later
+                                sg_indx = i;
+
+                                if( flags & SRB_DataOut ){
+                                        if(copy_from_user(p,sg_user[i],upsg->sg[i].count)){
+                                                kfree (usg);
+                                                dprintk((KERN_DEBUG"aacraid: Could not copy sg data from user\n"));
+                                                rcode = -EFAULT;
+                                                goto cleanup;
+                                        }
+                                }
+                                addr = pci_map_single(dev->pdev, p, usg->sg[i].count, data_dir);
 
-                        psg->sg[i].addr[0] = cpu_to_le32(addr & 0xffffffff);
-                        psg->sg[i].addr[1] = cpu_to_le32(addr>>32);
-                        psg->sg[i].count = cpu_to_le32(usg->sg[i].count);  
-                        byte_count += usg->sg[i].count;
+                                psg->sg[i].addr[0] = cpu_to_le32(addr & 0xffffffff);
+                                psg->sg[i].addr[1] = cpu_to_le32(addr>>32);
+                                byte_count += usg->sg[i].count;
+                                psg->sg[i].count = cpu_to_le32(usg->sg[i].count);
+                        }
+                        kfree (usg);
                 }
-                kfree (usg);
-
                 srbcmd->count = cpu_to_le32(byte_count);
                 psg->count = cpu_to_le32(sg_indx+1);
                 status = aac_fib_send(ScsiPortCommand64, srbfib, actual_fibsize, FsaNormal, 1, 1,NULL,NULL);
         } else {
                 struct user_sgmap* upsg = &user_srbcmd->sg;
                 struct sgmap* psg = &srbcmd->sg;
-                byte_count = 0;
-
-                actual_fibsize = sizeof (struct aac_srb) + (((user_srbcmd->sg.count & 0xff) - 1) * sizeof (struct sgentry));
-                if(actual_fibsize != fibsize){ // User made a mistake - should not continue
-                        dprintk((KERN_DEBUG"aacraid: Bad Size specified in "
-                          "Raw SRB command calculated fibsize=%d "
-                          "user_srbcmd->sg.count=%d aac_srb=%d sgentry=%d "
-                          "issued fibsize=%d\n",
-                          actual_fibsize, user_srbcmd->sg.count,
-                          sizeof(struct aac_srb), sizeof(struct sgentry),
-                          fibsize));
-                        rcode = -EINVAL;
-                        goto cleanup;
-                }
-                if ((data_dir == DMA_NONE) && upsg->count) {
-                        dprintk((KERN_DEBUG"aacraid: SG with no direction specified in Raw SRB command\n"));
-                        rcode = -EINVAL;
-                        goto cleanup;
-                }
-                for (i = 0; i < upsg->count; i++) {
-                        dma_addr_t addr; 
-                        void* p;
-                        p = kmalloc(upsg->sg[i].count, GFP_KERNEL);
-                        if(p == 0) {
-                                dprintk((KERN_DEBUG"aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
-                                  upsg->sg[i].count, i, upsg->count));
-                                rcode = -ENOMEM;
-                                goto cleanup;
-                        }
-                        sg_user[i] = (void __user *)(long)upsg->sg[i].addr;
-                        sg_list[i] = p; // save so we can clean up later
-                        sg_indx = i;
-
-                        if( flags & SRB_DataOut ){
-                                if(copy_from_user(p, sg_user[i],
-                                                upsg->sg[i].count)) {
-                                        dprintk((KERN_DEBUG"aacraid: Could not copy sg data from user\n")); 
-                                        rcode = -EFAULT;
+
+                if (actual_fibsize64 == fibsize) {
+                        struct user_sgmap64* usg = (struct user_sgmap64 *)upsg;
+                        for (i = 0; i < upsg->count; i++) {
+                                u64 addr;
+                                void* p;
+                                /* Does this really need to be GFP_DMA? */
+                                p = kmalloc(usg->sg[i].count,GFP_KERNEL|__GFP_DMA);
+                                if(p == 0) {
+                                        dprintk((KERN_DEBUG"aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
+                                          usg->sg[i].count,i,usg->count));
+                                        rcode = -ENOMEM;
                                         goto cleanup;
                                 }
+                                addr = (u64)usg->sg[i].addr[0];
+                                addr += ((u64)usg->sg[i].addr[1]) << 32;
+                                sg_user[i] = (void __user *)(ptrdiff_t)addr;
+                                sg_list[i] = p; // save so we can clean up later
+                                sg_indx = i;
+
+                                if( flags & SRB_DataOut ){
+                                        if(copy_from_user(p,sg_user[i],usg->sg[i].count)){
+                                                dprintk((KERN_DEBUG"aacraid: Could not copy sg data from user\n"));
+                                                rcode = -EFAULT;
+                                                goto cleanup;
+                                        }
+                                }
+                                addr = pci_map_single(dev->pdev, p, usg->sg[i].count, data_dir);
+
+                                psg->sg[i].addr = cpu_to_le32(addr & 0xffffffff);
+                                byte_count += usg->sg[i].count;
+                                psg->sg[i].count = cpu_to_le32(usg->sg[i].count);
                         }
-                        addr = pci_map_single(dev->pdev, p,
-                                upsg->sg[i].count, data_dir);
+                } else {
+                        for (i = 0; i < upsg->count; i++) {
+                                dma_addr_t addr;
+                                void* p;
+                                p = kmalloc(upsg->sg[i].count, GFP_KERNEL);
+                                if(p == 0) {
+                                        dprintk((KERN_DEBUG"aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
+                                          upsg->sg[i].count, i, upsg->count));
+                                        rcode = -ENOMEM;
+                                        goto cleanup;
+                                }
+                                sg_user[i] = (void __user *)(ptrdiff_t)upsg->sg[i].addr;
+                                sg_list[i] = p; // save so we can clean up later
+                                sg_indx = i;
+
+                                if( flags & SRB_DataOut ){
+                                        if(copy_from_user(p, sg_user[i],
+                                                        upsg->sg[i].count)) {
+                                                dprintk((KERN_DEBUG"aacraid: Could not copy sg data from user\n"));
+                                                rcode = -EFAULT;
+                                                goto cleanup;
+                                        }
+                                }
+                                addr = pci_map_single(dev->pdev, p,
+                                        upsg->sg[i].count, data_dir);
 
-                        psg->sg[i].addr = cpu_to_le32(addr);
-                        psg->sg[i].count = cpu_to_le32(upsg->sg[i].count);  
-                        byte_count += upsg->sg[i].count;
+                                psg->sg[i].addr = cpu_to_le32(addr);
+                                byte_count += upsg->sg[i].count;
+                                psg->sg[i].count = cpu_to_le32(upsg->sg[i].count);
+                        }
                 }
                 srbcmd->count = cpu_to_le32(byte_count);
                 psg->count = cpu_to_le32(sg_indx+1);
@@ -682,7 +741,8 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
 
         if( flags & SRB_DataIn ) {
                 for(i = 0 ; i <= sg_indx; i++){
-                        byte_count = le32_to_cpu((dev->dac_support == 1)
+                        byte_count = le32_to_cpu(
+                          (dev->adapter_info.options & AAC_OPT_SGMAP_HOST64)
                               ? ((struct sgmap64*)&srbcmd->sg)->sg[i].count
                               : srbcmd->sg.sg[i].count);
                         if(copy_to_user(sg_user[i], sg_list[i], byte_count)){
diff --git a/drivers/scsi/aacraid/comminit.c b/drivers/scsi/aacraid/comminit.c
index ae34768987a4..33682ce96a5d 100644
--- a/drivers/scsi/aacraid/comminit.c
+++ b/drivers/scsi/aacraid/comminit.c
@@ -5,7 +5,7 @@
  * based on the old aacraid driver that is..
  * Adaptec aacraid device driver for Linux.
  *
- * Copyright (c) 2000 Adaptec, Inc. (aacraid@adaptec.com)
+ * Copyright (c) 2000-2007 Adaptec, Inc. (aacraid@adaptec.com)
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -110,7 +110,7 @@ static int aac_alloc_comm(struct aac_dev *dev, void **commaddr, unsigned long co
         /*
          *      Align the beginning of Headers to commalign
          */
-        align = (commalign - ((unsigned long)(base) & (commalign - 1)));
+        align = (commalign - ((ptrdiff_t)(base) & (commalign - 1)));
         base = base + align;
         phys = phys + align;
         /*
diff --git a/drivers/scsi/aacraid/commsup.c b/drivers/scsi/aacraid/commsup.c
index 1b97f60652ba..5824a757a753 100644
--- a/drivers/scsi/aacraid/commsup.c
+++ b/drivers/scsi/aacraid/commsup.c
@@ -5,7 +5,7 @@
  * based on the old aacraid driver that is..
  * Adaptec aacraid device driver for Linux.
  *
- * Copyright (c) 2000 Adaptec, Inc. (aacraid@adaptec.com)
+ * Copyright (c) 2000-2007 Adaptec, Inc. (aacraid@adaptec.com)
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -94,7 +94,7 @@ void aac_fib_map_free(struct aac_dev *dev)
 int aac_fib_setup(struct aac_dev * dev)
 {
         struct fib *fibptr;
-        struct hw_fib *hw_fib_va;
+        struct hw_fib *hw_fib;
         dma_addr_t hw_fib_pa;
         int i;
 
@@ -106,24 +106,24 @@ int aac_fib_setup(struct aac_dev * dev)
         if (i<0)
                 return -ENOMEM;
                 
-        hw_fib_va = dev->hw_fib_va;
+        hw_fib = dev->hw_fib_va;
         hw_fib_pa = dev->hw_fib_pa;
-        memset(hw_fib_va, 0, dev->max_fib_size * (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB));
+        memset(hw_fib, 0, dev->max_fib_size * (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB));
         /*
          *      Initialise the fibs
          */
         for (i = 0, fibptr = &dev->fibs[i]; i < (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB); i++, fibptr++) 
         {
                 fibptr->dev = dev;
-                fibptr->hw_fib = hw_fib_va;
-                fibptr->data = (void *) fibptr->hw_fib->data;
+                fibptr->hw_fib_va = hw_fib;
+                fibptr->data = (void *) fibptr->hw_fib_va->data;
                 fibptr->next = fibptr+1;        /* Forward chain the fibs */
                 init_MUTEX_LOCKED(&fibptr->event_wait);
                 spin_lock_init(&fibptr->event_lock);
-                hw_fib_va->header.XferState = cpu_to_le32(0xffffffff);
-                hw_fib_va->header.SenderSize = cpu_to_le16(dev->max_fib_size);
+                hw_fib->header.XferState = cpu_to_le32(0xffffffff);
+                hw_fib->header.SenderSize = cpu_to_le16(dev->max_fib_size);
                 fibptr->hw_fib_pa = hw_fib_pa;
-                hw_fib_va = (struct hw_fib *)((unsigned char *)hw_fib_va + dev->max_fib_size);
+                hw_fib = (struct hw_fib *)((unsigned char *)hw_fib + dev->max_fib_size);
                 hw_fib_pa = hw_fib_pa + dev->max_fib_size;
         }
         /*
@@ -166,7 +166,7 @@ struct fib *aac_fib_alloc(struct aac_dev *dev)
          *      Null out fields that depend on being zero at the start of
          *      each I/O
          */
-        fibptr->hw_fib->header.XferState = 0;
+        fibptr->hw_fib_va->header.XferState = 0;
         fibptr->callback = NULL;
         fibptr->callback_data = NULL;
 
@@ -178,7 +178,6 @@ struct fib *aac_fib_alloc(struct aac_dev *dev)
  *      @fibptr: fib to free up
  *
  *      Frees up a fib and places it on the appropriate queue
- *      (either free or timed out)
  */
  
 void aac_fib_free(struct fib *fibptr)
@@ -186,19 +185,15 @@ void aac_fib_free(struct fib *fibptr)
         unsigned long flags;
 
         spin_lock_irqsave(&fibptr->dev->fib_lock, flags);
-        if (fibptr->flags & FIB_CONTEXT_FLAG_TIMED_OUT) {
+        if (unlikely(fibptr->flags & FIB_CONTEXT_FLAG_TIMED_OUT))
                 aac_config.fib_timeouts++;
-                fibptr->next = fibptr->dev->timeout_fib;
-                fibptr->dev->timeout_fib = fibptr;
-        } else {
-                if (fibptr->hw_fib->header.XferState != 0) {
-                        printk(KERN_WARNING "aac_fib_free, XferState != 0, fibptr = 0x%p, XferState = 0x%x\n",
-                                 (void*)fibptr, 
-                                 le32_to_cpu(fibptr->hw_fib->header.XferState));
-                }
-                fibptr->next = fibptr->dev->free_fib;
-                fibptr->dev->free_fib = fibptr;
-        }       
+        if (fibptr->hw_fib_va->header.XferState != 0) {
+                printk(KERN_WARNING "aac_fib_free, XferState != 0, fibptr = 0x%p, XferState = 0x%x\n",
+                         (void*)fibptr,
+                         le32_to_cpu(fibptr->hw_fib_va->header.XferState));
+        }
+        fibptr->next = fibptr->dev->free_fib;
+        fibptr->dev->free_fib = fibptr;
         spin_unlock_irqrestore(&fibptr->dev->fib_lock, flags);
 }
 
@@ -211,7 +206,7 @@ void aac_fib_free(struct fib *fibptr)
  
 void aac_fib_init(struct fib *fibptr)
 {
-        struct hw_fib *hw_fib = fibptr->hw_fib;
+        struct hw_fib *hw_fib = fibptr->hw_fib_va;
 
         hw_fib->header.StructType = FIB_MAGIC;
         hw_fib->header.Size = cpu_to_le16(fibptr->dev->max_fib_size);
@@ -231,7 +226,7 @@ void aac_fib_init(struct fib *fibptr)
  
 static void fib_dealloc(struct fib * fibptr)
 {
-        struct hw_fib *hw_fib = fibptr->hw_fib;
+        struct hw_fib *hw_fib = fibptr->hw_fib_va;
         BUG_ON(hw_fib->header.StructType != FIB_MAGIC);
         hw_fib->header.XferState = 0;        
 }
@@ -386,7 +381,7 @@ int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size,
                 void *callback_data)
 {
         struct aac_dev * dev = fibptr->dev;
-        struct hw_fib * hw_fib = fibptr->hw_fib;
+        struct hw_fib * hw_fib = fibptr->hw_fib_va;
         unsigned long flags = 0;
         unsigned long qflags;
 
@@ -430,7 +425,7 @@ int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size,
          */
         hw_fib->header.Command = cpu_to_le16(command);
         hw_fib->header.XferState |= cpu_to_le32(SentFromHost);
-        fibptr->hw_fib->header.Flags = 0;       /* 0 the flags field - internal only*/
+        fibptr->hw_fib_va->header.Flags = 0;    /* 0 the flags field - internal only*/
         /*
          *      Set the size of the Fib we want to send to the adapter
          */
@@ -462,7 +457,7 @@ int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size,
         dprintk((KERN_DEBUG "  Command =               %d.\n", le32_to_cpu(hw_fib->header.Command)));
         dprintk((KERN_DEBUG "  SubCommand =            %d.\n", le32_to_cpu(((struct aac_query_mount *)fib_data(fibptr))->command)));
         dprintk((KERN_DEBUG "  XferState  =            %x.\n", le32_to_cpu(hw_fib->header.XferState)));
-        dprintk((KERN_DEBUG "  hw_fib va being sent=%p\n",fibptr->hw_fib));
+        dprintk((KERN_DEBUG "  hw_fib va being sent=%p\n",fibptr->hw_fib_va));
         dprintk((KERN_DEBUG "  hw_fib pa being sent=%lx\n",(ulong)fibptr->hw_fib_pa));
         dprintk((KERN_DEBUG "  fib being sent=%p\n",fibptr));
 
@@ -513,22 +508,20 @@ int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size,
                                 }
                                 udelay(5);
                         }
-                } else if (down_interruptible(&fibptr->event_wait)) {
-                        spin_lock_irqsave(&fibptr->event_lock, flags);
-                        if (fibptr->done == 0) {
-                                fibptr->done = 2; /* Tell interrupt we aborted */
-                                spin_unlock_irqrestore(&fibptr->event_lock, flags);
-                                return -EINTR;
-                        }
+                } else
+                        (void)down_interruptible(&fibptr->event_wait);
+                spin_lock_irqsave(&fibptr->event_lock, flags);
+                if (fibptr->done == 0) {
+                        fibptr->done = 2; /* Tell interrupt we aborted */
                         spin_unlock_irqrestore(&fibptr->event_lock, flags);
+                        return -EINTR;
                 }
+                spin_unlock_irqrestore(&fibptr->event_lock, flags);
                 BUG_ON(fibptr->done == 0);
                         
-                if((fibptr->flags & FIB_CONTEXT_FLAG_TIMED_OUT)){
+                if(unlikely(fibptr->flags & FIB_CONTEXT_FLAG_TIMED_OUT))
                         return -ETIMEDOUT;
-                } else {
-                        return 0;
-                }
+                return 0;
         }
         /*
          *      If the user does not want a response than return success otherwise
@@ -624,7 +617,7 @@ void aac_consumer_free(struct aac_dev * dev, struct aac_queue *q, u32 qid)
 
 int aac_fib_adapter_complete(struct fib *fibptr, unsigned short size)
 {
-        struct hw_fib * hw_fib = fibptr->hw_fib;
+        struct hw_fib * hw_fib = fibptr->hw_fib_va;
         struct aac_dev * dev = fibptr->dev;
         struct aac_queue * q;
         unsigned long nointr = 0;
@@ -688,7 +681,7 @@ int aac_fib_adapter_complete(struct fib *fibptr, unsigned short size)
  
 int aac_fib_complete(struct fib *fibptr)
 {
-        struct hw_fib * hw_fib = fibptr->hw_fib;
+        struct hw_fib * hw_fib = fibptr->hw_fib_va;
 
         /*
          *      Check for a fib which has already been completed
@@ -774,9 +767,8 @@ void aac_printf(struct aac_dev *dev, u32 val)
 #define AIF_SNIFF_TIMEOUT       (30*HZ)
 static void aac_handle_aif(struct aac_dev * dev, struct fib * fibptr)
 {
-        struct hw_fib * hw_fib = fibptr->hw_fib;
+        struct hw_fib * hw_fib = fibptr->hw_fib_va;
         struct aac_aifcmd * aifcmd = (struct aac_aifcmd *)hw_fib->data;
-        int busy;
         u32 container;
         struct scsi_device *device;
         enum {
@@ -988,9 +980,6 @@ static void aac_handle_aif(struct aac_dev * dev, struct fib * fibptr)
          * behind you.
          */
 
-        busy = 0;
-
-
         /*
          *      Find the scsi_device associated with the SCSI address,
          * and mark it as changed, invalidating the cache. This deals
@@ -1035,7 +1024,6 @@ static void aac_handle_aif(struct aac_dev * dev, struct fib * fibptr)
 static int _aac_reset_adapter(struct aac_dev *aac)
 {
         int index, quirks;
-        u32 ret;
         int retval;
         struct Scsi_Host *host;
         struct scsi_device *dev;
@@ -1059,35 +1047,29 @@ static int _aac_reset_adapter(struct aac_dev *aac)
          *      If a positive health, means in a known DEAD PANIC
          * state and the adapter could be reset to `try again'.
          */
-        retval = aac_adapter_check_health(aac);
-        if (retval == 0)
-                retval = aac_adapter_sync_cmd(aac, IOP_RESET_ALWAYS,
-                  0, 0, 0, 0, 0, 0, &ret, NULL, NULL, NULL, NULL);
-        if (retval)
-                retval = aac_adapter_sync_cmd(aac, IOP_RESET,
-                  0, 0, 0, 0, 0, 0, &ret, NULL, NULL, NULL, NULL);
+        retval = aac_adapter_restart(aac, aac_adapter_check_health(aac));
 
         if (retval)
                 goto out;
-        if (ret != 0x00000001) {
-                retval = -ENODEV;
-                goto out;
-        }
 
         /*
          *      Loop through the fibs, close the synchronous FIBS
          */
-        for (index = 0; index < (aac->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB); index++) {
+        for (retval = 1, index = 0; index < (aac->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB); index++) {
                 struct fib *fib = &aac->fibs[index];
-                if (!(fib->hw_fib->header.XferState & cpu_to_le32(NoResponseExpected | Async)) &&
-                  (fib->hw_fib->header.XferState & cpu_to_le32(ResponseExpected))) {
+                if (!(fib->hw_fib_va->header.XferState & cpu_to_le32(NoResponseExpected | Async)) &&
+                  (fib->hw_fib_va->header.XferState & cpu_to_le32(ResponseExpected))) {
                         unsigned long flagv;
                         spin_lock_irqsave(&fib->event_lock, flagv);
                         up(&fib->event_wait);
                         spin_unlock_irqrestore(&fib->event_lock, flagv);
                         schedule();
+                        retval = 0;
                 }
         }
+        /* Give some extra time for ioctls to complete. */
+        if (retval == 0)
+                ssleep(2);
         index = aac->cardtype;
 
         /*
@@ -1248,7 +1230,7 @@ int aac_check_health(struct aac_dev * aac)
 
                         memset(hw_fib, 0, sizeof(struct hw_fib));
                         memset(fib, 0, sizeof(struct fib));
-                        fib->hw_fib = hw_fib;
+                        fib->hw_fib_va = hw_fib;
                         fib->dev = aac;
                         aac_fib_init(fib);
                         fib->type = FSAFS_NTC_FIB_CONTEXT;
@@ -1354,11 +1336,11 @@ int aac_command_thread(void *data)
                          *      do anything at this point since we don't have
                          *      anything defined for this thread to do.
                          */
-                        hw_fib = fib->hw_fib;
+                        hw_fib = fib->hw_fib_va;
                         memset(fib, 0, sizeof(struct fib));
                         fib->type = FSAFS_NTC_FIB_CONTEXT;
                         fib->size = sizeof( struct fib );
-                        fib->hw_fib = hw_fib;
+                        fib->hw_fib_va = hw_fib;
                         fib->data = hw_fib->data;
                         fib->dev = dev;
                         /*
@@ -1485,7 +1467,7 @@ int aac_command_thread(void *data)
                                                  */
                                                 memcpy(hw_newfib, hw_fib, sizeof(struct hw_fib));
                                                 memcpy(newfib, fib, sizeof(struct fib));
-                                                newfib->hw_fib = hw_newfib;
+                                                newfib->hw_fib_va = hw_newfib;
                                                 /*
                                                  * Put the FIB onto the
                                                  * fibctx's fibs
diff --git a/drivers/scsi/aacraid/dpcsup.c b/drivers/scsi/aacraid/dpcsup.c
index 66aeb57dcc2d..42c7dcda6d9b 100644
--- a/drivers/scsi/aacraid/dpcsup.c
+++ b/drivers/scsi/aacraid/dpcsup.c
@@ -5,7 +5,7 @@
  * based on the old aacraid driver that is..
  * Adaptec aacraid device driver for Linux.
  *
- * Copyright (c) 2000 Adaptec, Inc. (aacraid@adaptec.com)
+ * Copyright (c) 2000-2007 Adaptec, Inc. (aacraid@adaptec.com)
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -72,7 +72,7 @@ unsigned int aac_response_normal(struct aac_queue * q)
                 u32 index = le32_to_cpu(entry->addr);
                 fast = index & 0x01;
                 fib = &dev->fibs[index >> 2];
-                hwfib = fib->hw_fib;
+                hwfib = fib->hw_fib_va;
                 
                 aac_consumer_free(dev, q, HostNormRespQueue);
                 /*
@@ -83,11 +83,13 @@ unsigned int aac_response_normal(struct aac_queue * q)
                  *      continue. The caller has already been notified that
                  *      the fib timed out.
                  */
-                if (!(fib->flags & FIB_CONTEXT_FLAG_TIMED_OUT))
-                        dev->queues->queue[AdapNormCmdQueue].numpending--;
-                else {
-                        printk(KERN_WARNING "aacraid: FIB timeout (%x).\n", fib->flags);
-                        printk(KERN_DEBUG"aacraid: hwfib=%p fib index=%i fib=%p\n",hwfib, hwfib->header.SenderData,fib);
+                dev->queues->queue[AdapNormCmdQueue].numpending--;
+
+                if (unlikely(fib->flags & FIB_CONTEXT_FLAG_TIMED_OUT)) {
+                        spin_unlock_irqrestore(q->lock, flags);
+                        aac_fib_complete(fib);
+                        aac_fib_free(fib);
+                        spin_lock_irqsave(q->lock, flags);
                         continue;
                 }
                 spin_unlock_irqrestore(q->lock, flags);
@@ -192,7 +194,7 @@ unsigned int aac_command_normal(struct aac_queue *q)
                 INIT_LIST_HEAD(&fib->fiblink);
                 fib->type = FSAFS_NTC_FIB_CONTEXT;
                 fib->size = sizeof(struct fib);
-                fib->hw_fib = hw_fib;
+                fib->hw_fib_va = hw_fib;
                 fib->data = hw_fib->data;
                 fib->dev = dev;
                 
@@ -253,12 +255,13 @@ unsigned int aac_intr_normal(struct aac_dev * dev, u32 Index)
                         return 1;
                 }
                 memset(hw_fib, 0, sizeof(struct hw_fib));
-                memcpy(hw_fib, (struct hw_fib *)(((unsigned long)(dev->regs.sa)) + (index & ~0x00000002L)), sizeof(struct hw_fib));
+                memcpy(hw_fib, (struct hw_fib *)(((ptrdiff_t)(dev->regs.sa)) +
+                  (index & ~0x00000002L)), sizeof(struct hw_fib));
                 memset(fib, 0, sizeof(struct fib));
                 INIT_LIST_HEAD(&fib->fiblink);
                 fib->type = FSAFS_NTC_FIB_CONTEXT;
                 fib->size = sizeof(struct fib);
-                fib->hw_fib = hw_fib;
+                fib->hw_fib_va = hw_fib;
                 fib->data = hw_fib->data;
                 fib->dev = dev;
         
@@ -270,7 +273,7 @@ unsigned int aac_intr_normal(struct aac_dev * dev, u32 Index)
         } else {
                 int fast = index & 0x01;
                 struct fib * fib = &dev->fibs[index >> 2];
-                struct hw_fib * hwfib = fib->hw_fib;
+                struct hw_fib * hwfib = fib->hw_fib_va;
 
                 /*
                  *      Remove this fib from the Outstanding I/O queue.
@@ -280,14 +283,14 @@ unsigned int aac_intr_normal(struct aac_dev * dev, u32 Index)
                  *      continue. The caller has already been notified that
                  *      the fib timed out.
                  */
-                if ((fib->flags & FIB_CONTEXT_FLAG_TIMED_OUT)) {
-                        printk(KERN_WARNING "aacraid: FIB timeout (%x).\n", fib->flags);
-                        printk(KERN_DEBUG"aacraid: hwfib=%p index=%i fib=%p\n",hwfib, hwfib->header.SenderData,fib);
+                dev->queues->queue[AdapNormCmdQueue].numpending--;
+
+                if (unlikely(fib->flags & FIB_CONTEXT_FLAG_TIMED_OUT)) {
+                        aac_fib_complete(fib);
+                        aac_fib_free(fib);
                         return 0;
                 }
 
-                dev->queues->queue[AdapNormCmdQueue].numpending--;
-
                 if (fast) {
                         /*
                          *      Doctor the fib
diff --git a/drivers/scsi/aacraid/linit.c b/drivers/scsi/aacraid/linit.c
index 0f948c2fb609..350ea7feb61d 100644
--- a/drivers/scsi/aacraid/linit.c
+++ b/drivers/scsi/aacraid/linit.c
@@ -5,7 +5,7 @@
  * based on the old aacraid driver that is..
  * Adaptec aacraid device driver for Linux.
  *
- * Copyright (c) 2000 Adaptec, Inc. (aacraid@adaptec.com)
+ * Copyright (c) 2000-2007 Adaptec, Inc. (aacraid@adaptec.com)
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -82,8 +82,6 @@ static LIST_HEAD(aac_devices);
 static int aac_cfg_major = -1;
 char aac_driver_version[] = AAC_DRIVER_FULL_VERSION;
 
-extern int expose_physicals;
-
 /*
  * Because of the way Linux names scsi devices, the order in this table has
  * become important.  Check for on-board Raid first, add-in cards second.
@@ -247,7 +245,19 @@ static struct aac_driver_ident aac_drivers[] = {
 
 static int aac_queuecommand(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
 {
+        struct Scsi_Host *host = cmd->device->host;
+        struct aac_dev *dev = (struct aac_dev *)host->hostdata;
+        u32 count = 0;
         cmd->scsi_done = done;
+        for (; count < (host->can_queue + AAC_NUM_MGT_FIB); ++count) {
+                struct fib * fib = &dev->fibs[count];
+                struct scsi_cmnd * command;
+                if (fib->hw_fib_va->header.XferState &&
+                    ((command = fib->callback_data)) &&
+                    (command == cmd) &&
+                    (cmd->SCp.phase == AAC_OWNER_FIRMWARE))
+                        return 0; /* Already owned by Adapter */
+        }
         cmd->SCp.phase = AAC_OWNER_LOWLEVEL;
         return (aac_scsi_cmd(cmd) ? FAILED : 0);
 } 
@@ -446,6 +456,40 @@ static int aac_ioctl(struct scsi_device *sdev, int cmd, void __user * arg)
         return aac_do_ioctl(dev, cmd, arg);
 }
 
+static int aac_eh_abort(struct scsi_cmnd* cmd)
+{
+        struct scsi_device * dev = cmd->device;
+        struct Scsi_Host * host = dev->host;
+        struct aac_dev * aac = (struct aac_dev *)host->hostdata;
+        int count;
+        int ret = FAILED;
+
+        printk(KERN_ERR "%s: Host adapter abort request (%d,%d,%d,%d)\n",
+                AAC_DRIVERNAME,
+                host->host_no, sdev_channel(dev), sdev_id(dev), dev->lun);
+        switch (cmd->cmnd[0]) {
+        case SERVICE_ACTION_IN:
+                if (!(aac->raw_io_interface) ||
+                    !(aac->raw_io_64) ||
+                    ((cmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16))
+                        break;
+        case INQUIRY:
+        case READ_CAPACITY:
+        case TEST_UNIT_READY:
+                /* Mark associated FIB to not complete, eh handler does this */
+                for (count = 0; count < (host->can_queue + AAC_NUM_MGT_FIB); ++count) {
+                        struct fib * fib = &aac->fibs[count];
+                        if (fib->hw_fib_va->header.XferState &&
+                          (fib->callback_data == cmd)) {
+                                fib->flags |= FIB_CONTEXT_FLAG_TIMED_OUT;
+                                cmd->SCp.phase = AAC_OWNER_ERROR_HANDLER;
+                                ret = SUCCESS;
+                        }
+                }
+        }
+        return ret;
+}
+
 /*
  *      aac_eh_reset    - Reset command handling
  *      @scsi_cmd:      SCSI command block causing the reset
@@ -457,12 +501,20 @@ static int aac_eh_reset(struct scsi_cmnd* cmd)
         struct Scsi_Host * host = dev->host;
         struct scsi_cmnd * command;
         int count;
-        struct aac_dev * aac;
+        struct aac_dev * aac = (struct aac_dev *)host->hostdata;
         unsigned long flags;
 
+        /* Mark the associated FIB to not complete, eh handler does this */
+        for (count = 0; count < (host->can_queue + AAC_NUM_MGT_FIB); ++count) {
+                struct fib * fib = &aac->fibs[count];
+                if (fib->hw_fib_va->header.XferState &&
+                  (fib->callback_data == cmd)) {
+                        fib->flags |= FIB_CONTEXT_FLAG_TIMED_OUT;
+                        cmd->SCp.phase = AAC_OWNER_ERROR_HANDLER;
+                }
+        }
         printk(KERN_ERR "%s: Host adapter reset request. SCSI hang ?\n", 
                                         AAC_DRIVERNAME);
-        aac = (struct aac_dev *)host->hostdata;
 
         if ((count = aac_check_health(aac)))
                 return count;
@@ -496,7 +548,7 @@ static int aac_eh_reset(struct scsi_cmnd* cmd)
                 ssleep(1);
         }
         printk(KERN_ERR "%s: SCSI bus appears hung\n", AAC_DRIVERNAME);
-        return -ETIMEDOUT;
+        return SUCCESS; /* Cause an immediate retry of the command with a ten second delay after successful tur */
 }
 
 /**
@@ -796,6 +848,7 @@ static struct scsi_host_template aac_driver_template = {
         .bios_param                     = aac_biosparm, 
         .shost_attrs                    = aac_attrs,
         .slave_configure                = aac_slave_configure,
+        .eh_abort_handler               = aac_eh_abort,
         .eh_host_reset_handler          = aac_eh_reset,
         .can_queue                      = AAC_NUM_IO_FIB,       
         .this_id                        = MAXIMUM_NUM_CONTAINERS,
diff --git a/drivers/scsi/aacraid/nark.c b/drivers/scsi/aacraid/nark.c
index c76b611b6afb..a8ace5677813 100644
--- a/drivers/scsi/aacraid/nark.c
+++ b/drivers/scsi/aacraid/nark.c
@@ -74,9 +74,6 @@ static int aac_nark_ioremap(struct aac_dev * dev, u32 size)
 
 int aac_nark_init(struct aac_dev * dev)
 {
-        extern int _aac_rx_init(struct aac_dev *dev);
-        extern int aac_rx_select_comm(struct aac_dev *dev, int comm);
-
         /*
          *      Fill in the function dispatch table.
          */
diff --git a/drivers/scsi/aacraid/rkt.c b/drivers/scsi/aacraid/rkt.c
index d953c3fe998a..9c5fcfb398c2 100644
--- a/drivers/scsi/aacraid/rkt.c
+++ b/drivers/scsi/aacraid/rkt.c
@@ -45,7 +45,6 @@
 static int aac_rkt_select_comm(struct aac_dev *dev, int comm)
 {
         int retval;
-        extern int aac_rx_select_comm(struct aac_dev *dev, int comm);
         retval = aac_rx_select_comm(dev, comm);
         if (comm == AAC_COMM_MESSAGE) {
                 /*
@@ -97,8 +96,6 @@ static int aac_rkt_ioremap(struct aac_dev * dev, u32 size)
 
 int aac_rkt_init(struct aac_dev *dev)
 {
-        extern int _aac_rx_init(struct aac_dev *dev);
-
         /*
          *      Fill in the function dispatch table.
          */
diff --git a/drivers/scsi/aacraid/rx.c b/drivers/scsi/aacraid/rx.c
index d242e2611d67..0c71315cbf1a 100644
--- a/drivers/scsi/aacraid/rx.c
+++ b/drivers/scsi/aacraid/rx.c
@@ -5,7 +5,7 @@
  * based on the old aacraid driver that is..
  * Adaptec aacraid device driver for Linux.
  *
- * Copyright (c) 2000 Adaptec, Inc. (aacraid@adaptec.com)
+ * Copyright (c) 2000-2007 Adaptec, Inc. (aacraid@adaptec.com)
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -57,25 +57,25 @@ static irqreturn_t aac_rx_intr_producer(int irq, void *dev_id)
          *      been enabled.
          *      Check to see if this is our interrupt.  If it isn't just return
          */
-        if (intstat & ~(dev->OIMR)) {
+        if (likely(intstat & ~(dev->OIMR))) {
                 bellbits = rx_readl(dev, OutboundDoorbellReg);
-                if (bellbits & DoorBellPrintfReady) {
+                if (unlikely(bellbits & DoorBellPrintfReady)) {
                         aac_printf(dev, readl (&dev->IndexRegs->Mailbox[5]));
                         rx_writel(dev, MUnit.ODR,DoorBellPrintfReady);
                         rx_writel(dev, InboundDoorbellReg,DoorBellPrintfDone);
                 }
-                else if (bellbits & DoorBellAdapterNormCmdReady) {
+                else if (unlikely(bellbits & DoorBellAdapterNormCmdReady)) {
                         rx_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdReady);
                         aac_command_normal(&dev->queues->queue[HostNormCmdQueue]);
                 }
-                else if (bellbits & DoorBellAdapterNormRespReady) {
+                else if (likely(bellbits & DoorBellAdapterNormRespReady)) {
                         rx_writel(dev, MUnit.ODR,DoorBellAdapterNormRespReady);
                         aac_response_normal(&dev->queues->queue[HostNormRespQueue]);
                 }
-                else if (bellbits & DoorBellAdapterNormCmdNotFull) {
+                else if (unlikely(bellbits & DoorBellAdapterNormCmdNotFull)) {
                         rx_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdNotFull);
                 }
-                else if (bellbits & DoorBellAdapterNormRespNotFull) {
+                else if (unlikely(bellbits & DoorBellAdapterNormRespNotFull)) {
                         rx_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdNotFull);
                         rx_writel(dev, MUnit.ODR, DoorBellAdapterNormRespNotFull);
                 }
@@ -88,11 +88,11 @@ static irqreturn_t aac_rx_intr_message(int irq, void *dev_id)
 {
         struct aac_dev *dev = dev_id;
         u32 Index = rx_readl(dev, MUnit.OutboundQueue);
-        if (Index == 0xFFFFFFFFL)
+        if (unlikely(Index == 0xFFFFFFFFL))
                 Index = rx_readl(dev, MUnit.OutboundQueue);
-        if (Index != 0xFFFFFFFFL) {
+        if (likely(Index != 0xFFFFFFFFL)) {
                 do {
-                        if (aac_intr_normal(dev, Index)) {
+                        if (unlikely(aac_intr_normal(dev, Index))) {
                                 rx_writel(dev, MUnit.OutboundQueue, Index);
                                 rx_writel(dev, MUnit.ODR, DoorBellAdapterNormRespReady);
                         }
@@ -204,7 +204,7 @@ static int rx_sync_cmd(struct aac_dev *dev, u32 command,
                  */
                 msleep(1);
         }
-        if (ok != 1) {
+        if (unlikely(ok != 1)) {
                 /*
                  *      Restore interrupt mask even though we timed out
                  */
@@ -294,7 +294,7 @@ static void aac_rx_notify_adapter(struct aac_dev *dev, u32 event)
  *      Start up processing on an i960 based AAC adapter
  */
 
-void aac_rx_start_adapter(struct aac_dev *dev)
+static void aac_rx_start_adapter(struct aac_dev *dev)
 {
         struct aac_init *init;
 
@@ -319,12 +319,12 @@ static int aac_rx_check_health(struct aac_dev *dev)
         /*
          *      Check to see if the board failed any self tests.
          */
-        if (status & SELF_TEST_FAILED)
+        if (unlikely(status & SELF_TEST_FAILED))
                 return -1;
         /*
          *      Check to see if the board panic'd.
          */
-        if (status & KERNEL_PANIC) {
+        if (unlikely(status & KERNEL_PANIC)) {
                 char * buffer;
                 struct POSTSTATUS {
                         __le32 Post_Command;
@@ -333,15 +333,15 @@ static int aac_rx_check_health(struct aac_dev *dev)
                 dma_addr_t paddr, baddr;
                 int ret;
 
-                if ((status & 0xFF000000L) == 0xBC000000L)
+                if (likely((status & 0xFF000000L) == 0xBC000000L))
                         return (status >> 16) & 0xFF;
                 buffer = pci_alloc_consistent(dev->pdev, 512, &baddr);
                 ret = -2;
-                if (buffer == NULL)
+                if (unlikely(buffer == NULL))
                         return ret;
                 post = pci_alloc_consistent(dev->pdev,
                   sizeof(struct POSTSTATUS), &paddr);
-                if (post == NULL) {
+                if (unlikely(post == NULL)) {
                         pci_free_consistent(dev->pdev, 512, buffer, baddr);
                         return ret;
                 }
@@ -353,7 +353,7 @@ static int aac_rx_check_health(struct aac_dev *dev)
                   NULL, NULL, NULL, NULL, NULL);
                 pci_free_consistent(dev->pdev, sizeof(struct POSTSTATUS),
                   post, paddr);
-                if ((buffer[0] == '0') && ((buffer[1] == 'x') || (buffer[1] == 'X'))) {
+                if (likely((buffer[0] == '0') && ((buffer[1] == 'x') || (buffer[1] == 'X')))) {
                         ret = (buffer[2] <= '9') ? (buffer[2] - '0') : (buffer[2] - 'A' + 10);
                         ret <<= 4;
                         ret += (buffer[3] <= '9') ? (buffer[3] - '0') : (buffer[3] - 'A' + 10);
@@ -364,7 +364,7 @@ static int aac_rx_check_health(struct aac_dev *dev)
         /*
          *      Wait for the adapter to be up and running.
          */
-        if (!(status & KERNEL_UP_AND_RUNNING))
+        if (unlikely(!(status & KERNEL_UP_AND_RUNNING)))
                 return -3;
         /*
          *      Everything is OK
@@ -387,7 +387,7 @@ static int aac_rx_deliver_producer(struct fib * fib)
         unsigned long nointr = 0;
 
         spin_lock_irqsave(q->lock, qflags);
-        aac_queue_get( dev, &Index, AdapNormCmdQueue, fib->hw_fib, 1, fib, &nointr);
+        aac_queue_get( dev, &Index, AdapNormCmdQueue, fib->hw_fib_va, 1, fib, &nointr);
 
         q->numpending++;
         *(q->headers.producer) = cpu_to_le32(Index + 1);
@@ -419,9 +419,9 @@ static int aac_rx_deliver_message(struct fib * fib)
         spin_unlock_irqrestore(q->lock, qflags);
         for(;;) {
                 Index = rx_readl(dev, MUnit.InboundQueue);
-                if (Index == 0xFFFFFFFFL)
+                if (unlikely(Index == 0xFFFFFFFFL))
                         Index = rx_readl(dev, MUnit.InboundQueue);
-                if (Index != 0xFFFFFFFFL)
+                if (likely(Index != 0xFFFFFFFFL))
                         break;
                 if (--count == 0) {
                         spin_lock_irqsave(q->lock, qflags);
@@ -437,7 +437,7 @@ static int aac_rx_deliver_message(struct fib * fib)
         device += sizeof(u32);
         writel((u32)(addr >> 32), device);
         device += sizeof(u32);
-        writel(le16_to_cpu(fib->hw_fib->header.Size), device);
+        writel(le16_to_cpu(fib->hw_fib_va->header.Size), device);
         rx_writel(dev, MUnit.InboundQueue, Index);
         return 0;
 }
@@ -460,22 +460,34 @@ static int aac_rx_ioremap(struct aac_dev * dev, u32 size)
         return 0;
 }
 
-static int aac_rx_restart_adapter(struct aac_dev *dev)
+static int aac_rx_restart_adapter(struct aac_dev *dev, int bled)
 {
         u32 var;
 
-        printk(KERN_ERR "%s%d: adapter kernel panic'd.\n",
-                        dev->name, dev->id);
-
-        if (aac_rx_check_health(dev) <= 0)
-                return 1;
-        if (rx_sync_cmd(dev, IOP_RESET, 0, 0, 0, 0, 0, 0,
-                        &var, NULL, NULL, NULL, NULL))
-                return 1;
+        if (bled)
+                printk(KERN_ERR "%s%d: adapter kernel panic'd %x.\n",
+                        dev->name, dev->id, bled);
+        else {
+                bled = aac_adapter_sync_cmd(dev, IOP_RESET_ALWAYS,
+                  0, 0, 0, 0, 0, 0, &var, NULL, NULL, NULL, NULL);
+                if (!bled && (var != 0x00000001))
+                        bled = -EINVAL;
+        }
+        if (bled && (bled != -ETIMEDOUT))
+                bled = aac_adapter_sync_cmd(dev, IOP_RESET,
+                  0, 0, 0, 0, 0, 0, &var, NULL, NULL, NULL, NULL);
+
+        if (bled && (bled != -ETIMEDOUT))
+                return -EINVAL;
+        if (bled || (var == 0x3803000F)) { /* USE_OTHER_METHOD */
+                rx_writel(dev, MUnit.reserved2, 3);
+                msleep(5000); /* Delay 5 seconds */
+                var = 0x00000001;
+        }
         if (var != 0x00000001)
-                 return 1;
+                return -EINVAL;
         if (rx_readl(dev, MUnit.OMRx[0]) & KERNEL_PANIC)
-                return 1;
+                return -ENODEV;
         return 0;
 }
 
@@ -517,24 +529,29 @@ int _aac_rx_init(struct aac_dev *dev)
 {
         unsigned long start;
         unsigned long status;
-        int instance;
-        const char * name;
-
-        instance = dev->id;
-        name     = dev->name;
+        int restart = 0;
+        int instance = dev->id;
+        const char * name = dev->name;
 
         if (aac_adapter_ioremap(dev, dev->base_size)) {
                 printk(KERN_WARNING "%s: unable to map adapter.\n", name);
                 goto error_iounmap;
         }
 
+        /* Failure to reset here is an option ... */
+        dev->OIMR = status = rx_readb (dev, MUnit.OIMR);
+        if ((((status & 0xff) != 0xff) || reset_devices) &&
+          !aac_rx_restart_adapter(dev, 0))
+                ++restart;
         /*
          *      Check to see if the board panic'd while booting.
          */
         status = rx_readl(dev, MUnit.OMRx[0]);
-        if (status & KERNEL_PANIC)
-                if (aac_rx_restart_adapter(dev))
+        if (status & KERNEL_PANIC) {
+                if (aac_rx_restart_adapter(dev, aac_rx_check_health(dev)))
                         goto error_iounmap;
+                ++restart;
+        }
         /*
          *      Check to see if the board failed any self tests.
          */
@@ -556,12 +573,23 @@ int _aac_rx_init(struct aac_dev *dev)
          */
         while (!((status = rx_readl(dev, MUnit.OMRx[0])) & KERNEL_UP_AND_RUNNING))
         {
-                if(time_after(jiffies, start+startup_timeout*HZ))
-                {
+                if ((restart &&
+                  (status & (KERNEL_PANIC|SELF_TEST_FAILED|MONITOR_PANIC))) ||
+                  time_after(jiffies, start+HZ*startup_timeout)) {
                         printk(KERN_ERR "%s%d: adapter kernel failed to start, init status = %lx.\n", 
                                         dev->name, instance, status);
                         goto error_iounmap;
                 }
+                if (!restart &&
+                  ((status & (KERNEL_PANIC|SELF_TEST_FAILED|MONITOR_PANIC)) ||
+                  time_after(jiffies, start + HZ *
+                  ((startup_timeout > 60)
+                    ? (startup_timeout - 60)
+                    : (startup_timeout / 2))))) {
+                        if (likely(!aac_rx_restart_adapter(dev, aac_rx_check_health(dev))))
+                                start = jiffies;
+                        ++restart;
+                }
                 msleep(1);
         }
         /*
@@ -572,6 +600,7 @@ int _aac_rx_init(struct aac_dev *dev)
         dev->a_ops.adapter_notify = aac_rx_notify_adapter;
         dev->a_ops.adapter_sync_cmd = rx_sync_cmd;
         dev->a_ops.adapter_check_health = aac_rx_check_health;
+        dev->a_ops.adapter_restart = aac_rx_restart_adapter;
 
         /*
          *      First clear out all interrupts.  Then enable the one's that we