81 files changed, 3727 insertions, 1794 deletions
diff --git a/drivers/scsi/3w-9xxx.c b/drivers/scsi/3w-9xxx.c
index 31c497542272..d9152d02088c 100644
--- a/drivers/scsi/3w-9xxx.c
+++ b/drivers/scsi/3w-9xxx.c
@@ -61,6 +61,7 @@
                 Add support for embedded firmware error strings.
   2.26.02.003 - Correctly handle single sgl's with use_sg=1.
   2.26.02.004 - Add support for 9550SX controllers.
+   2.26.02.005 - Fix use_sg == 0 mapping on systems with 4GB or higher.
 */
 #include <linux/module.h>
@@ -84,7 +85,7 @@
 #include "3w-9xxx.h"
 /* Globals */
-#define TW_DRIVER_VERSION "2.26.02.004"
+#define TW_DRIVER_VERSION "2.26.02.005"
 static TW_Device_Extension *twa_device_extension_list[TW_MAX_SLOT];
 static unsigned int twa_device_extension_count;
 static int twa_major = -1;
@@ -1408,7 +1409,7 @@ static dma_addr_t twa_map_scsi_single_data(TW_Device_Extension *tw_dev, int requ
        dma_addr_t mapping;
        struct scsi_cmnd *cmd = tw_dev->srb[request_id];
        struct pci_dev *pdev = tw_dev->tw_pci_dev;
-        int retval = 0;
+        dma_addr_t retval = 0;
        if (cmd->request_bufflen == 0) {
                retval = 0;
@@ -1798,7 +1799,7 @@ static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id,
        int i, sg_count;
        struct scsi_cmnd *srb = NULL;
        struct scatterlist *sglist = NULL;
-        u32 buffaddr = 0x0;
+        dma_addr_t buffaddr = 0x0;
        int retval = 1;
        if (tw_dev->srb[request_id]) {
diff --git a/drivers/scsi/aacraid/aachba.c b/drivers/scsi/aacraid/aachba.c
index 7139659dd952..a16f8ded8f1d 100644
--- a/drivers/scsi/aacraid/aachba.c
+++ b/drivers/scsi/aacraid/aachba.c
@@ -173,10 +173,10 @@ int aac_get_config_status(struct aac_dev *dev)
        int status = 0;
        struct fib * fibptr;
-        if (!(fibptr = fib_alloc(dev)))
+        if (!(fibptr = aac_fib_alloc(dev)))
                return -ENOMEM;
-        fib_init(fibptr);
+        aac_fib_init(fibptr);
        {
                struct aac_get_config_status *dinfo;
                dinfo = (struct aac_get_config_status *) fib_data(fibptr);
@@ -186,7 +186,7 @@ int aac_get_config_status(struct aac_dev *dev)
                dinfo->count = cpu_to_le32(sizeof(((struct aac_get_config_status_resp *)NULL)->data));
        }
-        status = fib_send(ContainerCommand,
+        status = aac_fib_send(ContainerCommand,
                            fibptr,
                            sizeof (struct aac_get_config_status),
                            FsaNormal,
@@ -209,30 +209,30 @@ int aac_get_config_status(struct aac_dev *dev)
                        status = -EINVAL;
                }
        }
-        fib_complete(fibptr);
+        aac_fib_complete(fibptr);
        /* Send a CT_COMMIT_CONFIG to enable discovery of devices */
        if (status >= 0) {
                if (commit == 1) {
                        struct aac_commit_config * dinfo;
-                        fib_init(fibptr);
+                        aac_fib_init(fibptr);
                        dinfo = (struct aac_commit_config *) fib_data(fibptr);
        
                        dinfo->command = cpu_to_le32(VM_ContainerConfig);
                        dinfo->type = cpu_to_le32(CT_COMMIT_CONFIG);
        
-                        status = fib_send(ContainerCommand,
+                        status = aac_fib_send(ContainerCommand,
                                    fibptr,
                                    sizeof (struct aac_commit_config),
                                    FsaNormal,
                                    1, 1,
                                    NULL, NULL);
-                        fib_complete(fibptr);
+                        aac_fib_complete(fibptr);
                } else if (commit == 0) {
                        printk(KERN_WARNING
                          "aac_get_config_status: Foreign device configurations are being ignored\n");
                }
        }
-        fib_free(fibptr);
+        aac_fib_free(fibptr);
        return status;
 }
@@ -255,15 +255,15 @@ int aac_get_containers(struct aac_dev *dev)
        instance = dev->scsi_host_ptr->unique_id;
-        if (!(fibptr = fib_alloc(dev)))
+        if (!(fibptr = aac_fib_alloc(dev)))
                return -ENOMEM;
-        fib_init(fibptr);
+        aac_fib_init(fibptr);
        dinfo = (struct aac_get_container_count *) fib_data(fibptr);
        dinfo->command = cpu_to_le32(VM_ContainerConfig);
        dinfo->type = cpu_to_le32(CT_GET_CONTAINER_COUNT);
-        status = fib_send(ContainerCommand,
+        status = aac_fib_send(ContainerCommand,
                    fibptr,
                    sizeof (struct aac_get_container_count),
                    FsaNormal,
@@ -272,7 +272,7 @@ int aac_get_containers(struct aac_dev *dev)
        if (status >= 0) {
                dresp = (struct aac_get_container_count_resp *)fib_data(fibptr);
                maximum_num_containers = le32_to_cpu(dresp->ContainerSwitchEntries);
-                fib_complete(fibptr);
+                aac_fib_complete(fibptr);
        }
        if (maximum_num_containers < MAXIMUM_NUM_CONTAINERS)
@@ -280,7 +280,7 @@ int aac_get_containers(struct aac_dev *dev)
        fsa_dev_ptr = (struct fsa_dev_info *) kmalloc(
          sizeof(*fsa_dev_ptr) * maximum_num_containers, GFP_KERNEL);
        if (!fsa_dev_ptr) {
-                fib_free(fibptr);
+                aac_fib_free(fibptr);
                return -ENOMEM;
        }
        memset(fsa_dev_ptr, 0, sizeof(*fsa_dev_ptr) * maximum_num_containers);
@@ -294,14 +294,14 @@ int aac_get_containers(struct aac_dev *dev)
                fsa_dev_ptr[index].devname[0] = '\0';
-                fib_init(fibptr);
+                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 = fib_send(ContainerCommand,
+                status = aac_fib_send(ContainerCommand,
                                    fibptr,
                                    sizeof (struct aac_query_mount),
                                    FsaNormal,
@@ -319,7 +319,7 @@ int aac_get_containers(struct aac_dev *dev)
                        dinfo->count = cpu_to_le32(index);
                        dinfo->type = cpu_to_le32(FT_FILESYS);
-                        if (fib_send(ContainerCommand,
+                        if (aac_fib_send(ContainerCommand,
                                    fibptr,
                                    sizeof(struct aac_query_mount),
                                    FsaNormal,
@@ -347,7 +347,7 @@ int aac_get_containers(struct aac_dev *dev)
                        if (le32_to_cpu(dresp->mnt[0].state) & FSCS_READONLY)
                                    fsa_dev_ptr[index].ro = 1;
                }
-                fib_complete(fibptr);
+                aac_fib_complete(fibptr);
                /*
                 *      If there are no more containers, then stop asking.
                 */
@@ -355,7 +355,7 @@ int aac_get_containers(struct aac_dev *dev)
                        break;
                }
        }
-        fib_free(fibptr);
+        aac_fib_free(fibptr);
        return status;
 }
@@ -413,8 +413,8 @@ static void get_container_name_callback(void *context, struct fib * fibptr)
        scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
-        fib_complete(fibptr);
+        aac_fib_complete(fibptr);
-        fib_free(fibptr);
+        aac_fib_free(fibptr);
        scsicmd->scsi_done(scsicmd);
 }
@@ -430,10 +430,10 @@ static int aac_get_container_name(struct scsi_cmnd * scsicmd, int cid)
        dev = (struct aac_dev *)scsicmd->device->host->hostdata;
-        if (!(cmd_fibcontext = fib_alloc(dev)))
+        if (!(cmd_fibcontext = aac_fib_alloc(dev)))
                return -ENOMEM;
-        fib_init(cmd_fibcontext);
+        aac_fib_init(cmd_fibcontext);
        dinfo = (struct aac_get_name *) fib_data(cmd_fibcontext);
        dinfo->command = cpu_to_le32(VM_ContainerConfig);
@@ -441,7 +441,7 @@ static int aac_get_container_name(struct scsi_cmnd * scsicmd, int cid)
        dinfo->cid = cpu_to_le32(cid);
        dinfo->count = cpu_to_le32(sizeof(((struct aac_get_name_resp *)NULL)->data));
-        status = fib_send(ContainerCommand, 
+        status = aac_fib_send(ContainerCommand,
                  cmd_fibcontext, 
                  sizeof (struct aac_get_name),
                  FsaNormal, 
@@ -455,14 +455,14 @@ static int aac_get_container_name(struct scsi_cmnd * scsicmd, int cid)
        if (status == -EINPROGRESS) 
                return 0;
                
-        printk(KERN_WARNING "aac_get_container_name: fib_send failed with status: %d.\n", status);
+        printk(KERN_WARNING "aac_get_container_name: aac_fib_send failed with status: %d.\n", status);
-        fib_complete(cmd_fibcontext);
+        aac_fib_complete(cmd_fibcontext);
-        fib_free(cmd_fibcontext);
+        aac_fib_free(cmd_fibcontext);
        return -1;
 }
 /**
- *      probe_container         -       query a logical volume
+ *      aac_probe_container             -       query a logical volume
 *      @dev: device to query
 *      @cid: container identifier
 *
@@ -470,7 +470,7 @@ static int aac_get_container_name(struct scsi_cmnd * scsicmd, int cid)
 *      is updated in the struct fsa_dev_info structure rather than returned.
 */
 
-int probe_container(struct aac_dev *dev, int cid)
+int aac_probe_container(struct aac_dev *dev, int cid)
 {
        struct fsa_dev_info *fsa_dev_ptr;
        int status;
@@ -482,10 +482,10 @@ int probe_container(struct aac_dev *dev, int cid)
        fsa_dev_ptr = dev->fsa_dev;
        instance = dev->scsi_host_ptr->unique_id;
-        if (!(fibptr = fib_alloc(dev)))
+        if (!(fibptr = aac_fib_alloc(dev)))
                return -ENOMEM;
-        fib_init(fibptr);
+        aac_fib_init(fibptr);
        dinfo = (struct aac_query_mount *)fib_data(fibptr);
@@ -493,14 +493,14 @@ int probe_container(struct aac_dev *dev, int cid)
        dinfo->count = cpu_to_le32(cid);
        dinfo->type = cpu_to_le32(FT_FILESYS);
-        status = fib_send(ContainerCommand,
+        status = aac_fib_send(ContainerCommand,
                            fibptr,
                            sizeof(struct aac_query_mount),
                            FsaNormal,
                            1, 1,
                            NULL, NULL);
        if (status < 0) {
-                printk(KERN_WARNING "aacraid: probe_container query failed.\n");
+                printk(KERN_WARNING "aacraid: aac_probe_container query failed.\n");
                goto error;
        }
@@ -512,7 +512,7 @@ int probe_container(struct aac_dev *dev, int cid)
                dinfo->count = cpu_to_le32(cid);
                dinfo->type = cpu_to_le32(FT_FILESYS);
-                if (fib_send(ContainerCommand,
+                if (aac_fib_send(ContainerCommand,
                            fibptr,
                            sizeof(struct aac_query_mount),
                            FsaNormal,
@@ -535,8 +535,8 @@ int probe_container(struct aac_dev *dev, int cid)
        }
 error:
-        fib_complete(fibptr);
+        aac_fib_complete(fibptr);
-        fib_free(fibptr);
+        aac_fib_free(fibptr);
        return status;
 }
@@ -700,14 +700,14 @@ int aac_get_adapter_info(struct aac_dev* dev)
        struct aac_bus_info *command;
        struct aac_bus_info_response *bus_info;
-        if (!(fibptr = fib_alloc(dev)))
+        if (!(fibptr = aac_fib_alloc(dev)))
                return -ENOMEM;
-        fib_init(fibptr);
+        aac_fib_init(fibptr);
        info = (struct aac_adapter_info *) fib_data(fibptr);
        memset(info,0,sizeof(*info));
-        rcode = fib_send(RequestAdapterInfo,
+        rcode = aac_fib_send(RequestAdapterInfo,
                         fibptr, 
                         sizeof(*info),
                         FsaNormal, 
@@ -716,8 +716,8 @@ int aac_get_adapter_info(struct aac_dev* dev)
                         NULL);
        if (rcode < 0) {
-                fib_complete(fibptr);
+                aac_fib_complete(fibptr);
-                fib_free(fibptr);
+                aac_fib_free(fibptr);
                return rcode;
        }
        memcpy(&dev->adapter_info, info, sizeof(*info));
@@ -725,13 +725,13 @@ int aac_get_adapter_info(struct aac_dev* dev)
        if (dev->adapter_info.options & AAC_OPT_SUPPLEMENT_ADAPTER_INFO) {
                struct aac_supplement_adapter_info * info;
-                fib_init(fibptr);
+                aac_fib_init(fibptr);
                info = (struct aac_supplement_adapter_info *) fib_data(fibptr);
                memset(info,0,sizeof(*info));
-                rcode = fib_send(RequestSupplementAdapterInfo,
+                rcode = aac_fib_send(RequestSupplementAdapterInfo,
                                 fibptr,
                                 sizeof(*info),
                                 FsaNormal,
@@ -748,7 +748,7 @@ int aac_get_adapter_info(struct aac_dev* dev)
         * GetBusInfo 
         */
-        fib_init(fibptr);
+        aac_fib_init(fibptr);
        bus_info = (struct aac_bus_info_response *) fib_data(fibptr);
@@ -761,7 +761,7 @@ int aac_get_adapter_info(struct aac_dev* dev)
        command->MethodId = cpu_to_le32(1);
        command->CtlCmd = cpu_to_le32(GetBusInfo);
-        rcode = fib_send(ContainerCommand,
+        rcode = aac_fib_send(ContainerCommand,
                         fibptr,
                         sizeof (*bus_info),
                         FsaNormal,
@@ -891,8 +891,8 @@ int aac_get_adapter_info(struct aac_dev* dev)
                }
        }
-        fib_complete(fibptr);
+        aac_fib_complete(fibptr);
-        fib_free(fibptr);
+        aac_fib_free(fibptr);
        return rcode;
 }
@@ -976,8 +976,8 @@ static void io_callback(void *context, struct fib * fibptr)
                    ? sizeof(scsicmd->sense_buffer)
                    : sizeof(dev->fsa_dev[cid].sense_data));
        }
-        fib_complete(fibptr);
+        aac_fib_complete(fibptr);
-        fib_free(fibptr);
+        aac_fib_free(fibptr);
        scsicmd->scsi_done(scsicmd);
 }
@@ -1062,11 +1062,11 @@ static int aac_read(struct scsi_cmnd * scsicmd, int cid)
        /*
         *      Alocate and initialize a Fib
         */
-        if (!(cmd_fibcontext = fib_alloc(dev))) {
+        if (!(cmd_fibcontext = aac_fib_alloc(dev))) {
                return -1;
        }
-        fib_init(cmd_fibcontext);
+        aac_fib_init(cmd_fibcontext);
        if (dev->raw_io_interface) {
                struct aac_raw_io *readcmd;
@@ -1086,7 +1086,7 @@ static int aac_read(struct scsi_cmnd * scsicmd, int cid)
                /*
                 *      Now send the Fib to the adapter
                 */
-                status = fib_send(ContainerRawIo,
+                status = aac_fib_send(ContainerRawIo,
                          cmd_fibcontext, 
                          fibsize, 
                          FsaNormal, 
@@ -1112,7 +1112,7 @@ static int aac_read(struct scsi_cmnd * scsicmd, int cid)
                /*
                 *      Now send the Fib to the adapter
                 */
-                status = fib_send(ContainerCommand64, 
+                status = aac_fib_send(ContainerCommand64,
                          cmd_fibcontext, 
                          fibsize, 
                          FsaNormal, 
@@ -1136,7 +1136,7 @@ static int aac_read(struct scsi_cmnd * scsicmd, int cid)
                /*
                 *      Now send the Fib to the adapter
                 */
-                status = fib_send(ContainerCommand, 
+                status = aac_fib_send(ContainerCommand,
                          cmd_fibcontext, 
                          fibsize, 
                          FsaNormal, 
@@ -1153,14 +1153,14 @@ static int aac_read(struct scsi_cmnd * scsicmd, int cid)
        if (status == -EINPROGRESS) 
                return 0;
                
-        printk(KERN_WARNING "aac_read: fib_send failed with status: %d.\n", status);
+        printk(KERN_WARNING "aac_read: aac_fib_send failed with status: %d.\n", status);
        /*
         *      For some reason, the Fib didn't queue, return QUEUE_FULL
         */
        scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_TASK_SET_FULL;
        scsicmd->scsi_done(scsicmd);
-        fib_complete(cmd_fibcontext);
+        aac_fib_complete(cmd_fibcontext);
-        fib_free(cmd_fibcontext);
+        aac_fib_free(cmd_fibcontext);
        return 0;
 }
@@ -1228,12 +1228,12 @@ static int aac_write(struct scsi_cmnd * scsicmd, int cid)
        /*
         *      Allocate and initialize a Fib then setup a BlockWrite command
         */
-        if (!(cmd_fibcontext = fib_alloc(dev))) {
+        if (!(cmd_fibcontext = aac_fib_alloc(dev))) {
                scsicmd->result = DID_ERROR << 16;
                scsicmd->scsi_done(scsicmd);
                return 0;
        }
-        fib_init(cmd_fibcontext);
+        aac_fib_init(cmd_fibcontext);
        if (dev->raw_io_interface) {
                struct aac_raw_io *writecmd;
@@ -1253,7 +1253,7 @@ static int aac_write(struct scsi_cmnd * scsicmd, int cid)
                /*
                 *      Now send the Fib to the adapter
                 */
-                status = fib_send(ContainerRawIo,
+                status = aac_fib_send(ContainerRawIo,
                          cmd_fibcontext, 
                          fibsize, 
                          FsaNormal, 
@@ -1279,7 +1279,7 @@ static int aac_write(struct scsi_cmnd * scsicmd, int cid)
                /*
                 *      Now send the Fib to the adapter
                 */
-                status = fib_send(ContainerCommand64, 
+                status = aac_fib_send(ContainerCommand64,
                          cmd_fibcontext, 
                          fibsize, 
                          FsaNormal, 
@@ -1305,7 +1305,7 @@ static int aac_write(struct scsi_cmnd * scsicmd, int cid)
                /*
                 *      Now send the Fib to the adapter
                 */
-                status = fib_send(ContainerCommand, 
+                status = aac_fib_send(ContainerCommand,
                          cmd_fibcontext, 
                          fibsize, 
                          FsaNormal, 
@@ -1322,15 +1322,15 @@ static int aac_write(struct scsi_cmnd * scsicmd, int cid)
                return 0;
        }
-        printk(KERN_WARNING "aac_write: fib_send failed with status: %d\n", status);
+        printk(KERN_WARNING "aac_write: aac_fib_send failed with status: %d\n", status);
        /*
         *      For some reason, the Fib didn't queue, return QUEUE_FULL
         */
        scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_TASK_SET_FULL;
        scsicmd->scsi_done(scsicmd);
-        fib_complete(cmd_fibcontext);
+        aac_fib_complete(cmd_fibcontext);
-        fib_free(cmd_fibcontext);
+        aac_fib_free(cmd_fibcontext);
        return 0;
 }
@@ -1369,8 +1369,8 @@ static void synchronize_callback(void *context, struct fib *fibptr)
                          sizeof(cmd->sense_buffer)));
        }
-        fib_complete(fibptr);
+        aac_fib_complete(fibptr);
-        fib_free(fibptr);
+        aac_fib_free(fibptr);
        cmd->scsi_done(cmd);
 }
@@ -1407,10 +1407,10 @@ static int aac_synchronize(struct scsi_cmnd *scsicmd, int cid)
         *      Allocate and initialize a Fib
         */
        if (!(cmd_fibcontext = 
-            fib_alloc((struct aac_dev *)scsicmd->device->host->hostdata))) 
+            aac_fib_alloc((struct aac_dev *)scsicmd->device->host->hostdata)))
                return SCSI_MLQUEUE_HOST_BUSY;
-        fib_init(cmd_fibcontext);
+        aac_fib_init(cmd_fibcontext);
        synchronizecmd = fib_data(cmd_fibcontext);
        synchronizecmd->command = cpu_to_le32(VM_ContainerConfig);
@@ -1422,7 +1422,7 @@ static int aac_synchronize(struct scsi_cmnd *scsicmd, int cid)
        /*
         *      Now send the Fib to the adapter
         */
-        status = fib_send(ContainerCommand,
+        status = aac_fib_send(ContainerCommand,
                  cmd_fibcontext,
                  sizeof(struct aac_synchronize),
                  FsaNormal,
@@ -1437,9 +1437,9 @@ static int aac_synchronize(struct scsi_cmnd *scsicmd, int cid)
                return 0;
        printk(KERN_WARNING 
-                "aac_synchronize: fib_send failed with status: %d.\n", status);
+                "aac_synchronize: aac_fib_send failed with status: %d.\n", status);
-        fib_complete(cmd_fibcontext);
+        aac_fib_complete(cmd_fibcontext);
-        fib_free(cmd_fibcontext);
+        aac_fib_free(cmd_fibcontext);
        return SCSI_MLQUEUE_HOST_BUSY;
 }
@@ -1465,7 +1465,7 @@ int aac_scsi_cmd(struct scsi_cmnd * scsicmd)
         *      itself.
         */
        if (scmd_id(scsicmd) != host->this_id) {
-                if ((scsicmd->device->channel == 0) ){
+                if ((scsicmd->device->channel == CONTAINER_CHANNEL)) {
                        if( (scsicmd->device->id >= dev->maximum_num_containers) || (scsicmd->device->lun != 0)){ 
                                scsicmd->result = DID_NO_CONNECT << 16;
                                scsicmd->scsi_done(scsicmd);
@@ -1488,7 +1488,7 @@ int aac_scsi_cmd(struct scsi_cmnd * scsicmd)
                                case READ_CAPACITY:
                                case TEST_UNIT_READY:
                                        spin_unlock_irq(host->host_lock);
-                                        probe_container(dev, cid);
+                                        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);
@@ -1935,33 +1935,7 @@ static void aac_srb_callback(void *context, struct fib * fibptr)
        case SRB_STATUS_ERROR_RECOVERY:
        case SRB_STATUS_PENDING:
        case SRB_STATUS_SUCCESS:
-                if(scsicmd->cmnd[0] == INQUIRY ){
+                scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8;
-                        u8 b;
-                        u8 b1;
-                        /* We can't expose disk devices because we can't tell whether they
-                         * are the raw container drives or stand alone drives.  If they have
-                         * the removable bit set then we should expose them though.
-                         */
-                        b = (*(u8*)scsicmd->buffer)&0x1f;
-                        b1 = ((u8*)scsicmd->buffer)[1];
-                        if( b==TYPE_TAPE || b==TYPE_WORM || b==TYPE_ROM || b==TYPE_MOD|| b==TYPE_MEDIUM_CHANGER 
-                                        || (b==TYPE_DISK && (b1&0x80)) ){
-                                scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8;
-                        /*
-                         * We will allow disk devices if in RAID/SCSI mode and
-                         * the channel is 2
-                         */
-                        } else if ((dev->raid_scsi_mode) &&
-                                        (scmd_channel(scsicmd) == 2)) {
-                                scsicmd->result = DID_OK << 16 | 
-                                                COMMAND_COMPLETE << 8;
-                        } else {
-                                scsicmd->result = DID_NO_CONNECT << 16 | 
-                                                COMMAND_COMPLETE << 8;
-                        }
-                } else {
-                        scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8;
-                }
                break;
        case SRB_STATUS_DATA_OVERRUN:
                switch(scsicmd->cmnd[0]){
@@ -1981,28 +1955,7 @@ static void aac_srb_callback(void *context, struct fib * fibptr)
                        scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8;
                        break;
                case INQUIRY: {
-                        u8 b;
+                        scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8;
-                        u8 b1;
-                        /* We can't expose disk devices because we can't tell whether they
-                        * are the raw container drives or stand alone drives
-                        */
-                        b = (*(u8*)scsicmd->buffer)&0x0f;
-                        b1 = ((u8*)scsicmd->buffer)[1];
-                        if( b==TYPE_TAPE || b==TYPE_WORM || b==TYPE_ROM || b==TYPE_MOD|| b==TYPE_MEDIUM_CHANGER
-                                        || (b==TYPE_DISK && (b1&0x80)) ){
-                                scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8;
-                        /*
-                         * We will allow disk devices if in RAID/SCSI mode and
-                         * the channel is 2
-                         */
-                        } else if ((dev->raid_scsi_mode) &&
-                                        (scmd_channel(scsicmd) == 2)) {
-                                scsicmd->result = DID_OK << 16 | 
-                                                COMMAND_COMPLETE << 8;
-                        } else {
-                                scsicmd->result = DID_NO_CONNECT << 16 | 
-                                                COMMAND_COMPLETE << 8;
-                        }
                        break;
                }
                default:
@@ -2089,8 +2042,8 @@ static void aac_srb_callback(void *context, struct fib * fibptr)
         */
        scsicmd->result |= le32_to_cpu(srbreply->scsi_status);
-        fib_complete(fibptr);
+        aac_fib_complete(fibptr);
-        fib_free(fibptr);
+        aac_fib_free(fibptr);
        scsicmd->scsi_done(scsicmd);
 }
@@ -2142,10 +2095,10 @@ static int aac_send_srb_fib(struct scsi_cmnd* scsicmd)
        /*
         *      Allocate and initialize a Fib then setup a BlockWrite command
         */
-        if (!(cmd_fibcontext = fib_alloc(dev))) {
+        if (!(cmd_fibcontext = aac_fib_alloc(dev))) {
                return -1;
        }
-        fib_init(cmd_fibcontext);
+        aac_fib_init(cmd_fibcontext);
        srbcmd = (struct aac_srb*) fib_data(cmd_fibcontext);
        srbcmd->function = cpu_to_le32(SRBF_ExecuteScsi);
@@ -2179,7 +2132,7 @@ static int aac_send_srb_fib(struct scsi_cmnd* scsicmd)
                /*
                 *      Now send the Fib to the adapter
                 */
-                status = fib_send(ScsiPortCommand64, cmd_fibcontext, 
+                status = aac_fib_send(ScsiPortCommand64, cmd_fibcontext,
                                fibsize, FsaNormal, 0, 1,
                                  (fib_callback) aac_srb_callback, 
                                  (void *) scsicmd);
@@ -2201,7 +2154,7 @@ static int aac_send_srb_fib(struct scsi_cmnd* scsicmd)
                /*
                 *      Now send the Fib to the adapter
                 */
-                status = fib_send(ScsiPortCommand, cmd_fibcontext, fibsize, FsaNormal, 0, 1,
+                status = aac_fib_send(ScsiPortCommand, cmd_fibcontext, fibsize, FsaNormal, 0, 1,
                                  (fib_callback) aac_srb_callback, (void *) scsicmd);
        }
        /*
@@ -2211,9 +2164,9 @@ static int aac_send_srb_fib(struct scsi_cmnd* scsicmd)
                return 0;
        }
-        printk(KERN_WARNING "aac_srb: fib_send failed with status: %d\n", status);
+        printk(KERN_WARNING "aac_srb: aac_fib_send failed with status: %d\n", status);
-        fib_complete(cmd_fibcontext);
+        aac_fib_complete(cmd_fibcontext);
-        fib_free(cmd_fibcontext);
+        aac_fib_free(cmd_fibcontext);
        return -1;
 }
diff --git a/drivers/scsi/aacraid/aacraid.h b/drivers/scsi/aacraid/aacraid.h
index 66dbb6d2c506..2d430b7e8cf4 100644
--- a/drivers/scsi/aacraid/aacraid.h
+++ b/drivers/scsi/aacraid/aacraid.h
@@ -1774,16 +1774,16 @@ static inline u32 cap_to_cyls(sector_t capacity, u32 divisor)
 struct scsi_cmnd;
 const char *aac_driverinfo(struct Scsi_Host *);
-struct fib *fib_alloc(struct aac_dev *dev);
+struct fib *aac_fib_alloc(struct aac_dev *dev);
-int fib_setup(struct aac_dev *dev);
+int aac_fib_setup(struct aac_dev *dev);
-void fib_map_free(struct aac_dev *dev);
+void aac_fib_map_free(struct aac_dev *dev);
-void fib_free(struct fib * context);
+void aac_fib_free(struct fib * context);
-void fib_init(struct fib * context);
+void aac_fib_init(struct fib * context);
 void aac_printf(struct aac_dev *dev, u32 val);
-int fib_send(u16 command, struct fib * context, unsigned long size, int priority, int wait, int reply, fib_callback callback, void *ctxt);
+int aac_fib_send(u16 command, struct fib * context, unsigned long size, int priority, int wait, int reply, fib_callback callback, void *ctxt);
 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 fib_complete(struct fib * context);
+int aac_fib_complete(struct fib * context);
 #define fib_data(fibctx) ((void *)(fibctx)->hw_fib->data)
 struct aac_dev *aac_init_adapter(struct aac_dev *dev);
 int aac_get_config_status(struct aac_dev *dev);
@@ -1799,11 +1799,11 @@ unsigned int aac_command_normal(struct aac_queue * q);
 unsigned int aac_intr_normal(struct aac_dev * dev, u32 Index);
 int aac_command_thread(struct aac_dev * dev);
 int aac_close_fib_context(struct aac_dev * dev, struct aac_fib_context *fibctx);
-int fib_adapter_complete(struct fib * fibptr, unsigned short size);
+int aac_fib_adapter_complete(struct fib * fibptr, unsigned short size);
 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 probe_container(struct aac_dev *dev, int cid);
+int aac_probe_container(struct aac_dev *dev, int cid);
 extern int numacb;
 extern int acbsize;
 extern char aac_driver_version[];
diff --git a/drivers/scsi/aacraid/commctrl.c b/drivers/scsi/aacraid/commctrl.c
index 4fe79cd7c957..47fefca72695 100644
--- a/drivers/scsi/aacraid/commctrl.c
+++ b/drivers/scsi/aacraid/commctrl.c
@@ -63,7 +63,7 @@ static int ioctl_send_fib(struct aac_dev * dev, void __user *arg)
        unsigned size;
        int retval;
-        fibptr = fib_alloc(dev);
+        fibptr = aac_fib_alloc(dev);
        if(fibptr == NULL) {
                return -ENOMEM;
        }
@@ -73,7 +73,7 @@ static int ioctl_send_fib(struct aac_dev * dev, void __user *arg)
         *      First copy in the header so that we can check the size field.
         */
        if (copy_from_user((void *)kfib, arg, sizeof(struct aac_fibhdr))) {
-                fib_free(fibptr);
+                aac_fib_free(fibptr);
                return -EFAULT;
        }
        /*
@@ -110,13 +110,13 @@ static int ioctl_send_fib(struct aac_dev * dev, void __user *arg)
                 */
                kfib->header.XferState = 0;
        } else {
-                retval = fib_send(le16_to_cpu(kfib->header.Command), fibptr,
+                retval = aac_fib_send(le16_to_cpu(kfib->header.Command), fibptr,
                                le16_to_cpu(kfib->header.Size) , FsaNormal,
                                1, 1, NULL, NULL);
                if (retval) {
                        goto cleanup;
                }
-                if (fib_complete(fibptr) != 0) {
+                if (aac_fib_complete(fibptr) != 0) {
                        retval = -EINVAL;
                        goto cleanup;
                }
@@ -138,7 +138,7 @@ cleanup:
                fibptr->hw_fib_pa = hw_fib_pa;
                fibptr->hw_fib = hw_fib;
        }
-        fib_free(fibptr);
+        aac_fib_free(fibptr);
        return retval;
 }
@@ -464,10 +464,10 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
        /*
         *      Allocate and initialize a Fib then setup a BlockWrite command
         */
-        if (!(srbfib = fib_alloc(dev))) {
+        if (!(srbfib = aac_fib_alloc(dev))) {
                return -ENOMEM;
        }
-        fib_init(srbfib);
+        aac_fib_init(srbfib);
        srbcmd = (struct aac_srb*) fib_data(srbfib);
@@ -601,7 +601,7 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
                srbcmd->count = cpu_to_le32(byte_count);
                psg->count = cpu_to_le32(sg_indx+1);
-                status = fib_send(ScsiPortCommand64, srbfib, actual_fibsize, FsaNormal, 1, 1,NULL,NULL);
+                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;
@@ -649,7 +649,7 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
                }
                srbcmd->count = cpu_to_le32(byte_count);
                psg->count = cpu_to_le32(sg_indx+1);
-                status = fib_send(ScsiPortCommand, srbfib, actual_fibsize, FsaNormal, 1, 1, NULL, NULL);
+                status = aac_fib_send(ScsiPortCommand, srbfib, actual_fibsize, FsaNormal, 1, 1, NULL, NULL);
        }
        if (status != 0){
@@ -684,8 +684,8 @@ cleanup:
        for(i=0; i <= sg_indx; i++){
                kfree(sg_list[i]);
        }
-        fib_complete(srbfib);
+        aac_fib_complete(srbfib);
-        fib_free(srbfib);
+        aac_fib_free(srbfib);
        return rcode;
 }
diff --git a/drivers/scsi/aacraid/comminit.c b/drivers/scsi/aacraid/comminit.c
index 82821d331c07..1628d094943d 100644
--- a/drivers/scsi/aacraid/comminit.c
+++ b/drivers/scsi/aacraid/comminit.c
@@ -185,17 +185,17 @@ int aac_send_shutdown(struct aac_dev * dev)
        struct aac_close *cmd;
        int status;
-        fibctx = fib_alloc(dev);
+        fibctx = aac_fib_alloc(dev);
        if (!fibctx)
                return -ENOMEM;
-        fib_init(fibctx);
+        aac_fib_init(fibctx);
        cmd = (struct aac_close *) fib_data(fibctx);
        cmd->command = cpu_to_le32(VM_CloseAll);
        cmd->cid = cpu_to_le32(0xffffffff);
-        status = fib_send(ContainerCommand,
+        status = aac_fib_send(ContainerCommand,
                          fibctx,
                          sizeof(struct aac_close),
                          FsaNormal,
@@ -203,8 +203,8 @@ int aac_send_shutdown(struct aac_dev * dev)
                          NULL, NULL);
        if (status == 0)
-                fib_complete(fibctx);
+                aac_fib_complete(fibctx);
-        fib_free(fibctx);
+        aac_fib_free(fibctx);
        return status;
 }
@@ -427,7 +427,7 @@ struct aac_dev *aac_init_adapter(struct aac_dev *dev)
        /*
         *      Initialize the list of fibs
         */
-        if(fib_setup(dev)<0){
+        if (aac_fib_setup(dev) < 0) {
                kfree(dev->queues);
                return NULL;
        }
diff --git a/drivers/scsi/aacraid/commsup.c b/drivers/scsi/aacraid/commsup.c
index 38d6d00fb0fc..609fd19b1844 100644
--- a/drivers/scsi/aacraid/commsup.c
+++ b/drivers/scsi/aacraid/commsup.c
@@ -38,10 +38,10 @@
 #include <linux/slab.h>
 #include <linux/completion.h>
 #include <linux/blkdev.h>
+#include <linux/delay.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_device.h>
 #include <asm/semaphore.h>
-#include <asm/delay.h>
 #include "aacraid.h"
@@ -67,27 +67,27 @@ static int fib_map_alloc(struct aac_dev *dev)
 }
 /**
- *      fib_map_free            -       free the fib objects
+ *      aac_fib_map_free                -       free the fib objects
 *      @dev: Adapter to free
 *
 *      Free the PCI mappings and the memory allocated for FIB blocks
 *      on this adapter.
 */
-void fib_map_free(struct aac_dev *dev)
+void aac_fib_map_free(struct aac_dev *dev)
 {
        pci_free_consistent(dev->pdev, dev->max_fib_size * (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB), dev->hw_fib_va, dev->hw_fib_pa);
 }
 /**
- *      fib_setup       -       setup the fibs
+ *      aac_fib_setup   -       setup the fibs
 *      @dev: Adapter to set up
 *
 *      Allocate the PCI space for the fibs, map it and then intialise the
 *      fib area, the unmapped fib data and also the free list
 */
-int fib_setup(struct aac_dev * dev)
+int aac_fib_setup(struct aac_dev * dev)
 {
        struct fib *fibptr;
        struct hw_fib *hw_fib_va;
@@ -134,14 +134,14 @@ int fib_setup(struct aac_dev * dev)
 }
 /**
- *      fib_alloc       -       allocate a fib
+ *      aac_fib_alloc   -       allocate a fib
 *      @dev: Adapter to allocate the fib for
 *
 *      Allocate a fib from the adapter fib pool. If the pool is empty we
 *      return NULL.
 */
 
-struct fib * fib_alloc(struct aac_dev *dev)
+struct fib *aac_fib_alloc(struct aac_dev *dev)
 {
        struct fib * fibptr;
        unsigned long flags;
@@ -170,14 +170,14 @@ struct fib * fib_alloc(struct aac_dev *dev)
 }
 /**
- *      fib_free        -       free a fib
+ *      aac_fib_free    -       free a fib
 *      @fibptr: fib to free up
 *
 *      Frees up a fib and places it on the appropriate queue
 *      (either free or timed out)
 */
 
-void fib_free(struct fib * fibptr)
+void aac_fib_free(struct fib *fibptr)
 {
        unsigned long flags;
@@ -188,7 +188,7 @@ void fib_free(struct fib * fibptr)
                fibptr->dev->timeout_fib = fibptr;
        } else {
                if (fibptr->hw_fib->header.XferState != 0) {
-                        printk(KERN_WARNING "fib_free, XferState != 0, fibptr = 0x%p, XferState = 0x%x\n", 
+                        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));
                }
@@ -199,13 +199,13 @@ void fib_free(struct fib * fibptr)
 }
 /**
- *      fib_init        -       initialise a fib
+ *      aac_fib_init    -       initialise a fib
 *      @fibptr: The fib to initialize
 *      
 *      Set up the generic fib fields ready for use
 */
 
-void fib_init(struct fib *fibptr)
+void aac_fib_init(struct fib *fibptr)
 {
        struct hw_fib *hw_fib = fibptr->hw_fib;
@@ -362,7 +362,7 @@ static int aac_queue_get(struct aac_dev * dev, u32 * index, u32 qid, struct hw_f
 */
 /**
- *      fib_send        -       send a fib to the adapter
+ *      aac_fib_send    -       send a fib to the adapter
 *      @command: Command to send
 *      @fibptr: The fib
 *      @size: Size of fib data area
@@ -378,7 +378,9 @@ static int aac_queue_get(struct aac_dev * dev, u32 * index, u32 qid, struct hw_f
 *      response FIB is received from the adapter.
 */
 
-int fib_send(u16 command, struct fib * fibptr, unsigned long size,  int priority, int wait, int reply, fib_callback callback, void * callback_data)
+int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size,
+                int priority, int wait, int reply, fib_callback callback,
+                void *callback_data)
 {
        struct aac_dev * dev = fibptr->dev;
        struct hw_fib * hw_fib = fibptr->hw_fib;
@@ -493,7 +495,7 @@ int fib_send(u16 command, struct fib * fibptr, unsigned long size,  int priority
                q->numpending++;
                *(q->headers.producer) = cpu_to_le32(index + 1);
                spin_unlock_irqrestore(q->lock, qflags);
-                dprintk((KERN_DEBUG "fib_send: inserting a queue entry at index %d.\n",index));
+                dprintk((KERN_DEBUG "aac_fib_send: inserting a queue entry at index %d.\n",index));
                if (!(nointr & aac_config.irq_mod))
                        aac_adapter_notify(dev, AdapNormCmdQueue);
        }
@@ -520,7 +522,7 @@ int fib_send(u16 command, struct fib * fibptr, unsigned long size,  int priority
                                        list_del(&fibptr->queue);
                                        spin_unlock_irqrestore(q->lock, qflags);
                                        if (wait == -1) {
-                                                printk(KERN_ERR "aacraid: fib_send: first asynchronous command timed out.\n"
+                                                printk(KERN_ERR "aacraid: aac_fib_send: first asynchronous command timed out.\n"
                                                  "Usually a result of a PCI interrupt routing problem;\n"
                                                  "update mother board BIOS or consider utilizing one of\n"
                                                  "the SAFE mode kernel options (acpi, apic etc)\n");
@@ -624,7 +626,7 @@ void aac_consumer_free(struct aac_dev * dev, struct aac_queue *q, u32 qid)
 }        
 /**
- *      fib_adapter_complete    -       complete adapter issued fib
+ *      aac_fib_adapter_complete        -       complete adapter issued fib
 *      @fibptr: fib to complete
 *      @size: size of fib
 *
@@ -632,7 +634,7 @@ void aac_consumer_free(struct aac_dev * dev, struct aac_queue *q, u32 qid)
 *      the adapter.
 */
-int fib_adapter_complete(struct fib * fibptr, unsigned short size)
+int aac_fib_adapter_complete(struct fib *fibptr, unsigned short size)
 {
        struct hw_fib * hw_fib = fibptr->hw_fib;
        struct aac_dev * dev = fibptr->dev;
@@ -683,20 +685,20 @@ int fib_adapter_complete(struct fib * fibptr, unsigned short size)
        }
        else 
        {
-                printk(KERN_WARNING "fib_adapter_complete: Unknown xferstate detected.\n");
+                printk(KERN_WARNING "aac_fib_adapter_complete: Unknown xferstate detected.\n");
                BUG();
        }   
        return 0;
 }
 /**
- *      fib_complete    -       fib completion handler
+ *      aac_fib_complete        -       fib completion handler
 *      @fib: FIB to complete
 *
 *      Will do all necessary work to complete a FIB.
 */
 
-int fib_complete(struct fib * fibptr)
+int aac_fib_complete(struct fib *fibptr)
 {
        struct hw_fib * hw_fib = fibptr->hw_fib;
@@ -995,14 +997,14 @@ static void aac_handle_aif(struct aac_dev * dev, struct fib * fibptr)
        if (!dev || !dev->scsi_host_ptr)
                return;
        /*
-         * force reload of disk info via probe_container
+         * force reload of disk info via aac_probe_container
         */
        if ((device_config_needed == CHANGE)
         && (dev->fsa_dev[container].valid == 1))
                dev->fsa_dev[container].valid = 2;
        if ((device_config_needed == CHANGE) ||
                        (device_config_needed == ADD))
-                probe_container(dev, container);
+                aac_probe_container(dev, container);
        device = scsi_device_lookup(dev->scsi_host_ptr, 
                CONTAINER_TO_CHANNEL(container), 
                CONTAINER_TO_ID(container), 
@@ -1104,7 +1106,7 @@ int aac_command_thread(struct aac_dev * dev)
                                /* Handle Driver Notify Events */
                                aac_handle_aif(dev, fib);
                                *(__le32 *)hw_fib->data = cpu_to_le32(ST_OK);
-                                fib_adapter_complete(fib, (u16)sizeof(u32));
+                                aac_fib_adapter_complete(fib, (u16)sizeof(u32));
                        } else {
                                struct list_head *entry;
                                /* The u32 here is important and intended. We are using
@@ -1241,7 +1243,7 @@ int aac_command_thread(struct aac_dev * dev)
                                 *      Set the status of this FIB
                                 */
                                *(__le32 *)hw_fib->data = cpu_to_le32(ST_OK);
-                                fib_adapter_complete(fib, sizeof(u32));
+                                aac_fib_adapter_complete(fib, sizeof(u32));
                                spin_unlock_irqrestore(&dev->fib_lock, flagv);
                                /* Free up the remaining resources */
                                hw_fib_p = hw_fib_pool;
diff --git a/drivers/scsi/aacraid/dpcsup.c b/drivers/scsi/aacraid/dpcsup.c
index 439948ef8251..f6bcb9486f85 100644
--- a/drivers/scsi/aacraid/dpcsup.c
+++ b/drivers/scsi/aacraid/dpcsup.c
@@ -206,7 +206,7 @@ unsigned int aac_command_normal(struct aac_queue *q)
                         *      Set the status of this FIB
                         */
                        *(__le32 *)hw_fib->data = cpu_to_le32(ST_OK);
-                        fib_adapter_complete(fib, sizeof(u32));
+                        aac_fib_adapter_complete(fib, sizeof(u32));
                        spin_lock_irqsave(q->lock, flags);
                }               
        }
diff --git a/drivers/scsi/aacraid/linit.c b/drivers/scsi/aacraid/linit.c
index 0bf5f9a943e8..271617890562 100644
--- a/drivers/scsi/aacraid/linit.c
+++ b/drivers/scsi/aacraid/linit.c
@@ -385,17 +385,45 @@ static int aac_biosparm(struct scsi_device *sdev, struct block_device *bdev,
 static int aac_slave_configure(struct scsi_device *sdev)
 {
-        struct Scsi_Host *host = sdev->host;
+        if (sdev_channel(sdev) == CONTAINER_CHANNEL) {
+                sdev->skip_ms_page_8 = 1;
+                sdev->skip_ms_page_3f = 1;
+        }
+        if ((sdev->type == TYPE_DISK) &&
+                        (sdev_channel(sdev) != CONTAINER_CHANNEL)) {
+                struct aac_dev *aac = (struct aac_dev *)sdev->host->hostdata;
+                if (!aac->raid_scsi_mode || (sdev_channel(sdev) != 2))
+                        sdev->no_uld_attach = 1;
+        }
+        if (sdev->tagged_supported && (sdev->type == TYPE_DISK) &&
+                        (sdev_channel(sdev) == CONTAINER_CHANNEL)) {
+                struct scsi_device * dev;
+                struct Scsi_Host *host = sdev->host;
+                unsigned num_lsu = 0;
+                unsigned num_one = 0;
+                unsigned depth;
-        if (sdev->tagged_supported)
+                __shost_for_each_device(dev, host) {
-                scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, 128);
+                        if (dev->tagged_supported && (dev->type == TYPE_DISK) &&
-        else
+                                (sdev_channel(dev) == CONTAINER_CHANNEL))
+                                ++num_lsu;
+                        else
+                                ++num_one;
+                }
+                if (num_lsu == 0)
+                        ++num_lsu;
+                depth = (host->can_queue - num_one) / num_lsu;
+                if (depth > 256)
+                        depth = 256;
+                else if (depth < 2)
+                        depth = 2;
+                scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth);
+                if (!(((struct aac_dev *)host->hostdata)->adapter_info.options &
+                                AAC_OPT_NEW_COMM))
+                        blk_queue_max_segment_size(sdev->request_queue, 65536);
+        } else
                scsi_adjust_queue_depth(sdev, 0, 1);
-        if (!(((struct aac_dev *)host->hostdata)->adapter_info.options
-          & AAC_OPT_NEW_COMM))
-                blk_queue_max_segment_size(sdev->request_queue, 65536);
        return 0;
 }
@@ -870,7 +898,7 @@ static int __devinit aac_probe_one(struct pci_dev *pdev,
 
        /*
         * max channel will be the physical channels plus 1 virtual channel
-         * all containers are on the virtual channel 0
+         * all containers are on the virtual channel 0 (CONTAINER_CHANNEL)
         * physical channels are address by their actual physical number+1
         */
        if (aac->nondasd_support == 1)
@@ -913,7 +941,7 @@ static int __devinit aac_probe_one(struct pci_dev *pdev,
        aac_adapter_disable_int(aac);
        free_irq(pdev->irq, aac);
 out_unmap:
-        fib_map_free(aac);
+        aac_fib_map_free(aac);
        pci_free_consistent(aac->pdev, aac->comm_size, aac->comm_addr, aac->comm_phys);
        kfree(aac->queues);
        iounmap(aac->regs.sa);
@@ -947,7 +975,7 @@ static void __devexit aac_remove_one(struct pci_dev *pdev)
        aac_send_shutdown(aac);
        aac_adapter_disable_int(aac);
-        fib_map_free(aac);
+        aac_fib_map_free(aac);
        pci_free_consistent(aac->pdev, aac->comm_size, aac->comm_addr,
                        aac->comm_phys);
        kfree(aac->queues);
diff --git a/drivers/scsi/aha152x.c b/drivers/scsi/aha152x.c
index cb2ee25f213f..531a1f9ceb51 100644
--- a/drivers/scsi/aha152x.c
+++ b/drivers/scsi/aha152x.c
@@ -1260,16 +1260,15 @@ static void free_hard_reset_SCs(struct Scsi_Host *shpnt, Scsi_Cmnd **SCs)
 * Reset the bus
 *
 */
-static int aha152x_bus_reset(Scsi_Cmnd *SCpnt)
+static int aha152x_bus_reset_host(struct Scsi_Host *shpnt)
 {
-        struct Scsi_Host *shpnt = SCpnt->device->host;
        unsigned long flags;
        DO_LOCK(flags);
 #if defined(AHA152X_DEBUG)
        if(HOSTDATA(shpnt)->debug & debug_eh) {
-                printk(DEBUG_LEAD "aha152x_bus_reset(%p)", CMDINFO(SCpnt), SCpnt);
+                printk(KERN_DEBUG "scsi%d: bus reset", shpnt->host_no);
                show_queues(shpnt);
        }
 #endif
@@ -1277,14 +1276,14 @@ static int aha152x_bus_reset(Scsi_Cmnd *SCpnt)
        free_hard_reset_SCs(shpnt, &ISSUE_SC);
        free_hard_reset_SCs(shpnt, &DISCONNECTED_SC);
-        DPRINTK(debug_eh, DEBUG_LEAD "resetting bus\n", CMDINFO(SCpnt));
+        DPRINTK(debug_eh, KERN_DEBUG "scsi%d: resetting bus\n", shpnt->host_no);
        SETPORT(SCSISEQ, SCSIRSTO);
        mdelay(256);
        SETPORT(SCSISEQ, 0);
        mdelay(DELAY);
-        DPRINTK(debug_eh, DEBUG_LEAD "bus resetted\n", CMDINFO(SCpnt));
+        DPRINTK(debug_eh, KERN_DEBUG "scsi%d: bus resetted\n", shpnt->host_no);
        setup_expected_interrupts(shpnt);
        if(HOSTDATA(shpnt)->commands==0)
@@ -1295,6 +1294,14 @@ static int aha152x_bus_reset(Scsi_Cmnd *SCpnt)
        return SUCCESS;
 }
+/*
+ * Reset the bus
+ *
+ */
+static int aha152x_bus_reset(Scsi_Cmnd *SCpnt)
+{
+        return aha152x_bus_reset_host(SCpnt->device->host);
+}
 /*
 *  Restore default values to the AIC-6260 registers and reset the fifos
@@ -1337,23 +1344,28 @@ static void reset_ports(struct Scsi_Host *shpnt)
 * Reset the host (bus and controller)
 *
 */
-int aha152x_host_reset(Scsi_Cmnd * SCpnt)
+int aha152x_host_reset_host(struct Scsi_Host *shpnt)
 {
-#if defined(AHA152X_DEBUG)
+        DPRINTK(debug_eh, KERN_DEBUG "scsi%d: host reset\n", shpnt->host_no);
-        struct Scsi_Host *shpnt = SCpnt->device->host;
-#endif
-        DPRINTK(debug_eh, DEBUG_LEAD "aha152x_host_reset(%p)\n", CMDINFO(SCpnt), SCpnt);
-        aha152x_bus_reset(SCpnt);
+        aha152x_bus_reset_host(shpnt);
-        DPRINTK(debug_eh, DEBUG_LEAD "resetting ports\n", CMDINFO(SCpnt));
+        DPRINTK(debug_eh, KERN_DEBUG "scsi%d: resetting ports\n", shpnt->host_no);
-        reset_ports(SCpnt->device->host);
+        reset_ports(shpnt);
        return SUCCESS;
 }
 /*
+ * Reset the host (bus and controller)
+ * 
+ */
+static int aha152x_host_reset(Scsi_Cmnd *SCpnt)
+{
+        return aha152x_host_reset_host(SCpnt->device->host);
+}
+/*
 * Return the "logical geometry"
 *
 */
@@ -1431,22 +1443,18 @@ static void run(void)
 {
        int i;
        for (i = 0; i<ARRAY_SIZE(aha152x_host); i++) {
-                struct Scsi_Host *shpnt = aha152x_host[i];
+                is_complete(aha152x_host[i]);
-                if (shpnt && HOSTDATA(shpnt)->service) {
-                        HOSTDATA(shpnt)->service=0;
-                        is_complete(shpnt);
-                }
        }
 }
 /*
- *    Interrupts handler
+ * Interrupt handler
 *
 */
 static irqreturn_t intr(int irqno, void *dev_id, struct pt_regs *regs)
 {
        struct Scsi_Host *shpnt = lookup_irq(irqno);
+        unsigned long flags;
        unsigned char rev, dmacntrl0;
        if (!shpnt) {
@@ -1472,23 +1480,23 @@ static irqreturn_t intr(int irqno, void *dev_id, struct pt_regs *regs)
        if ((rev == 0xFF) && (dmacntrl0 == 0xFF))
                return IRQ_NONE;
+        if( TESTLO(DMASTAT, INTSTAT) )
+                return IRQ_NONE;        
        /* no more interrupts from the controller, while we're busy.
           INTEN is restored by the BH handler */
        CLRBITS(DMACNTRL0, INTEN);
-#if 0
+        DO_LOCK(flags);
-        /* check if there is already something to be
+        if( HOSTDATA(shpnt)->service==0 ) {
-           serviced; should not happen */
+                HOSTDATA(shpnt)->service=1;
-        if(HOSTDATA(shpnt)->service) {
-                printk(KERN_ERR "aha152x%d: lost interrupt (%d)\n", HOSTNO, HOSTDATA(shpnt)->service);
+                /* Poke the BH handler */
-                show_queues(shpnt);
+                INIT_WORK(&aha152x_tq, (void *) run, NULL);
+                schedule_work(&aha152x_tq);
        }
-#endif
+        DO_UNLOCK(flags);
-        
-        /* Poke the BH handler */
-        HOSTDATA(shpnt)->service++;
-        INIT_WORK(&aha152x_tq, (void *) run, NULL);
-        schedule_work(&aha152x_tq);
        return IRQ_HANDLED;
 }
@@ -2527,7 +2535,18 @@ static void is_complete(struct Scsi_Host *shpnt)
        unsigned long flags;
        int pending;
+        if(!shpnt)
+                return;
        DO_LOCK(flags);
+        if( HOSTDATA(shpnt)->service==0 )  {
+                DO_UNLOCK(flags);
+                return;
+        }
+        HOSTDATA(shpnt)->service = 0;
        if(HOSTDATA(shpnt)->in_intr) {
                DO_UNLOCK(flags);
                /* aha152x_error never returns.. */
diff --git a/drivers/scsi/aha152x.h b/drivers/scsi/aha152x.h
index d277613af29b..d2add24d02a3 100644
--- a/drivers/scsi/aha152x.h
+++ b/drivers/scsi/aha152x.h
@@ -332,6 +332,6 @@ struct aha152x_setup {
 struct Scsi_Host *aha152x_probe_one(struct aha152x_setup *);
 void aha152x_release(struct Scsi_Host *);
-int aha152x_host_reset(Scsi_Cmnd *);
+int aha152x_host_reset_host(struct Scsi_Host *);
 #endif /* _AHA152X_H */
diff --git a/drivers/scsi/ahci.c b/drivers/scsi/ahci.c
index 19bd346951dd..559ff7aae3f1 100644
--- a/drivers/scsi/ahci.c
+++ b/drivers/scsi/ahci.c
@@ -286,6 +286,10 @@ static const struct pci_device_id ahci_pci_tbl[] = {
          board_ahci }, /* ICH8M */
        { PCI_VENDOR_ID_INTEL, 0x282a, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
          board_ahci }, /* ICH8M */
+        { 0x197b, 0x2360, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+          board_ahci }, /* JMicron JMB360 */
+        { 0x197b, 0x2363, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+          board_ahci }, /* JMicron JMB363 */
        { }     /* terminate list */
 };
@@ -738,23 +742,17 @@ static irqreturn_t ahci_interrupt (int irq, void *dev_instance, struct pt_regs *
                        struct ata_queued_cmd *qc;
                        qc = ata_qc_from_tag(ap, ap->active_tag);
                        if (!ahci_host_intr(ap, qc))
-                                if (ata_ratelimit()) {
+                                if (ata_ratelimit())
-                                        struct pci_dev *pdev =
+                                        dev_printk(KERN_WARNING, host_set->dev,
-                                                to_pci_dev(ap->host_set->dev);
-                                        dev_printk(KERN_WARNING, &pdev->dev,
                                          "unhandled interrupt on port %u\n",
                                          i);
-                                }
                        VPRINTK("port %u\n", i);
                } else {
                        VPRINTK("port %u (no irq)\n", i);
-                        if (ata_ratelimit()) {
+                        if (ata_ratelimit())
-                                struct pci_dev *pdev =
+                                dev_printk(KERN_WARNING, host_set->dev,
-                                        to_pci_dev(ap->host_set->dev);
-                                dev_printk(KERN_WARNING, &pdev->dev,
                                        "interrupt on disabled port %u\n", i);
-                        }
                }
                irq_ack |= (1 << i);
@@ -802,7 +800,6 @@ static int ahci_host_init(struct ata_probe_ent *probe_ent)
        struct pci_dev *pdev = to_pci_dev(probe_ent->dev);
        void __iomem *mmio = probe_ent->mmio_base;
        u32 tmp, cap_save;
-        u16 tmp16;
        unsigned int i, j, using_dac;
        int rc;
        void __iomem *port_mmio;
@@ -836,9 +833,13 @@ static int ahci_host_init(struct ata_probe_ent *probe_ent)
        writel(0xf, mmio + HOST_PORTS_IMPL);
        (void) readl(mmio + HOST_PORTS_IMPL);   /* flush */
-        pci_read_config_word(pdev, 0x92, &tmp16);
+        if (pdev->vendor == PCI_VENDOR_ID_INTEL) {
-        tmp16 |= 0xf;
+                u16 tmp16;
-        pci_write_config_word(pdev, 0x92, tmp16);
+                pci_read_config_word(pdev, 0x92, &tmp16);
+                tmp16 |= 0xf;
+                pci_write_config_word(pdev, 0x92, tmp16);
+        }
        hpriv->cap = readl(mmio + HOST_CAP);
        hpriv->port_map = readl(mmio + HOST_PORTS_IMPL);
@@ -1082,6 +1083,10 @@ static int ahci_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
        if (have_msi)
                hpriv->flags |= AHCI_FLAG_MSI;
+        /* JMicron-specific fixup: make sure we're in AHCI mode */
+        if (pdev->vendor == 0x197b)
+                pci_write_config_byte(pdev, 0x41, 0xa1);
        /* initialize adapter */
        rc = ahci_host_init(probe_ent);
        if (rc)
diff --git a/drivers/scsi/aic7xxx/Kconfig.aic79xx b/drivers/scsi/aic7xxx/Kconfig.aic79xx
index 69ed77fcb71f..7955ebe8e1e8 100644
--- a/drivers/scsi/aic7xxx/Kconfig.aic79xx
+++ b/drivers/scsi/aic7xxx/Kconfig.aic79xx
@@ -37,13 +37,13 @@ config AIC79XX_CMDS_PER_DEVICE
 config AIC79XX_RESET_DELAY_MS
        int "Initial bus reset delay in milli-seconds"
        depends on SCSI_AIC79XX
-        default "15000"
+        default "5000"
        ---help---
        The number of milliseconds to delay after an initial bus reset.
        The bus settle delay following all error recovery actions is
        dictated by the SCSI layer and is not affected by this value.
-        Default: 15000 (15 seconds)
+        Default: 5000 (5 seconds)
 config AIC79XX_BUILD_FIRMWARE
        bool "Build Adapter Firmware with Kernel Build"
diff --git a/drivers/scsi/aic7xxx/aic79xx.h b/drivers/scsi/aic7xxx/aic79xx.h
index 2cfdbef447db..1d11f7e77564 100644
--- a/drivers/scsi/aic7xxx/aic79xx.h
+++ b/drivers/scsi/aic7xxx/aic79xx.h
@@ -37,7 +37,7 @@
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 *
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx.h#108 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx.h#109 $
 *
 * $FreeBSD$
 */
@@ -222,6 +222,7 @@ typedef enum {
 typedef enum {
        AHD_FENONE              = 0x00000,
        AHD_WIDE                = 0x00001,/* Wide Channel */
+        AHD_AIC79XXB_SLOWCRC    = 0x00002,/* SLOWCRC bit should be set */
        AHD_MULTI_FUNC          = 0x00100,/* Multi-Function/Channel Device */
        AHD_TARGETMODE          = 0x01000,/* Has tested target mode support */
        AHD_MULTIROLE           = 0x02000,/* Space for two roles at a time */
diff --git a/drivers/scsi/aic7xxx/aic79xx.reg b/drivers/scsi/aic7xxx/aic79xx.reg
index 3a3204703b15..be14e2ecb8f7 100644
--- a/drivers/scsi/aic7xxx/aic79xx.reg
+++ b/drivers/scsi/aic7xxx/aic79xx.reg
@@ -1,7 +1,7 @@
 /*
 * Aic79xx register and scratch ram definitions.
 *
- * Copyright (c) 1994-2001 Justin T. Gibbs.
+ * Copyright (c) 1994-2001, 2004 Justin T. Gibbs.
 * Copyright (c) 2000-2002 Adaptec Inc.
 * All rights reserved.
 *
@@ -39,7 +39,7 @@
 *
 * $FreeBSD$
 */
-VERSION = "$Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#76 $"
+VERSION = "$Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#77 $"
 /*
 * This file is processed by the aic7xxx_asm utility for use in assembling
@@ -3715,8 +3715,9 @@ scratch_ram {
        SEQ_FLAGS2 {
                size            1
-                field   TARGET_MSG_PENDING        0x02
+                field   PENDING_MK_MESSAGE      0x01
-                field   SELECTOUT_QFROZEN         0x04
+                field   TARGET_MSG_PENDING      0x02
+                field   SELECTOUT_QFROZEN       0x04
        }
        ALLOCFIFO_SCBPTR {
@@ -3777,6 +3778,26 @@ scratch_ram {
        CMDSIZE_TABLE {
                size            8
        }
+        /*
+         * When an SCB with the MK_MESSAGE flag is
+         * queued to the controller, it cannot enter
+         * the waiting for selection list until the
+         * selections for any previously queued
+         * commands to that target complete.  During
+         * the wait, the MK_MESSAGE SCB is queued
+         * here.
+         */
+        MK_MESSAGE_SCB {
+                size            2
+        }
+        /*
+         * Saved SCSIID of MK_MESSAGE_SCB to avoid
+         * an extra SCBPTR operation when deciding
+         * if the MK_MESSAGE_SCB can be run.
+         */
+        MK_MESSAGE_SCSIID {
+                size            1
+        }
 }
 /************************* Hardware SCB Definition ****************************/
diff --git a/drivers/scsi/aic7xxx/aic79xx.seq b/drivers/scsi/aic7xxx/aic79xx.seq
index bef1f9d369b6..58bc17591b54 100644
--- a/drivers/scsi/aic7xxx/aic79xx.seq
+++ b/drivers/scsi/aic7xxx/aic79xx.seq
@@ -1,7 +1,7 @@
 /*
 * Adaptec U320 device driver firmware for Linux and FreeBSD.
 *
- * Copyright (c) 1994-2001 Justin T. Gibbs.
+ * Copyright (c) 1994-2001, 2004 Justin T. Gibbs.
 * Copyright (c) 2000-2002 Adaptec Inc.
 * All rights reserved.
 *
@@ -40,7 +40,7 @@
 * $FreeBSD$
 */
-VERSION = "$Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#119 $"
+VERSION = "$Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#120 $"
 PATCH_ARG_LIST = "struct ahd_softc *ahd"
 PREFIX = "ahd_"
@@ -110,10 +110,8 @@ check_waiting_list:
         * one last time.
         */
        test    SSTAT0, SELDO jnz select_out;
-END_CRITICAL;
        call    start_selection;
 idle_loop_checkbus:
-BEGIN_CRITICAL;
        test    SSTAT0, SELDO jnz select_out;
 END_CRITICAL;
        test    SSTAT0, SELDI jnz select_in;
@@ -294,7 +292,6 @@ fetch_new_scb_inprog:
        test    CCSCBCTL, ARRDONE jz return;
 fetch_new_scb_done:
        and     CCSCBCTL, ~(CCARREN|CCSCBEN);
-        bmov    REG0, SCBPTR, 2;
        clr     A;
        add     CMDS_PENDING, 1;
        adc     CMDS_PENDING[1], A;
@@ -316,43 +313,117 @@ fetch_new_scb_done:
        clr     SCB_FIFO_USE_COUNT;
        /* Update the next SCB address to download. */
        bmov    NEXT_QUEUED_SCB_ADDR, SCB_NEXT_SCB_BUSADDR, 4;
+        /*
+         * NULL out the SCB links since these fields
+         * occupy the same location as SCB_NEXT_SCB_BUSADDR.
+         */
        mvi     SCB_NEXT[1], SCB_LIST_NULL;
        mvi     SCB_NEXT2[1], SCB_LIST_NULL;
        /* Increment our position in the QINFIFO. */
        mov     NONE, SNSCB_QOFF;
        /*
-         * SCBs that want to send messages are always
+         * Save SCBID of this SCB in REG0 since
-         * queued independently.  This ensures that they
+         * SCBPTR will be clobbered during target
-         * are at the head of the SCB list to select out
+         * list updates.  We also record the SCB's
-         * to a target and we will see the MK_MESSAGE flag.
+         * flags so that we can refer to them even
+         * after SCBPTR has been changed.
+         */
+        bmov    REG0, SCBPTR, 2;
+        mov     A, SCB_CONTROL;
+        /*
+         * Find the tail SCB of the execution queue
+         * for this target.
         */
-        test    SCB_CONTROL, MK_MESSAGE jnz first_new_target_scb;
        shr     SINDEX, 3, SCB_SCSIID;
        and     SINDEX, ~0x1;
        mvi     SINDEX[1], (WAITING_SCB_TAILS >> 8);
        bmov    DINDEX, SINDEX, 2;
        bmov    SCBPTR, SINDIR, 2;
+        /*
+         * Update the tail to point to the new SCB.
+         */
        bmov    DINDIR, REG0, 2;
+        /*
+         * If the queue was empty, queue this SCB as
+         * the first for this target.
+         */
        cmp     SCBPTR[1], SCB_LIST_NULL je first_new_target_scb;
+        /*
+         * SCBs that want to send messages must always be
+         * at the head of their per-target queue so that
+         * ATN can be asserted even if the current
+         * negotiation agreement is packetized.  If the
+         * target queue is empty, the SCB can be queued
+         * immediately.  If the queue is not empty, we must
+         * wait for it to empty before entering this SCB
+         * into the waiting for selection queue.  Otherwise
+         * our batching and round-robin selection scheme 
+         * could allow commands to be queued out of order.
+         * To simplify the implementation, we stop pulling
+         * new commands from the host until the MK_MESSAGE
+         * SCB can be queued to the waiting for selection
+         * list.
+         */
+        test    A, MK_MESSAGE jz batch_scb; 
+        /*
+         * If the last SCB is also a MK_MESSAGE SCB, then
+         * order is preserved even if we batch.
+         */
+        test    SCB_CONTROL, MK_MESSAGE jz batch_scb; 
+        /*
+         * Defer this SCB and stop fetching new SCBs until
+         * it can be queued.  Since the SCB_SCSIID of the
+         * tail SCB must be the same as that of the newly
+         * queued SCB, there is no need to restore the SCBID
+         * here.
+         */
+        or      SEQ_FLAGS2, PENDING_MK_MESSAGE;
+        bmov    MK_MESSAGE_SCB, REG0, 2;
+        mov     MK_MESSAGE_SCSIID, SCB_SCSIID ret;
+batch_scb:
+        /*
+         * Otherwise just update the previous tail SCB to
+         * point to the new tail.
+         */
        bmov    SCB_NEXT, REG0, 2 ret;
 first_new_target_scb:
+        /*
+         * Append SCB to the tail of the waiting for
+         * selection list.
+         */
        cmp     WAITING_TID_HEAD[1], SCB_LIST_NULL je first_new_scb;
        bmov    SCBPTR, WAITING_TID_TAIL, 2;
        bmov    SCB_NEXT2, REG0, 2;
        bmov    WAITING_TID_TAIL, REG0, 2 ret;
 first_new_scb:
+        /*
+         * Whole list is empty, so the head of
+         * the list must be initialized too.
+         */
        bmov    WAITING_TID_HEAD, REG0, 2;
        bmov    WAITING_TID_TAIL, REG0, 2 ret;
 END_CRITICAL;
 scbdma_idle:
        /*
-         * Give precedence to downloading new SCBs to execute
+         * Don't bother downloading new SCBs to execute
-         * unless select-outs are currently frozen.
+         * if select-outs are currently frozen or we have
+         * a MK_MESSAGE SCB waiting to enter the queue.
         */
-        test    SEQ_FLAGS2, SELECTOUT_QFROZEN jnz . + 2;
+        test    SEQ_FLAGS2, SELECTOUT_QFROZEN|PENDING_MK_MESSAGE
+                jnz scbdma_no_new_scbs;
 BEGIN_CRITICAL;
        test    QOFF_CTLSTA, NEW_SCB_AVAIL jnz fetch_new_scb;
+scbdma_no_new_scbs:
        cmp     COMPLETE_DMA_SCB_HEAD[1], SCB_LIST_NULL jne dma_complete_scb;
        cmp     COMPLETE_SCB_HEAD[1], SCB_LIST_NULL je return;
        /* FALLTHROUGH */
@@ -671,27 +742,41 @@ curscb_ww_done:
        }
        /*
-         * Requeue any SCBs not sent, to the tail of the waiting Q.
+         * The whole list made it.  Clear our tail pointer to indicate
+         * that the per-target selection queue is now empty.
         */
-        cmp     SCB_NEXT[1], SCB_LIST_NULL je select_out_list_done;
+        cmp     SCB_NEXT[1], SCB_LIST_NULL je select_out_clear_tail;
        /*
+         * Requeue any SCBs not sent, to the tail of the waiting Q.
         * We know that neither the per-TID list nor the list of
-         * TIDs is empty.  Use this knowledge to our advantage.
+         * TIDs is empty.  Use this knowledge to our advantage and
+         * queue the remainder to the tail of the global execution
+         * queue.
         */
        bmov    REG0, SCB_NEXT, 2;
+select_out_queue_remainder:
        bmov    SCBPTR, WAITING_TID_TAIL, 2;
        bmov    SCB_NEXT2, REG0, 2;
        bmov    WAITING_TID_TAIL, REG0, 2;
        jmp     select_out_inc_tid_q;
-select_out_list_done:
+select_out_clear_tail:
+        /*
+         * Queue any pending MK_MESSAGE SCB for this target now
+         * that the queue is empty.
+         */
+        test    SEQ_FLAGS2, PENDING_MK_MESSAGE jz select_out_no_mk_message_scb;
+        mov     A, MK_MESSAGE_SCSIID;
+        cmp     SCB_SCSIID, A jne select_out_no_mk_message_scb;
+        and     SEQ_FLAGS2, ~PENDING_MK_MESSAGE;
+        bmov    REG0, MK_MESSAGE_SCB, 2;
+        jmp select_out_queue_remainder;
+select_out_no_mk_message_scb:
        /*
-         * The whole list made it.  Just clear our TID's tail pointer
+         * Clear this target's execution tail and increment the queue.
-         * unless we were queued independently due to our need to
-         * send a message.
         */
-        test    SCB_CONTROL, MK_MESSAGE jnz select_out_inc_tid_q;
        shr     DINDEX, 3, SCB_SCSIID;
        or      DINDEX, 1;      /* Want only the second byte */
        mvi     DINDEX[1], ((WAITING_SCB_TAILS) >> 8);
@@ -703,8 +788,8 @@ select_out_inc_tid_q:
        mvi     WAITING_TID_TAIL[1], SCB_LIST_NULL;
        bmov    SCBPTR, CURRSCB, 2;
        mvi     CLRSINT0, CLRSELDO;
-        test    LQOSTAT2, LQOPHACHGOUTPKT jnz unexpected_nonpkt_phase;
+        test    LQOSTAT2, LQOPHACHGOUTPKT jnz unexpected_nonpkt_mode_cleared;
-        test    LQOSTAT1, LQOPHACHGINPKT jnz unexpected_nonpkt_phase;
+        test    LQOSTAT1, LQOPHACHGINPKT jnz unexpected_nonpkt_mode_cleared;
        /*
         * If this is a packetized connection, return to our
@@ -2127,6 +2212,18 @@ SET_DST_MODE	M_DFF0;
        mvi     DFFSXFRCTL, CLRCHN;
 unexpected_nonpkt_mode_cleared:
        mvi     CLRSINT2, CLRNONPACKREQ;
+        if ((ahd->bugs & AHD_BUSFREEREV_BUG) != 0) {
+                /*
+                 * Test to ensure that the bus has not
+                 * already gone free prior to clearing
+                 * any stale busfree status.  This avoids
+                 * a window whereby a busfree just after
+                 * a selection could be missed.
+                 */
+                test    SCSISIGI, BSYI jz . + 2;
+                mvi     CLRSINT1,CLRBUSFREE;
+                or      SIMODE1, ENBUSFREE;
+        }
        test    SCSIPHASE, ~(MSG_IN_PHASE|MSG_OUT_PHASE) jnz illegal_phase;
        SET_SEQINTCODE(ENTERING_NONPACK)
        jmp     ITloop;
diff --git a/drivers/scsi/aic7xxx/aic79xx_core.c b/drivers/scsi/aic7xxx/aic79xx_core.c
index db8f5ce99ee3..342f77966a5b 100644
--- a/drivers/scsi/aic7xxx/aic79xx_core.c
+++ b/drivers/scsi/aic7xxx/aic79xx_core.c
@@ -37,7 +37,7 @@
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 *
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx.c#247 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx.c#250 $
 */
 #ifdef __linux__
@@ -197,7 +197,8 @@ static int		ahd_search_scb_list(struct ahd_softc *ahd, int target,
                                            char channel, int lun, u_int tag,
                                            role_t role, uint32_t status,
                                            ahd_search_action action,
-                                            u_int *list_head, u_int tid);
+                                            u_int *list_head, u_int *list_tail,
+                                            u_int tid);
 static void             ahd_stitch_tid_list(struct ahd_softc *ahd,
                                            u_int tid_prev, u_int tid_cur,
                                            u_int tid_next);
@@ -1660,7 +1661,8 @@ ahd_handle_scsiint(struct ahd_softc *ahd, u_int intstat)
                 * so just clear the error.
                 */
                ahd_outb(ahd, CLRLQIINT1, CLRLQICRCI_NLQ);
-        } else if ((status & BUSFREE) != 0) {
+        } else if ((status & BUSFREE) != 0
+                || (lqistat1 & LQOBUSFREE) != 0) {
                u_int lqostat1;
                int   restart;
                int   clear_fifo;
@@ -2025,10 +2027,6 @@ ahd_handle_pkt_busfree(struct ahd_softc *ahd, u_int busfreetime)
                u_int waiting_t;
                u_int next;
-                if ((busfreetime & BUSFREE_LQO) == 0)
-                        printf("%s: Warning, BUSFREE time is 0x%x.  "
-                               "Expected BUSFREE_LQO.\n",
-                               ahd_name(ahd), busfreetime);
                /*
                 * The LQO manager detected an unexpected busfree
                 * either:
@@ -2251,8 +2249,14 @@ ahd_handle_nonpkt_busfree(struct ahd_softc *ahd)
                        struct ahd_tmode_tstate *tstate;
                        /*
-                         * PPR Rejected.  Try non-ppr negotiation
+                         * PPR Rejected.
-                         * and retry command.
+                         *
+                         * If the previous negotiation was packetized,
+                         * this could be because the device has been
+                         * reset without our knowledge.  Force our
+                         * current negotiation to async and retry the
+                         * negotiation.  Otherwise retry the command
+                         * with non-ppr negotiation.
                         */
 #ifdef AHD_DEBUG
                        if ((ahd_debug & AHD_SHOW_MESSAGES) != 0)
@@ -2261,11 +2265,34 @@ ahd_handle_nonpkt_busfree(struct ahd_softc *ahd)
                        tinfo = ahd_fetch_transinfo(ahd, devinfo.channel,
                                                    devinfo.our_scsiid,
                                                    devinfo.target, &tstate);
-                        tinfo->curr.transport_version = 2;
+                        if ((tinfo->curr.ppr_options & MSG_EXT_PPR_IU_REQ)!=0) {
-                        tinfo->goal.transport_version = 2;
+                                ahd_set_width(ahd, &devinfo,
-                        tinfo->goal.ppr_options = 0;
+                                              MSG_EXT_WDTR_BUS_8_BIT,
-                        ahd_qinfifo_requeue_tail(ahd, scb);
+                                              AHD_TRANS_CUR,
-                        printerror = 0;
+                                              /*paused*/TRUE);
+                                ahd_set_syncrate(ahd, &devinfo,
+                                                /*period*/0, /*offset*/0,
+                                                /*ppr_options*/0,
+                                                AHD_TRANS_CUR,
+                                                /*paused*/TRUE);
+                                /*
+                                 * The expect PPR busfree handler below
+                                 * will effect the retry and necessary
+                                 * abort.
+                                 */
+                        } else {
+                                tinfo->curr.transport_version = 2;
+                                tinfo->goal.transport_version = 2;
+                                tinfo->goal.ppr_options = 0;
+                                /*
+                                 * Remove any SCBs in the waiting for selection
+                                 * queue that may also be for this target so
+                                 * that command ordering is preserved.
+                                 */
+                                ahd_freeze_devq(ahd, scb);
+                                ahd_qinfifo_requeue_tail(ahd, scb);
+                                printerror = 0;
+                        }
                } else if (ahd_sent_msg(ahd, AHDMSG_EXT, MSG_EXT_WDTR, FALSE)
                        && ppr_busfree == 0) {
                        /*
@@ -2280,6 +2307,12 @@ ahd_handle_nonpkt_busfree(struct ahd_softc *ahd)
                                      MSG_EXT_WDTR_BUS_8_BIT,
                                      AHD_TRANS_CUR|AHD_TRANS_GOAL,
                                      /*paused*/TRUE);
+                        /*
+                         * Remove any SCBs in the waiting for selection
+                         * queue that may also be for this target so that
+                         * command ordering is preserved.
+                         */
+                        ahd_freeze_devq(ahd, scb);
                        ahd_qinfifo_requeue_tail(ahd, scb);
                        printerror = 0;
                } else if (ahd_sent_msg(ahd, AHDMSG_EXT, MSG_EXT_SDTR, FALSE)
@@ -2297,6 +2330,12 @@ ahd_handle_nonpkt_busfree(struct ahd_softc *ahd)
                                        /*ppr_options*/0,
                                        AHD_TRANS_CUR|AHD_TRANS_GOAL,
                                        /*paused*/TRUE);
+                        /*
+                         * Remove any SCBs in the waiting for selection
+                         * queue that may also be for this target so that
+                         * command ordering is preserved.
+                         */
+                        ahd_freeze_devq(ahd, scb);
                        ahd_qinfifo_requeue_tail(ahd, scb);
                        printerror = 0;
                } else if ((ahd->msg_flags & MSG_FLAG_EXPECT_IDE_BUSFREE) != 0
@@ -2369,14 +2408,14 @@ ahd_handle_nonpkt_busfree(struct ahd_softc *ahd)
                         */
                        printf("%s: ", ahd_name(ahd));
                }
-                if (lastphase != P_BUSFREE)
-                        ahd_force_renegotiation(ahd, &devinfo);
                printf("Unexpected busfree %s, %d SCBs aborted, "
                       "PRGMCNT == 0x%x\n",
                       ahd_lookup_phase_entry(lastphase)->phasemsg,
                       aborted,
                       ahd_inw(ahd, PRGMCNT));
                ahd_dump_card_state(ahd);
+                if (lastphase != P_BUSFREE)
+                        ahd_force_renegotiation(ahd, &devinfo);
        }
        /* Always restart the sequencer. */
        return (1);
@@ -3293,6 +3332,15 @@ ahd_update_neg_table(struct ahd_softc *ahd, struct ahd_devinfo *devinfo,
                con_opts |= WIDEXFER;
        /*
+         * Slow down our CRC interval to be
+         * compatible with packetized U320 devices
+         * that can't handle a CRC at full speed
+         */
+        if (ahd->features & AHD_AIC79XXB_SLOWCRC) {
+                con_opts |= ENSLOWCRC;
+        }
+        /*
         * During packetized transfers, the target will
         * give us the oportunity to send command packets
         * without us asserting attention.
@@ -3315,7 +3363,6 @@ ahd_update_pending_scbs(struct ahd_softc *ahd)
 {
        struct          scb *pending_scb;
        int             pending_scb_count;
-        u_int           scb_tag;
        int             paused;
        u_int           saved_scbptr;
        ahd_mode_state  saved_modes;
@@ -3333,7 +3380,6 @@ ahd_update_pending_scbs(struct ahd_softc *ahd)
        pending_scb_count = 0;
        LIST_FOREACH(pending_scb, &ahd->pending_scbs, pending_links) {
                struct ahd_devinfo devinfo;
-                struct hardware_scb *pending_hscb;
                struct ahd_initiator_tinfo *tinfo;
                struct ahd_tmode_tstate *tstate;
@@ -3341,11 +3387,10 @@ ahd_update_pending_scbs(struct ahd_softc *ahd)
                tinfo = ahd_fetch_transinfo(ahd, devinfo.channel,
                                            devinfo.our_scsiid,
                                            devinfo.target, &tstate);
-                pending_hscb = pending_scb->hscb;
                if ((tstate->auto_negotiate & devinfo.target_mask) == 0
                 && (pending_scb->flags & SCB_AUTO_NEGOTIATE) != 0) {
                        pending_scb->flags &= ~SCB_AUTO_NEGOTIATE;
-                        pending_hscb->control &= ~MK_MESSAGE;
+                        pending_scb->hscb->control &= ~MK_MESSAGE;
                }
                ahd_sync_scb(ahd, pending_scb,
                             BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
@@ -3377,18 +3422,15 @@ ahd_update_pending_scbs(struct ahd_softc *ahd)
                ahd_outb(ahd, SCSISEQ0, ahd_inb(ahd, SCSISEQ0) & ~ENSELO);
        saved_scbptr = ahd_get_scbptr(ahd);
        /* Ensure that the hscbs down on the card match the new information */
-        for (scb_tag = 0; scb_tag < ahd->scb_data.maxhscbs; scb_tag++) {
+        LIST_FOREACH(pending_scb, &ahd->pending_scbs, pending_links) {
-                struct  hardware_scb *pending_hscb;
+                u_int   scb_tag;
                u_int   control;
-                pending_scb = ahd_lookup_scb(ahd, scb_tag);
+                scb_tag = SCB_GET_TAG(pending_scb);
-                if (pending_scb == NULL)
-                        continue;
                ahd_set_scbptr(ahd, scb_tag);
-                pending_hscb = pending_scb->hscb;
                control = ahd_inb_scbram(ahd, SCB_CONTROL);
                control &= ~MK_MESSAGE;
-                control |= pending_hscb->control & MK_MESSAGE;
+                control |= pending_scb->hscb->control & MK_MESSAGE;
                ahd_outb(ahd, SCB_CONTROL, control);
        }
        ahd_set_scbptr(ahd, saved_scbptr);
@@ -6500,13 +6542,14 @@ ahd_chip_init(struct ahd_softc *ahd)
                              | ENLQIOVERI_LQ|ENLQIOVERI_NLQ);
        ahd_outb(ahd, LQOMODE0, ENLQOATNLQ|ENLQOATNPKT|ENLQOTCRC);
        /*
-         * An interrupt from LQOBUSFREE is made redundant by the
+         * We choose to have the sequencer catch LQOPHCHGINPKT errors
-         * BUSFREE interrupt.  We choose to have the sequencer catch
+         * manually for the command phase at the start of a packetized
-         * LQOPHCHGINPKT errors manually for the command phase at the
+         * selection case.  ENLQOBUSFREE should be made redundant by
-         * start of a packetized selection case.
+         * the BUSFREE interrupt, but it seems that some LQOBUSFREE
-        ahd_outb(ahd, LQOMODE1, ENLQOBUSFREE|ENLQOPHACHGINPKT);
+         * events fail to assert the BUSFREE interrupt so we must
+         * also enable LQOBUSFREE interrupts.
         */
-        ahd_outb(ahd, LQOMODE1, 0);
+        ahd_outb(ahd, LQOMODE1, ENLQOBUSFREE);
        /*
         * Setup sequencer interrupt handlers.
@@ -6617,6 +6660,8 @@ ahd_chip_init(struct ahd_softc *ahd)
        /* We don't have any waiting selections */
        ahd_outw(ahd, WAITING_TID_HEAD, SCB_LIST_NULL);
        ahd_outw(ahd, WAITING_TID_TAIL, SCB_LIST_NULL);
+        ahd_outw(ahd, MK_MESSAGE_SCB, SCB_LIST_NULL);
+        ahd_outw(ahd, MK_MESSAGE_SCSIID, 0xFF);
        for (i = 0; i < AHD_NUM_TARGETS; i++)
                ahd_outw(ahd, WAITING_SCB_TAILS + (2 * i), SCB_LIST_NULL);
@@ -6704,6 +6749,18 @@ ahd_chip_init(struct ahd_softc *ahd)
        ahd_loadseq(ahd);
        ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
+        if (ahd->features & AHD_AIC79XXB_SLOWCRC) {
+                u_int negodat3 = ahd_inb(ahd, NEGCONOPTS);
+                negodat3 |= ENSLOWCRC;
+                ahd_outb(ahd, NEGCONOPTS, negodat3);
+                negodat3 = ahd_inb(ahd, NEGCONOPTS);
+                if (!(negodat3 & ENSLOWCRC))
+                        printf("aic79xx: failed to set the SLOWCRC bit\n");
+                else
+                        printf("aic79xx: SLOWCRC bit set\n");
+        }
 }
 /*
@@ -7260,12 +7317,28 @@ ahd_reset_cmds_pending(struct ahd_softc *ahd)
        ahd->flags &= ~AHD_UPDATE_PEND_CMDS;
 }
+void
+ahd_done_with_status(struct ahd_softc *ahd, struct scb *scb, uint32_t status)
+{
+        cam_status ostat;
+        cam_status cstat;
+        ostat = ahd_get_transaction_status(scb);
+        if (ostat == CAM_REQ_INPROG)
+                ahd_set_transaction_status(scb, status);
+        cstat = ahd_get_transaction_status(scb);
+        if (cstat != CAM_REQ_CMP)
+                ahd_freeze_scb(scb);
+        ahd_done(ahd, scb);
+}
 int
 ahd_search_qinfifo(struct ahd_softc *ahd, int target, char channel,
                   int lun, u_int tag, role_t role, uint32_t status,
                   ahd_search_action action)
 {
        struct scb      *scb;
+        struct scb      *mk_msg_scb;
        struct scb      *prev_scb;
        ahd_mode_state   saved_modes;
        u_int            qinstart;
@@ -7274,6 +7347,7 @@ ahd_search_qinfifo(struct ahd_softc *ahd, int target, char channel,
        u_int            tid_next;
        u_int            tid_prev;
        u_int            scbid;
+        u_int            seq_flags2;
        u_int            savedscbptr;
        uint32_t         busaddr;
        int              found;
@@ -7329,23 +7403,10 @@ ahd_search_qinfifo(struct ahd_softc *ahd, int target, char channel,
                        found++;
                        switch (action) {
                        case SEARCH_COMPLETE:
-                        {
-                                cam_status ostat;
-                                cam_status cstat;
-                                ostat = ahd_get_transaction_status(scb);
-                                if (ostat == CAM_REQ_INPROG)
-                                        ahd_set_transaction_status(scb,
-                                                                   status);
-                                cstat = ahd_get_transaction_status(scb);
-                                if (cstat != CAM_REQ_CMP)
-                                        ahd_freeze_scb(scb);
                                if ((scb->flags & SCB_ACTIVE) == 0)
                                        printf("Inactive SCB in qinfifo\n");
-                                ahd_done(ahd, scb);
+                                ahd_done_with_status(ahd, scb, status);
                                /* FALLTHROUGH */
-                        }
                        case SEARCH_REMOVE:
                                break;
                        case SEARCH_PRINT:
@@ -7375,21 +7436,24 @@ ahd_search_qinfifo(struct ahd_softc *ahd, int target, char channel,
         * looking for matches.
         */
        ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
+        seq_flags2 = ahd_inb(ahd, SEQ_FLAGS2);
+        if ((seq_flags2 & PENDING_MK_MESSAGE) != 0) {
+                scbid = ahd_inw(ahd, MK_MESSAGE_SCB);
+                mk_msg_scb = ahd_lookup_scb(ahd, scbid);
+        } else
+                mk_msg_scb = NULL;
        savedscbptr = ahd_get_scbptr(ahd);
        tid_next = ahd_inw(ahd, WAITING_TID_HEAD);
        tid_prev = SCB_LIST_NULL;
        targets = 0;
        for (scbid = tid_next; !SCBID_IS_NULL(scbid); scbid = tid_next) {
                u_int tid_head;
+                u_int tid_tail;
-                /*
-                 * We limit based on the number of SCBs since
-                 * MK_MESSAGE SCBs are not in the per-tid lists.
-                 */
                targets++;
-                if (targets > AHD_SCB_MAX) {
+                if (targets > AHD_NUM_TARGETS)
                        panic("TID LIST LOOP");
-                }
                if (scbid >= ahd->scb_data.numscbs) {
                        printf("%s: Waiting TID List inconsistency. "
                               "SCB index == 0x%x, yet numscbs == 0x%x.",
@@ -7419,8 +7483,71 @@ ahd_search_qinfifo(struct ahd_softc *ahd, int target, char channel,
                tid_head = scbid;
                found += ahd_search_scb_list(ahd, target, channel,
                                             lun, tag, role, status,
-                                             action, &tid_head,
+                                             action, &tid_head, &tid_tail,
                                             SCB_GET_TARGET(ahd, scb));
+                /*
+                 * Check any MK_MESSAGE SCB that is still waiting to
+                 * enter this target's waiting for selection queue.
+                 */
+                if (mk_msg_scb != NULL
+                 && ahd_match_scb(ahd, mk_msg_scb, target, channel,
+                                  lun, tag, role)) {
+                        /*
+                         * We found an scb that needs to be acted on.
+                         */
+                        found++;
+                        switch (action) {
+                        case SEARCH_COMPLETE:
+                                if ((mk_msg_scb->flags & SCB_ACTIVE) == 0)
+                                        printf("Inactive SCB pending MK_MSG\n");
+                                ahd_done_with_status(ahd, mk_msg_scb, status);
+                                /* FALLTHROUGH */
+                        case SEARCH_REMOVE:
+                        {
+                                u_int tail_offset;
+                                printf("Removing MK_MSG scb\n");
+                                /*
+                                 * Reset our tail to the tail of the
+                                 * main per-target list.
+                                 */
+                                tail_offset = WAITING_SCB_TAILS
+                                    + (2 * SCB_GET_TARGET(ahd, mk_msg_scb));
+                                ahd_outw(ahd, tail_offset, tid_tail);
+                                seq_flags2 &= ~PENDING_MK_MESSAGE;
+                                ahd_outb(ahd, SEQ_FLAGS2, seq_flags2);
+                                ahd_outw(ahd, CMDS_PENDING,
+                                         ahd_inw(ahd, CMDS_PENDING)-1);
+                                mk_msg_scb = NULL;
+                                break;
+                        }
+                        case SEARCH_PRINT:
+                                printf(" 0x%x", SCB_GET_TAG(scb));
+                                /* FALLTHROUGH */
+                        case SEARCH_COUNT:
+                                break;
+                        }
+                }
+                if (mk_msg_scb != NULL
+                 && SCBID_IS_NULL(tid_head)
+                 && ahd_match_scb(ahd, scb, target, channel, CAM_LUN_WILDCARD,
+                                  SCB_LIST_NULL, ROLE_UNKNOWN)) {
+                        /*
+                         * When removing the last SCB for a target
+                         * queue with a pending MK_MESSAGE scb, we
+                         * must queue the MK_MESSAGE scb.
+                         */
+                        printf("Queueing mk_msg_scb\n");
+                        tid_head = ahd_inw(ahd, MK_MESSAGE_SCB);
+                        seq_flags2 &= ~PENDING_MK_MESSAGE;
+                        ahd_outb(ahd, SEQ_FLAGS2, seq_flags2);
+                        mk_msg_scb = NULL;
+                }
                if (tid_head != scbid)
                        ahd_stitch_tid_list(ahd, tid_prev, tid_head, tid_next);
                if (!SCBID_IS_NULL(tid_head))
@@ -7428,6 +7555,8 @@ ahd_search_qinfifo(struct ahd_softc *ahd, int target, char channel,
                if (action == SEARCH_PRINT)
                        printf(")\n");
        }
+        /* Restore saved state. */
        ahd_set_scbptr(ahd, savedscbptr);
        ahd_restore_modes(ahd, saved_modes);
        return (found);
@@ -7436,7 +7565,8 @@ ahd_search_qinfifo(struct ahd_softc *ahd, int target, char channel,
 static int
 ahd_search_scb_list(struct ahd_softc *ahd, int target, char channel,
                    int lun, u_int tag, role_t role, uint32_t status,
-                    ahd_search_action action, u_int *list_head, u_int tid)
+                    ahd_search_action action, u_int *list_head, 
+                    u_int *list_tail, u_int tid)
 {
        struct  scb *scb;
        u_int   scbid;
@@ -7448,6 +7578,7 @@ ahd_search_scb_list(struct ahd_softc *ahd, int target, char channel,
        found = 0;
        prev = SCB_LIST_NULL;
        next = *list_head;
+        *list_tail = SCB_LIST_NULL;
        for (scbid = next; !SCBID_IS_NULL(scbid); scbid = next) {
                if (scbid >= ahd->scb_data.numscbs) {
                        printf("%s:SCB List inconsistency. "
@@ -7463,6 +7594,7 @@ ahd_search_scb_list(struct ahd_softc *ahd, int target, char channel,
                        panic("Waiting List traversal\n");
                }
                ahd_set_scbptr(ahd, scbid);
+                *list_tail = scbid;
                next = ahd_inw_scbram(ahd, SCB_NEXT);
                if (ahd_match_scb(ahd, scb, target, channel,
                                  lun, SCB_LIST_NULL, role) == 0) {
@@ -7472,24 +7604,14 @@ ahd_search_scb_list(struct ahd_softc *ahd, int target, char channel,
                found++;
                switch (action) {
                case SEARCH_COMPLETE:
-                {
-                        cam_status ostat;
-                        cam_status cstat;
-                        ostat = ahd_get_transaction_status(scb);
-                        if (ostat == CAM_REQ_INPROG)
-                                ahd_set_transaction_status(scb, status);
-                        cstat = ahd_get_transaction_status(scb);
-                        if (cstat != CAM_REQ_CMP)
-                                ahd_freeze_scb(scb);
                        if ((scb->flags & SCB_ACTIVE) == 0)
                                printf("Inactive SCB in Waiting List\n");
-                        ahd_done(ahd, scb);
+                        ahd_done_with_status(ahd, scb, status);
                        /* FALLTHROUGH */
-                }
                case SEARCH_REMOVE:
                        ahd_rem_wscb(ahd, scbid, prev, next, tid);
-                        if (prev == SCB_LIST_NULL)
+                        *list_tail = prev;
+                        if (SCBID_IS_NULL(prev))
                                *list_head = next;
                        break;
                case SEARCH_PRINT:
@@ -7558,14 +7680,17 @@ ahd_rem_wscb(struct ahd_softc *ahd, u_int scbid,
        }
        /*
-         * SCBs that had MK_MESSAGE set in them will not
+         * SCBs that have MK_MESSAGE set in them may
-         * be queued to the per-target lists, so don't
+         * cause the tail pointer to be updated without
-         * blindly clear the tail pointer.
+         * setting the next pointer of the previous tail.
+         * Only clear the tail if the removed SCB was
+         * the tail.
         */
        tail_offset = WAITING_SCB_TAILS + (2 * tid);
        if (SCBID_IS_NULL(next)
         && ahd_inw(ahd, tail_offset) == scbid)
                ahd_outw(ahd, tail_offset, prev);
        ahd_add_scb_to_free_list(ahd, scbid);
        return (next);
 }
@@ -8148,11 +8273,6 @@ ahd_handle_scsi_status(struct ahd_softc *ahd, struct scb *scb)
                ahd_setup_data_scb(ahd, scb);
                scb->flags |= SCB_SENSE;
                ahd_queue_scb(ahd, scb);
-                /*
-                 * Ensure we have enough time to actually
-                 * retrieve the sense.
-                 */
-                ahd_scb_timer_reset(scb, 5 * 1000000);
                break;
        }
        case SCSI_STATUS_OK:
@@ -8793,6 +8913,9 @@ ahd_dump_card_state(struct ahd_softc *ahd)
         * Mode independent registers.
         */
        cur_col = 0;
+        ahd_intstat_print(ahd_inb(ahd, INTSTAT), &cur_col, 50);
+        ahd_seloid_print(ahd_inb(ahd, SELOID), &cur_col, 50);
+        ahd_selid_print(ahd_inb(ahd, SELID), &cur_col, 50);
        ahd_hs_mailbox_print(ahd_inb(ahd, LOCAL_HS_MAILBOX), &cur_col, 50);
        ahd_intctl_print(ahd_inb(ahd, INTCTL), &cur_col, 50);
        ahd_seqintstat_print(ahd_inb(ahd, SEQINTSTAT), &cur_col, 50);
@@ -8808,6 +8931,12 @@ ahd_dump_card_state(struct ahd_softc *ahd)
        ahd_seqintctl_print(ahd_inb(ahd, SEQINTCTL), &cur_col, 50);
        ahd_seq_flags_print(ahd_inb(ahd, SEQ_FLAGS), &cur_col, 50);
        ahd_seq_flags2_print(ahd_inb(ahd, SEQ_FLAGS2), &cur_col, 50);
+        ahd_qfreeze_count_print(ahd_inw(ahd, QFREEZE_COUNT), &cur_col, 50);
+        ahd_kernel_qfreeze_count_print(ahd_inw(ahd, KERNEL_QFREEZE_COUNT),
+                                       &cur_col, 50);
+        ahd_mk_message_scb_print(ahd_inw(ahd, MK_MESSAGE_SCB), &cur_col, 50);
+        ahd_mk_message_scsiid_print(ahd_inb(ahd, MK_MESSAGE_SCSIID),
+                                    &cur_col, 50);
        ahd_sstat0_print(ahd_inb(ahd, SSTAT0), &cur_col, 50);
        ahd_sstat1_print(ahd_inb(ahd, SSTAT1), &cur_col, 50);
        ahd_sstat2_print(ahd_inb(ahd, SSTAT2), &cur_col, 50);
@@ -8915,7 +9044,7 @@ ahd_dump_card_state(struct ahd_softc *ahd)
                ahd_set_modes(ahd, AHD_MODE_DFF0 + i, AHD_MODE_DFF0 + i);
                fifo_scbptr = ahd_get_scbptr(ahd);
-                printf("\n%s: FIFO%d %s, LONGJMP == 0x%x, SCB 0x%x\n",
+                printf("\n\n%s: FIFO%d %s, LONGJMP == 0x%x, SCB 0x%x\n",
                       ahd_name(ahd), i,
                       (dffstat & (FIFO0FREE << i)) ? "Free" : "Active",
                       ahd_inw(ahd, LONGJMP_ADDR), fifo_scbptr);
@@ -8970,6 +9099,9 @@ ahd_dump_card_state(struct ahd_softc *ahd)
        printf("%s: OS_SPACE_CNT = 0x%x MAXCMDCNT = 0x%x\n",
               ahd_name(ahd), ahd_inb(ahd, OS_SPACE_CNT),
               ahd_inb(ahd, MAXCMDCNT));
+        printf("%s: SAVED_SCSIID = 0x%x SAVED_LUN = 0x%x\n",
+               ahd_name(ahd), ahd_inb(ahd, SAVED_SCSIID),
+               ahd_inb(ahd, SAVED_LUN));
        ahd_simode0_print(ahd_inb(ahd, SIMODE0), &cur_col, 50);
        printf("\n");
        ahd_set_modes(ahd, AHD_MODE_CCHAN, AHD_MODE_CCHAN);
diff --git a/drivers/scsi/aic7xxx/aic79xx_inline.h b/drivers/scsi/aic7xxx/aic79xx_inline.h
index 91c4f7f484b1..8ad3ce945b9e 100644
--- a/drivers/scsi/aic7xxx/aic79xx_inline.h
+++ b/drivers/scsi/aic7xxx/aic79xx_inline.h
@@ -37,7 +37,7 @@
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 *
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx_inline.h#58 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx_inline.h#59 $
 *
 * $FreeBSD$
 */
@@ -804,9 +804,10 @@ ahd_queue_scb(struct ahd_softc *ahd, struct scb *scb)
                uint64_t host_dataptr;
                host_dataptr = ahd_le64toh(scb->hscb->dataptr);
-                printf("%s: Queueing SCB 0x%x bus addr 0x%x - 0x%x%x/0x%x\n",
+                printf("%s: Queueing SCB %d:0x%x bus addr 0x%x - 0x%x%x/0x%x\n",
                       ahd_name(ahd),
-                       SCB_GET_TAG(scb), ahd_le32toh(scb->hscb->hscb_busaddr),
+                       SCB_GET_TAG(scb), scb->hscb->scsiid,
+                       ahd_le32toh(scb->hscb->hscb_busaddr),
                       (u_int)((host_dataptr >> 32) & 0xFFFFFFFF),
                       (u_int)(host_dataptr & 0xFFFFFFFF),
                       ahd_le32toh(scb->hscb->datacnt));
diff --git a/drivers/scsi/aic7xxx/aic79xx_osm.c b/drivers/scsi/aic7xxx/aic79xx_osm.c
index 2567e29960bd..7254ea535a16 100644
--- a/drivers/scsi/aic7xxx/aic79xx_osm.c
+++ b/drivers/scsi/aic7xxx/aic79xx_osm.c
@@ -314,6 +314,21 @@ static uint32_t aic79xx_seltime;
 */
 uint32_t aic79xx_periodic_otag;
+/* Some storage boxes are using an LSI chip which has a bug making it
+ * impossible to use aic79xx Rev B chip in 320 speeds.  The following
+ * storage boxes have been reported to be buggy:
+ * EonStor 3U 16-Bay: U16U-G3A3
+ * EonStor 2U 12-Bay: U12U-G3A3
+ * SentinelRAID: 2500F R5 / R6
+ * SentinelRAID: 2500F R1
+ * SentinelRAID: 2500F/1500F
+ * SentinelRAID: 150F
+ * 
+ * To get around this LSI bug, you can set your board to 160 mode
+ * or you can enable the SLOWCRC bit.
+ */
+uint32_t aic79xx_slowcrc;
 /*
 * Module information and settable options.
 */
@@ -343,6 +358,7 @@ MODULE_PARM_DESC(aic79xx,
 "       amplitude:<int>         Set the signal amplitude (0-7).\n"
 "       seltime:<int>           Selection Timeout:\n"
 "                               (0/256ms,1/128ms,2/64ms,3/32ms)\n"
+"       slowcrc                 Turn on the SLOWCRC bit (Rev B only)\n"          
 "\n"
 "       Sample /etc/modprobe.conf line:\n"
 "               Enable verbose logging\n"
@@ -1003,6 +1019,7 @@ aic79xx_setup(char *s)
                { "slewrate", NULL },
                { "precomp", NULL },
                { "amplitude", NULL },
+                { "slowcrc", &aic79xx_slowcrc },
        };
        end = strchr(s, '\0');
@@ -1072,7 +1089,6 @@ ahd_linux_register_host(struct ahd_softc *ahd, struct scsi_host_template *templa
                return (ENOMEM);
        *((struct ahd_softc **)host->hostdata) = ahd;
-        ahd_lock(ahd, &s);
        ahd->platform_data->host = host;
        host->can_queue = AHD_MAX_QUEUE;
        host->cmd_per_lun = 2;
@@ -1083,7 +1099,9 @@ ahd_linux_register_host(struct ahd_softc *ahd, struct scsi_host_template *templa
        host->max_lun = AHD_NUM_LUNS;
        host->max_channel = 0;
        host->sg_tablesize = AHD_NSEG;
+        ahd_lock(ahd, &s);
        ahd_set_unit(ahd, ahd_linux_unit++);
+        ahd_unlock(ahd, &s);
        sprintf(buf, "scsi%d", host->host_no);
        new_name = malloc(strlen(buf) + 1, M_DEVBUF, M_NOWAIT);
        if (new_name != NULL) {
@@ -1093,7 +1111,6 @@ ahd_linux_register_host(struct ahd_softc *ahd, struct scsi_host_template *templa
        host->unique_id = ahd->unit;
        ahd_linux_initialize_scsi_bus(ahd);
        ahd_intr_enable(ahd, TRUE);
-        ahd_unlock(ahd, &s);
        host->transportt = ahd_linux_transport_template;
@@ -1127,6 +1144,7 @@ ahd_linux_initialize_scsi_bus(struct ahd_softc *ahd)
 {
        u_int target_id;
        u_int numtarg;
+        unsigned long s;
        target_id = 0;
        numtarg = 0;
@@ -1139,6 +1157,8 @@ ahd_linux_initialize_scsi_bus(struct ahd_softc *ahd)
        else
                numtarg = (ahd->features & AHD_WIDE) ? 16 : 8;
+        ahd_lock(ahd, &s);
        /*
         * Force negotiation to async for all targets that
         * will not see an initial bus reset.
@@ -1155,16 +1175,12 @@ ahd_linux_initialize_scsi_bus(struct ahd_softc *ahd)
                ahd_update_neg_request(ahd, &devinfo, tstate,
                                       tinfo, AHD_NEG_ALWAYS);
        }
+        ahd_unlock(ahd, &s);
        /* Give the bus some time to recover */
        if ((ahd->flags & AHD_RESET_BUS_A) != 0) {
                ahd_freeze_simq(ahd);
-                init_timer(&ahd->platform_data->reset_timer);
+                msleep(AIC79XX_RESET_DELAY);
-                ahd->platform_data->reset_timer.data = (u_long)ahd;
+                ahd_release_simq(ahd);
-                ahd->platform_data->reset_timer.expires =
-                    jiffies + (AIC79XX_RESET_DELAY * HZ)/1000;
-                ahd->platform_data->reset_timer.function =
-                    (ahd_linux_callback_t *)ahd_release_simq;
-                add_timer(&ahd->platform_data->reset_timer);
        }
 }
@@ -2033,6 +2049,9 @@ ahd_linux_sem_timeout(u_long arg)
 void
 ahd_freeze_simq(struct ahd_softc *ahd)
 {
+        unsigned long s;
+        ahd_lock(ahd, &s);
        ahd->platform_data->qfrozen++;
        if (ahd->platform_data->qfrozen == 1) {
                scsi_block_requests(ahd->platform_data->host);
@@ -2040,6 +2059,7 @@ ahd_freeze_simq(struct ahd_softc *ahd)
                                        CAM_LUN_WILDCARD, SCB_LIST_NULL,
                                        ROLE_INITIATOR, CAM_REQUEUE_REQ);
        }
+        ahd_unlock(ahd, &s);
 }
 void
@@ -2344,8 +2364,9 @@ done:
                               ahd_name(ahd), dev->active);
                        retval = FAILED;
                }
-        }
+        } else
-        ahd_unlock(ahd, &flags);
+                ahd_unlock(ahd, &flags);
        return (retval);
 }
diff --git a/drivers/scsi/aic7xxx/aic79xx_osm.h b/drivers/scsi/aic7xxx/aic79xx_osm.h
index cb74fccc8100..9cb101345107 100644
--- a/drivers/scsi/aic7xxx/aic79xx_osm.h
+++ b/drivers/scsi/aic7xxx/aic79xx_osm.h
@@ -36,7 +36,7 @@
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 *
- * $Id: //depot/aic7xxx/linux/drivers/scsi/aic7xxx/aic79xx_osm.h#137 $
+ * $Id: //depot/aic7xxx/linux/drivers/scsi/aic7xxx/aic79xx_osm.h#166 $
 *
 */
 #ifndef _AIC79XX_LINUX_H_
@@ -228,7 +228,6 @@ typedef struct timer_list ahd_timer_t;
 typedef void ahd_linux_callback_t (u_long);  
 static __inline void ahd_timer_reset(ahd_timer_t *timer, int usec,
                                     ahd_callback_t *func, void *arg);
-static __inline void ahd_scb_timer_reset(struct scb *scb, u_int usec);
 static __inline void
 ahd_timer_reset(ahd_timer_t *timer, int usec, ahd_callback_t *func, void *arg)
@@ -243,12 +242,6 @@ ahd_timer_reset(ahd_timer_t *timer, int usec, ahd_callback_t *func, void *arg)
        add_timer(timer);
 }
-static __inline void
-ahd_scb_timer_reset(struct scb *scb, u_int usec)
-{
-        mod_timer(&scb->io_ctx->eh_timeout, jiffies + (usec * HZ)/1000000);
-}
 /***************************** SMP support ************************************/
 #include <linux/spinlock.h>
@@ -389,7 +382,6 @@ struct ahd_platform_data {
        spinlock_t               spin_lock;
        u_int                    qfrozen;
-        struct timer_list        reset_timer;
        struct semaphore         eh_sem;
        struct Scsi_Host        *host;          /* pointer to scsi host */
 #define AHD_LINUX_NOIRQ ((uint32_t)~0)
diff --git a/drivers/scsi/aic7xxx/aic79xx_osm_pci.c b/drivers/scsi/aic7xxx/aic79xx_osm_pci.c
index bf360ae021ab..ebbf7e4ff4cc 100644
--- a/drivers/scsi/aic7xxx/aic79xx_osm_pci.c
+++ b/drivers/scsi/aic7xxx/aic79xx_osm_pci.c
@@ -220,10 +220,10 @@ ahd_linux_pci_reserve_io_regions(struct ahd_softc *ahd, u_long *base,
        *base2 = pci_resource_start(ahd->dev_softc, 3);
        if (*base == 0 || *base2 == 0)
                return (ENOMEM);
-        if (request_region(*base, 256, "aic79xx") == 0)
+        if (!request_region(*base, 256, "aic79xx"))
                return (ENOMEM);
-        if (request_region(*base2, 256, "aic79xx") == 0) {
+        if (!request_region(*base2, 256, "aic79xx")) {
-                release_region(*base2, 256);
+                release_region(*base, 256);
                return (ENOMEM);
        }
        return (0);
@@ -237,7 +237,7 @@ ahd_linux_pci_reserve_mem_region(struct ahd_softc *ahd,
        u_long  start;
        u_long  base_page;
        u_long  base_offset;
-        int     error;
+        int     error = 0;
        if (aic79xx_allow_memio == 0)
                return (ENOMEM);
@@ -245,16 +245,15 @@ ahd_linux_pci_reserve_mem_region(struct ahd_softc *ahd,
        if ((ahd->bugs & AHD_PCIX_MMAPIO_BUG) != 0)
                return (ENOMEM);
-        error = 0;
        start = pci_resource_start(ahd->dev_softc, 1);
        base_page = start & PAGE_MASK;
        base_offset = start - base_page;
        if (start != 0) {
                *bus_addr = start;
-                if (request_mem_region(start, 0x1000, "aic79xx") == 0)
+                if (!request_mem_region(start, 0x1000, "aic79xx"))
                        error = ENOMEM;
-                if (error == 0) {
+                if (!error) {
-                        *maddr = ioremap_nocache(base_page, base_offset + 256);
+                        *maddr = ioremap_nocache(base_page, base_offset + 512);
                        if (*maddr == NULL) {
                                error = ENOMEM;
                                release_mem_region(start, 0x1000);
@@ -344,7 +343,7 @@ ahd_pci_map_int(struct ahd_softc *ahd)
        error = request_irq(ahd->dev_softc->irq, ahd_linux_isr,
                            SA_SHIRQ, "aic79xx", ahd);
-        if (error == 0)
+        if (!error)
                ahd->platform_data->irq = ahd->dev_softc->irq;
        
        return (-error);
diff --git a/drivers/scsi/aic7xxx/aic79xx_pci.c b/drivers/scsi/aic7xxx/aic79xx_pci.c
index 196a6344b037..757242e522c2 100644
--- a/drivers/scsi/aic7xxx/aic79xx_pci.c
+++ b/drivers/scsi/aic7xxx/aic79xx_pci.c
@@ -38,7 +38,7 @@
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 *
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx_pci.c#89 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx_pci.c#92 $
 */
 #ifdef __linux__
@@ -950,12 +950,19 @@ ahd_aic790X_setup(struct ahd_softc *ahd)
                if ((ahd->flags & AHD_HP_BOARD) == 0)
                        AHD_SET_SLEWRATE(ahd, AHD_SLEWRATE_DEF_REVA);
        } else {
+                /* This is revision B and newer. */
+                extern uint32_t aic79xx_slowcrc;
                u_int devconfig1;
                ahd->features |= AHD_RTI|AHD_NEW_IOCELL_OPTS
-                              |  AHD_NEW_DFCNTRL_OPTS|AHD_FAST_CDB_DELIVERY;
+                              |  AHD_NEW_DFCNTRL_OPTS|AHD_FAST_CDB_DELIVERY
+                              |  AHD_BUSFREEREV_BUG;
                ahd->bugs |= AHD_LQOOVERRUN_BUG|AHD_EARLY_REQ_BUG;
+                /* If the user requested the the SLOWCRC bit to be set. */
+                if (aic79xx_slowcrc)
+                        ahd->features |= AHD_AIC79XXB_SLOWCRC;
                /*
                 * Some issues have been resolved in the 7901B.
                 */
diff --git a/drivers/scsi/aic7xxx/aic79xx_reg.h_shipped b/drivers/scsi/aic7xxx/aic79xx_reg.h_shipped
index 8763b158856b..2068e00d2c75 100644
--- a/drivers/scsi/aic7xxx/aic79xx_reg.h_shipped
+++ b/drivers/scsi/aic7xxx/aic79xx_reg.h_shipped
@@ -2,8 +2,8 @@
 * DO NOT EDIT - This file is automatically generated
 *               from the following source files:
 *
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#119 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#120 $
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#76 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#77 $
 */
 typedef int (ahd_reg_print_t)(u_int, u_int *, u_int);
 typedef struct ahd_reg_parse_entry {
@@ -2204,6 +2204,20 @@ ahd_reg_print_t ahd_cmdsize_table_print;
 #endif
 #if AIC_DEBUG_REGISTERS
+ahd_reg_print_t ahd_mk_message_scb_print;
+#else
+#define ahd_mk_message_scb_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "MK_MESSAGE_SCB", 0x160, regvalue, cur_col, wrap)
+#endif
+#if AIC_DEBUG_REGISTERS
+ahd_reg_print_t ahd_mk_message_scsiid_print;
+#else
+#define ahd_mk_message_scsiid_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "MK_MESSAGE_SCSIID", 0x162, regvalue, cur_col, wrap)
+#endif
+#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_scb_base_print;
 #else
 #define ahd_scb_base_print(regvalue, cur_col, wrap) \
@@ -3638,6 +3652,7 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define SEQ_FLAGS2                      0x14d
 #define         SELECTOUT_QFROZEN       0x04
 #define         TARGET_MSG_PENDING      0x02
+#define         PENDING_MK_MESSAGE      0x01
 #define ALLOCFIFO_SCBPTR                0x14e
@@ -3655,6 +3670,10 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define CMDSIZE_TABLE                   0x158
+#define MK_MESSAGE_SCB                  0x160
+#define MK_MESSAGE_SCSIID               0x162
 #define SCB_BASE                        0x180
 #define SCB_RESIDUAL_DATACNT            0x180
@@ -3800,5 +3819,5 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 /* Exported Labels */
-#define LABEL_seq_isr   0x285
+#define LABEL_seq_isr   0x28f
-#define LABEL_timer_isr 0x281
+#define LABEL_timer_isr 0x28b
diff --git a/drivers/scsi/aic7xxx/aic79xx_reg_print.c_shipped b/drivers/scsi/aic7xxx/aic79xx_reg_print.c_shipped
index a4137c985376..db38a61a8cb4 100644
--- a/drivers/scsi/aic7xxx/aic79xx_reg_print.c_shipped
+++ b/drivers/scsi/aic7xxx/aic79xx_reg_print.c_shipped
@@ -2,8 +2,8 @@
 * DO NOT EDIT - This file is automatically generated
 *               from the following source files:
 *
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#118 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#120 $
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#75 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#77 $
 */
 #include "aic79xx_osm.h"
@@ -3382,6 +3382,7 @@ ahd_initiator_tag_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 static ahd_reg_parse_entry_t SEQ_FLAGS2_parse_table[] = {
+        { "PENDING_MK_MESSAGE", 0x01, 0x01 },
        { "TARGET_MSG_PENDING", 0x02, 0x02 },
        { "SELECTOUT_QFROZEN",  0x04, 0x04 }
 };
@@ -3389,7 +3390,7 @@ static ahd_reg_parse_entry_t SEQ_FLAGS2_parse_table[] = {
 int
 ahd_seq_flags2_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(SEQ_FLAGS2_parse_table, 2, "SEQ_FLAGS2",
+        return (ahd_print_register(SEQ_FLAGS2_parse_table, 3, "SEQ_FLAGS2",
            0x14d, regvalue, cur_col, wrap));
 }
@@ -3450,6 +3451,20 @@ ahd_cmdsize_table_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 int
+ahd_mk_message_scb_print(u_int regvalue, u_int *cur_col, u_int wrap)
+{
+        return (ahd_print_register(NULL, 0, "MK_MESSAGE_SCB",
+            0x160, regvalue, cur_col, wrap));
+}
+int
+ahd_mk_message_scsiid_print(u_int regvalue, u_int *cur_col, u_int wrap)
+{
+        return (ahd_print_register(NULL, 0, "MK_MESSAGE_SCSIID",
+            0x162, regvalue, cur_col, wrap));
+}
+int
 ahd_scb_base_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
        return (ahd_print_register(NULL, 0, "SCB_BASE",
diff --git a/drivers/scsi/aic7xxx/aic79xx_seq.h_shipped b/drivers/scsi/aic7xxx/aic79xx_seq.h_shipped
index b1e5365be230..11bed07e90b7 100644
--- a/drivers/scsi/aic7xxx/aic79xx_seq.h_shipped
+++ b/drivers/scsi/aic7xxx/aic79xx_seq.h_shipped
@@ -2,17 +2,17 @@
 * DO NOT EDIT - This file is automatically generated
 *               from the following source files:
 *
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#119 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#120 $
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#76 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#77 $
 */
 static uint8_t seqprog[] = {
        0xff, 0x02, 0x06, 0x78,
-        0x00, 0xea, 0x64, 0x59,
+        0x00, 0xea, 0x6e, 0x59,
        0x01, 0xea, 0x04, 0x30,
        0xff, 0x04, 0x0c, 0x78,
-        0x19, 0xea, 0x64, 0x59,
+        0x19, 0xea, 0x6e, 0x59,
        0x19, 0xea, 0x04, 0x00,
-        0x33, 0xea, 0x5e, 0x59,
+        0x33, 0xea, 0x68, 0x59,
        0x33, 0xea, 0x00, 0x00,
        0x60, 0x3a, 0x3a, 0x68,
        0x04, 0x4d, 0x35, 0x78,
@@ -33,15 +33,15 @@ static uint8_t seqprog[] = {
        0xff, 0xea, 0x62, 0x02,
        0x00, 0xe2, 0x3a, 0x40,
        0xff, 0x21, 0x3b, 0x70,
-        0x40, 0x4b, 0xaa, 0x69,
+        0x40, 0x4b, 0xb4, 0x69,
-        0x00, 0xe2, 0x68, 0x59,
+        0x00, 0xe2, 0x72, 0x59,
-        0x40, 0x4b, 0xaa, 0x69,
+        0x40, 0x4b, 0xb4, 0x69,
-        0x20, 0x4b, 0x96, 0x69,
+        0x20, 0x4b, 0xa0, 0x69,
        0xfc, 0x42, 0x44, 0x78,
        0x10, 0x40, 0x44, 0x78,
-        0x00, 0xe2, 0xfc, 0x5d,
+        0x00, 0xe2, 0x10, 0x5e,
        0x20, 0x4d, 0x48, 0x78,
-        0x00, 0xe2, 0xfc, 0x5d,
+        0x00, 0xe2, 0x10, 0x5e,
        0x30, 0x3f, 0xc0, 0x09,
        0x30, 0xe0, 0x50, 0x60,
        0x7f, 0x4a, 0x94, 0x08,
@@ -51,7 +51,7 @@ static uint8_t seqprog[] = {
        0x00, 0xe2, 0x76, 0x58,
        0x00, 0xe2, 0x86, 0x58,
        0x00, 0xe2, 0x06, 0x40,
-        0x33, 0xea, 0x5e, 0x59,
+        0x33, 0xea, 0x68, 0x59,
        0x33, 0xea, 0x00, 0x00,
        0x01, 0x52, 0x84, 0x78,
        0x02, 0x58, 0x50, 0x31,
@@ -59,26 +59,26 @@ static uint8_t seqprog[] = {
        0xff, 0x97, 0x6f, 0x78,
        0x50, 0x4b, 0x6a, 0x68,
        0xbf, 0x3a, 0x74, 0x08,
-        0x14, 0xea, 0x64, 0x59,
+        0x14, 0xea, 0x6e, 0x59,
        0x14, 0xea, 0x04, 0x00,
        0x08, 0x92, 0x25, 0x03,
        0xff, 0x90, 0x5f, 0x68,
-        0x00, 0xe2, 0x76, 0x5b,
+        0x00, 0xe2, 0x8a, 0x5b,
        0x00, 0xe2, 0x5e, 0x40,
-        0x00, 0xea, 0x5e, 0x59,
+        0x00, 0xea, 0x68, 0x59,
        0x01, 0xea, 0x00, 0x30,
        0x80, 0xf9, 0x7e, 0x68,
-        0x00, 0xe2, 0x5c, 0x59,
+        0x00, 0xe2, 0x66, 0x59,
-        0x11, 0xea, 0x5e, 0x59,
+        0x11, 0xea, 0x68, 0x59,
        0x11, 0xea, 0x00, 0x00,
-        0x80, 0xf9, 0x5c, 0x79,
+        0x80, 0xf9, 0x66, 0x79,
        0xff, 0xea, 0xd4, 0x0d,
-        0x22, 0xea, 0x5e, 0x59,
+        0x22, 0xea, 0x68, 0x59,
        0x22, 0xea, 0x00, 0x00,
        0x10, 0x16, 0x90, 0x78,
        0x10, 0x16, 0x2c, 0x00,
        0x01, 0x0b, 0xae, 0x32,
-        0x18, 0xad, 0x12, 0x79,
+        0x18, 0xad, 0x1c, 0x79,
        0x04, 0xad, 0xdc, 0x68,
        0x80, 0xad, 0x84, 0x78,
        0x10, 0xad, 0xaa, 0x78,
@@ -118,7 +118,6 @@ static uint8_t seqprog[] = {
        0x80, 0x18, 0x30, 0x04,
        0x40, 0xad, 0x84, 0x78,
        0xe7, 0xad, 0x5a, 0x09,
-        0x02, 0xa8, 0x40, 0x31,
        0xff, 0xea, 0xc0, 0x09,
        0x01, 0x54, 0xa9, 0x1a,
        0x00, 0x55, 0xab, 0x22,
@@ -128,24 +127,30 @@ static uint8_t seqprog[] = {
        0xff, 0xea, 0x5a, 0x03,
        0xff, 0xea, 0x5e, 0x03,
        0x01, 0x10, 0xd4, 0x31,
-        0x10, 0x92, 0x07, 0x69,
+        0x02, 0xa8, 0x40, 0x31,
+        0x01, 0x92, 0xc1, 0x31,
        0x3d, 0x93, 0xc5, 0x29,
        0xfe, 0xe2, 0xc4, 0x09,
        0x01, 0xea, 0xc6, 0x01,
        0x02, 0xe2, 0xc8, 0x31,
        0x02, 0xec, 0x50, 0x31,
        0x02, 0xa0, 0xda, 0x31,
-        0xff, 0xa9, 0x06, 0x71,
+        0xff, 0xa9, 0x10, 0x71,
+        0x10, 0xe0, 0x0e, 0x79,
+        0x10, 0x92, 0x0f, 0x79,
+        0x01, 0x4d, 0x9b, 0x02,
+        0x02, 0xa0, 0xc0, 0x32,
+        0x01, 0x93, 0xc5, 0x36,
        0x02, 0xa0, 0x58, 0x37,
-        0xff, 0x21, 0x0f, 0x71,
+        0xff, 0x21, 0x19, 0x71,
        0x02, 0x22, 0x51, 0x31,
        0x02, 0xa0, 0x5c, 0x33,
        0x02, 0xa0, 0x44, 0x36,
        0x02, 0xa0, 0x40, 0x32,
        0x02, 0xa0, 0x44, 0x36,
-        0x04, 0x4d, 0x17, 0x69,
+        0x05, 0x4d, 0x21, 0x69,
-        0x40, 0x16, 0x48, 0x69,
+        0x40, 0x16, 0x52, 0x69,
-        0xff, 0x2d, 0x4d, 0x61,
+        0xff, 0x2d, 0x57, 0x61,
        0xff, 0x29, 0x85, 0x70,
        0x02, 0x28, 0x55, 0x32,
        0x01, 0xea, 0x5a, 0x01,
@@ -159,22 +164,22 @@ static uint8_t seqprog[] = {
        0x01, 0x56, 0xad, 0x1a,
        0xff, 0x54, 0xa9, 0x1a,
        0xff, 0x55, 0xab, 0x22,
-        0xff, 0x8d, 0x41, 0x71,
+        0xff, 0x8d, 0x4b, 0x71,
-        0x80, 0xac, 0x40, 0x71,
+        0x80, 0xac, 0x4a, 0x71,
-        0x20, 0x16, 0x40, 0x69,
+        0x20, 0x16, 0x4a, 0x69,
        0x00, 0xac, 0xc4, 0x19,
-        0x07, 0xe2, 0x40, 0xf9,
+        0x07, 0xe2, 0x4a, 0xf9,
        0x02, 0x8c, 0x51, 0x31,
-        0x00, 0xe2, 0x24, 0x41,
+        0x00, 0xe2, 0x2e, 0x41,
        0x01, 0xac, 0x08, 0x31,
        0x09, 0xea, 0x5a, 0x01,
        0x02, 0x8c, 0x51, 0x32,
        0xff, 0xea, 0x1a, 0x07,
        0x04, 0x24, 0xf9, 0x30,
-        0x1d, 0xea, 0x52, 0x41,
+        0x1d, 0xea, 0x5c, 0x41,
        0x02, 0x2c, 0x51, 0x31,
        0x04, 0xa8, 0xf9, 0x30,
-        0x19, 0xea, 0x52, 0x41,
+        0x19, 0xea, 0x5c, 0x41,
        0x06, 0xea, 0x08, 0x81,
        0x01, 0xe2, 0x5a, 0x35,
        0x02, 0xf2, 0xf0, 0x31,
@@ -190,27 +195,27 @@ static uint8_t seqprog[] = {
        0x02, 0x20, 0xb9, 0x30,
        0x02, 0x20, 0x51, 0x31,
        0x4c, 0x93, 0xd7, 0x28,
-        0x10, 0x92, 0x77, 0x79,
+        0x10, 0x92, 0x81, 0x79,
        0x01, 0x6b, 0xc0, 0x30,
        0x02, 0x64, 0xc8, 0x00,
        0x40, 0x3a, 0x74, 0x04,
        0x00, 0xe2, 0x76, 0x58,
-        0x33, 0xea, 0x5e, 0x59,
+        0x33, 0xea, 0x68, 0x59,
        0x33, 0xea, 0x00, 0x00,
        0x30, 0x3f, 0xc0, 0x09,
-        0x30, 0xe0, 0x78, 0x61,
+        0x30, 0xe0, 0x82, 0x61,
-        0x20, 0x3f, 0x8e, 0x69,
+        0x20, 0x3f, 0x98, 0x69,
-        0x10, 0x3f, 0x78, 0x79,
+        0x10, 0x3f, 0x82, 0x79,
        0x02, 0xea, 0x7e, 0x00,
-        0x00, 0xea, 0x5e, 0x59,
+        0x00, 0xea, 0x68, 0x59,
        0x01, 0xea, 0x00, 0x30,
        0x02, 0x4e, 0x51, 0x35,
        0x01, 0xea, 0x7e, 0x00,
-        0x11, 0xea, 0x5e, 0x59,
+        0x11, 0xea, 0x68, 0x59,
        0x11, 0xea, 0x00, 0x00,
        0x02, 0x4e, 0x51, 0x35,
        0xc0, 0x4a, 0x94, 0x00,
-        0x04, 0x41, 0x9c, 0x79,
+        0x04, 0x41, 0xa6, 0x79,
        0x08, 0xea, 0x98, 0x00,
        0x08, 0x57, 0xae, 0x00,
        0x08, 0x3c, 0x78, 0x00,
@@ -218,12 +223,12 @@ static uint8_t seqprog[] = {
        0x0f, 0x67, 0xc0, 0x09,
        0x00, 0x3a, 0x75, 0x02,
        0x20, 0xea, 0x96, 0x00,
-        0x00, 0xe2, 0x14, 0x42,
+        0x00, 0xe2, 0x28, 0x42,
        0xc0, 0x4a, 0x94, 0x00,
-        0x40, 0x3a, 0xc8, 0x69,
+        0x40, 0x3a, 0xd2, 0x69,
        0x02, 0x55, 0x06, 0x68,
-        0x02, 0x56, 0xc8, 0x69,
+        0x02, 0x56, 0xd2, 0x69,
-        0xff, 0x5b, 0xc8, 0x61,
+        0xff, 0x5b, 0xd2, 0x61,
        0x02, 0x20, 0x51, 0x31,
        0x80, 0xea, 0xb2, 0x01,
        0x44, 0xea, 0x00, 0x00,
@@ -231,40 +236,45 @@ static uint8_t seqprog[] = {
        0x33, 0xea, 0x00, 0x00,
        0xff, 0xea, 0xb2, 0x09,
        0xff, 0xe0, 0xc0, 0x19,
-        0xff, 0xe0, 0xca, 0x79,
+        0xff, 0xe0, 0xd4, 0x79,
        0x02, 0xac, 0x51, 0x31,
-        0x00, 0xe2, 0xc0, 0x41,
+        0x00, 0xe2, 0xca, 0x41,
        0x02, 0x5e, 0x50, 0x31,
        0x02, 0xa8, 0xb8, 0x30,
        0x02, 0x5c, 0x50, 0x31,
-        0xff, 0xad, 0xdb, 0x71,
+        0xff, 0xad, 0xe5, 0x71,
        0x02, 0xac, 0x41, 0x31,
        0x02, 0x22, 0x51, 0x31,
        0x02, 0xa0, 0x5c, 0x33,
        0x02, 0xa0, 0x44, 0x32,
-        0x00, 0xe2, 0xe4, 0x41,
+        0x00, 0xe2, 0xf8, 0x41,
-        0x10, 0x92, 0xe5, 0x69,
+        0x01, 0x4d, 0xf1, 0x79,
+        0x01, 0x62, 0xc1, 0x31,
+        0x00, 0x93, 0xf1, 0x61,
+        0xfe, 0x4d, 0x9b, 0x0a,
+        0x02, 0x60, 0x41, 0x31,
+        0x00, 0xe2, 0xdc, 0x41,
        0x3d, 0x93, 0xc9, 0x29,
        0x01, 0xe4, 0xc8, 0x01,
        0x01, 0xea, 0xca, 0x01,
        0xff, 0xea, 0xda, 0x01,
        0x02, 0x20, 0x51, 0x31,
        0x02, 0xae, 0x41, 0x32,
-        0xff, 0x21, 0xed, 0x61,
+        0xff, 0x21, 0x01, 0x62,
        0xff, 0xea, 0x46, 0x02,
        0x02, 0x5c, 0x50, 0x31,
        0x40, 0xea, 0x96, 0x00,
-        0x02, 0x56, 0x04, 0x6e,
+        0x02, 0x56, 0x20, 0x6e,
-        0x01, 0x55, 0x04, 0x6e,
+        0x01, 0x55, 0x20, 0x6e,
-        0x10, 0x92, 0xf9, 0x79,
+        0x10, 0x92, 0x0d, 0x7a,
-        0x10, 0x40, 0x02, 0x6a,
+        0x10, 0x40, 0x16, 0x6a,
-        0x01, 0x56, 0x02, 0x7a,
+        0x01, 0x56, 0x16, 0x7a,
        0xff, 0x97, 0x07, 0x78,
-        0x13, 0xea, 0x64, 0x59,
+        0x13, 0xea, 0x6e, 0x59,
        0x13, 0xea, 0x04, 0x00,
        0x00, 0xe2, 0x06, 0x40,
        0xbf, 0x3a, 0x74, 0x08,
-        0x04, 0x41, 0x08, 0x7a,
+        0x04, 0x41, 0x1c, 0x7a,
        0x08, 0xea, 0x98, 0x00,
        0x08, 0x57, 0xae, 0x00,
        0x01, 0x93, 0x75, 0x32,
@@ -272,108 +282,108 @@ static uint8_t seqprog[] = {
        0x40, 0xea, 0x72, 0x02,
        0x08, 0x3c, 0x78, 0x00,
        0x80, 0xea, 0x6e, 0x02,
-        0x00, 0xe2, 0xe2, 0x5b,
+        0x00, 0xe2, 0xf6, 0x5b,
        0x01, 0x3c, 0xc1, 0x31,
-        0x9f, 0xe0, 0x84, 0x7c,
+        0x9f, 0xe0, 0x98, 0x7c,
-        0x80, 0xe0, 0x28, 0x72,
+        0x80, 0xe0, 0x3c, 0x72,
-        0xa0, 0xe0, 0x64, 0x72,
+        0xa0, 0xe0, 0x78, 0x72,
-        0xc0, 0xe0, 0x5a, 0x72,
+        0xc0, 0xe0, 0x6e, 0x72,
-        0xe0, 0xe0, 0x94, 0x72,
+        0xe0, 0xe0, 0xa8, 0x72,
-        0x01, 0xea, 0x64, 0x59,
+        0x01, 0xea, 0x6e, 0x59,
        0x01, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0x14, 0x42,
+        0x00, 0xe2, 0x28, 0x42,
-        0x80, 0x39, 0x2f, 0x7a,
+        0x80, 0x39, 0x43, 0x7a,
-        0x03, 0xea, 0x64, 0x59,
+        0x03, 0xea, 0x6e, 0x59,
        0x03, 0xea, 0x04, 0x00,
-        0xee, 0x00, 0x36, 0x6a,
+        0xee, 0x00, 0x4a, 0x6a,
        0x05, 0xea, 0xb4, 0x00,
-        0x33, 0xea, 0x5e, 0x59,
+        0x33, 0xea, 0x68, 0x59,
        0x33, 0xea, 0x00, 0x00,
        0x02, 0xa8, 0x9c, 0x32,
-        0x00, 0xe2, 0x7e, 0x59,
+        0x00, 0xe2, 0x88, 0x59,
        0xef, 0x96, 0xd5, 0x19,
-        0x00, 0xe2, 0x46, 0x52,
+        0x00, 0xe2, 0x5a, 0x52,
        0x09, 0x80, 0xe1, 0x30,
        0x02, 0xea, 0x36, 0x00,
        0xa8, 0xea, 0x32, 0x00,
-        0x00, 0xe2, 0x4c, 0x42,
+        0x00, 0xe2, 0x60, 0x42,
        0x01, 0x96, 0xd1, 0x30,
        0x10, 0x80, 0x89, 0x31,
        0x20, 0xea, 0x32, 0x00,
        0xbf, 0x39, 0x73, 0x0a,
-        0x10, 0x4c, 0x56, 0x6a,
+        0x10, 0x4c, 0x6a, 0x6a,
-        0x20, 0x19, 0x4e, 0x6a,
+        0x20, 0x19, 0x62, 0x6a,
-        0x20, 0x19, 0x52, 0x6a,
+        0x20, 0x19, 0x66, 0x6a,
-        0x02, 0x4d, 0x14, 0x6a,
+        0x02, 0x4d, 0x28, 0x6a,
        0x40, 0x39, 0x73, 0x02,
-        0x00, 0xe2, 0x14, 0x42,
+        0x00, 0xe2, 0x28, 0x42,
-        0x80, 0x39, 0xd5, 0x6a,
+        0x80, 0x39, 0xe9, 0x6a,
        0x01, 0x44, 0x10, 0x33,
        0x08, 0x92, 0x25, 0x03,
-        0x00, 0xe2, 0x14, 0x42,
+        0x00, 0xe2, 0x28, 0x42,
        0x10, 0xea, 0x80, 0x00,
        0x01, 0x37, 0xc5, 0x31,
-        0x80, 0xe2, 0x80, 0x62,
+        0x80, 0xe2, 0x94, 0x62,
-        0x10, 0x92, 0xa5, 0x6a,
+        0x10, 0x92, 0xb9, 0x6a,
        0xc0, 0x94, 0xc5, 0x01,
-        0x40, 0x92, 0x71, 0x6a,
+        0x40, 0x92, 0x85, 0x6a,
        0xbf, 0xe2, 0xc4, 0x09,
-        0x20, 0x92, 0x85, 0x7a,
+        0x20, 0x92, 0x99, 0x7a,
        0x01, 0xe2, 0x88, 0x30,
-        0x00, 0xe2, 0xe2, 0x5b,
+        0x00, 0xe2, 0xf6, 0x5b,
-        0xa0, 0x3c, 0x8d, 0x62,
+        0xa0, 0x3c, 0xa1, 0x62,
        0x23, 0x92, 0x89, 0x08,
-        0x00, 0xe2, 0xe2, 0x5b,
+        0x00, 0xe2, 0xf6, 0x5b,
-        0xa0, 0x3c, 0x8d, 0x62,
+        0xa0, 0x3c, 0xa1, 0x62,
-        0x00, 0xa8, 0x84, 0x42,
+        0x00, 0xa8, 0x98, 0x42,
-        0xff, 0xe2, 0x84, 0x62,
+        0xff, 0xe2, 0x98, 0x62,
-        0x00, 0xe2, 0xa4, 0x42,
+        0x00, 0xe2, 0xb8, 0x42,
        0x40, 0xea, 0x98, 0x00,
        0x01, 0xe2, 0x88, 0x30,
-        0x00, 0xe2, 0xe2, 0x5b,
+        0x00, 0xe2, 0xf6, 0x5b,
-        0xa0, 0x3c, 0x63, 0x72,
+        0xa0, 0x3c, 0x77, 0x72,
        0x40, 0xea, 0x98, 0x00,
        0x01, 0x37, 0x95, 0x32,
        0x08, 0xea, 0x6e, 0x02,
-        0x00, 0xe2, 0x14, 0x42,
+        0x00, 0xe2, 0x28, 0x42,
-        0xe0, 0xea, 0xfe, 0x5b,
+        0xe0, 0xea, 0x12, 0x5c,
-        0x80, 0xe0, 0xe0, 0x6a,
+        0x80, 0xe0, 0xf4, 0x6a,
-        0x04, 0xe0, 0x92, 0x73,
+        0x04, 0xe0, 0xa6, 0x73,
-        0x02, 0xe0, 0xc4, 0x73,
+        0x02, 0xe0, 0xd8, 0x73,
-        0x00, 0xea, 0x3e, 0x73,
+        0x00, 0xea, 0x52, 0x73,
-        0x03, 0xe0, 0xd4, 0x73,
+        0x03, 0xe0, 0xe8, 0x73,
-        0x23, 0xe0, 0xb6, 0x72,
+        0x23, 0xe0, 0xca, 0x72,
-        0x08, 0xe0, 0xdc, 0x72,
+        0x08, 0xe0, 0xf0, 0x72,
-        0x00, 0xe2, 0xe2, 0x5b,
+        0x00, 0xe2, 0xf6, 0x5b,
-        0x07, 0xea, 0x64, 0x59,
+        0x07, 0xea, 0x6e, 0x59,
        0x07, 0xea, 0x04, 0x00,
-        0x08, 0x48, 0x15, 0x72,
+        0x08, 0x48, 0x29, 0x72,
-        0x04, 0x48, 0xb3, 0x62,
+        0x04, 0x48, 0xc7, 0x62,
        0x01, 0x49, 0x89, 0x30,
-        0x00, 0xe2, 0xa4, 0x42,
+        0x00, 0xe2, 0xb8, 0x42,
        0x01, 0x44, 0xd4, 0x31,
-        0x00, 0xe2, 0xa4, 0x42,
+        0x00, 0xe2, 0xb8, 0x42,
        0x01, 0x00, 0x6c, 0x32,
-        0x33, 0xea, 0x5e, 0x59,
+        0x33, 0xea, 0x68, 0x59,
        0x33, 0xea, 0x00, 0x00,
        0x4c, 0x3a, 0xc1, 0x28,
        0x01, 0x64, 0xc0, 0x31,
-        0x00, 0x36, 0x5f, 0x59,
+        0x00, 0x36, 0x69, 0x59,
        0x01, 0x36, 0x01, 0x30,
-        0x01, 0xe0, 0xda, 0x7a,
+        0x01, 0xe0, 0xee, 0x7a,
-        0xa0, 0xea, 0xf4, 0x5b,
+        0xa0, 0xea, 0x08, 0x5c,
-        0x01, 0xa0, 0xda, 0x62,
+        0x01, 0xa0, 0xee, 0x62,
-        0x01, 0x84, 0xcf, 0x7a,
+        0x01, 0x84, 0xe3, 0x7a,
-        0x01, 0x95, 0xdd, 0x6a,
+        0x01, 0x95, 0xf1, 0x6a,
-        0x05, 0xea, 0x64, 0x59,
+        0x05, 0xea, 0x6e, 0x59,
        0x05, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0xdc, 0x42,
+        0x00, 0xe2, 0xf0, 0x42,
-        0x03, 0xea, 0x64, 0x59,
+        0x03, 0xea, 0x6e, 0x59,
        0x03, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0xdc, 0x42,
+        0x00, 0xe2, 0xf0, 0x42,
-        0x07, 0xea, 0x06, 0x5c,
+        0x07, 0xea, 0x1a, 0x5c,
        0x01, 0x44, 0xd4, 0x31,
-        0x00, 0xe2, 0x14, 0x42,
+        0x00, 0xe2, 0x28, 0x42,
        0x3f, 0xe0, 0x76, 0x0a,
        0xc0, 0x3a, 0xc1, 0x09,
        0x00, 0x3b, 0x51, 0x01,
@@ -384,54 +394,54 @@ static uint8_t seqprog[] = {
        0x01, 0xea, 0xc6, 0x01,
        0x02, 0xe2, 0xc8, 0x31,
        0x02, 0xec, 0x40, 0x31,
-        0xff, 0xa1, 0xfc, 0x72,
+        0xff, 0xa1, 0x10, 0x73,
        0x02, 0xe8, 0xda, 0x31,
        0x02, 0xa0, 0x50, 0x31,
-        0x00, 0xe2, 0x1e, 0x43,
+        0x00, 0xe2, 0x32, 0x43,
        0x80, 0x39, 0x73, 0x02,
        0x01, 0x44, 0xd4, 0x31,
-        0x00, 0xe2, 0xe2, 0x5b,
+        0x00, 0xe2, 0xf6, 0x5b,
        0x01, 0x39, 0x73, 0x02,
-        0xe0, 0x3c, 0x39, 0x63,
+        0xe0, 0x3c, 0x4d, 0x63,
        0x02, 0x39, 0x73, 0x02,
-        0x20, 0x46, 0x32, 0x63,
+        0x20, 0x46, 0x46, 0x63,
        0xff, 0xea, 0x52, 0x09,
-        0xa8, 0xea, 0xf4, 0x5b,
+        0xa8, 0xea, 0x08, 0x5c,
-        0x04, 0x92, 0x19, 0x7b,
+        0x04, 0x92, 0x2d, 0x7b,
        0x01, 0x3a, 0xc1, 0x31,
-        0x00, 0x93, 0x19, 0x63,
+        0x00, 0x93, 0x2d, 0x63,
        0x01, 0x3b, 0xc1, 0x31,
-        0x00, 0x94, 0x23, 0x73,
+        0x00, 0x94, 0x37, 0x73,
        0x01, 0xa9, 0x52, 0x11,
-        0xff, 0xa9, 0x0e, 0x6b,
+        0xff, 0xa9, 0x22, 0x6b,
-        0x00, 0xe2, 0x32, 0x43,
+        0x00, 0xe2, 0x46, 0x43,
        0x10, 0x39, 0x73, 0x02,
-        0x04, 0x92, 0x33, 0x7b,
+        0x04, 0x92, 0x47, 0x7b,
        0xfb, 0x92, 0x25, 0x0b,
        0xff, 0xea, 0x72, 0x0a,
-        0x01, 0xa4, 0x2d, 0x6b,
+        0x01, 0xa4, 0x41, 0x6b,
        0x02, 0xa8, 0x9c, 0x32,
-        0x00, 0xe2, 0x7e, 0x59,
+        0x00, 0xe2, 0x88, 0x59,
-        0x10, 0x92, 0xdd, 0x7a,
+        0x10, 0x92, 0xf1, 0x7a,
-        0xff, 0xea, 0x06, 0x5c,
+        0xff, 0xea, 0x1a, 0x5c,
-        0x00, 0xe2, 0xdc, 0x42,
+        0x00, 0xe2, 0xf0, 0x42,
-        0x04, 0xea, 0x64, 0x59,
+        0x04, 0xea, 0x6e, 0x59,
        0x04, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0xdc, 0x42,
+        0x00, 0xe2, 0xf0, 0x42,
-        0x04, 0xea, 0x64, 0x59,
+        0x04, 0xea, 0x6e, 0x59,
        0x04, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0x14, 0x42,
+        0x00, 0xe2, 0x28, 0x42,
-        0x08, 0x92, 0xd5, 0x7a,
+        0x08, 0x92, 0xe9, 0x7a,
-        0xc0, 0x39, 0x49, 0x7b,
+        0xc0, 0x39, 0x5d, 0x7b,
-        0x80, 0x39, 0xd5, 0x6a,
+        0x80, 0x39, 0xe9, 0x6a,
-        0xff, 0x88, 0x49, 0x6b,
+        0xff, 0x88, 0x5d, 0x6b,
-        0x40, 0x39, 0xd5, 0x6a,
+        0x40, 0x39, 0xe9, 0x6a,
-        0x10, 0x92, 0x4f, 0x7b,
+        0x10, 0x92, 0x63, 0x7b,
-        0x0a, 0xea, 0x64, 0x59,
+        0x0a, 0xea, 0x6e, 0x59,
        0x0a, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0x6e, 0x5b,
+        0x00, 0xe2, 0x82, 0x5b,
-        0x00, 0xe2, 0xae, 0x43,
+        0x00, 0xe2, 0xc2, 0x43,
-        0x50, 0x4b, 0x56, 0x6b,
+        0x50, 0x4b, 0x6a, 0x6b,
        0xbf, 0x3a, 0x74, 0x08,
        0x01, 0xe0, 0xf4, 0x31,
        0xff, 0xea, 0xc0, 0x09,
@@ -441,31 +451,31 @@ static uint8_t seqprog[] = {
        0x01, 0xfa, 0xc0, 0x35,
        0x02, 0xa8, 0x90, 0x32,
        0x02, 0xea, 0xb4, 0x00,
-        0x33, 0xea, 0x5e, 0x59,
+        0x33, 0xea, 0x68, 0x59,
        0x33, 0xea, 0x00, 0x00,
        0x02, 0x48, 0x51, 0x31,
        0xff, 0x90, 0x85, 0x68,
-        0xff, 0x88, 0x7b, 0x6b,
+        0xff, 0x88, 0x8f, 0x6b,
-        0x01, 0xa4, 0x77, 0x6b,
+        0x01, 0xa4, 0x8b, 0x6b,
-        0x02, 0xa4, 0x7f, 0x6b,
+        0x02, 0xa4, 0x93, 0x6b,
-        0x01, 0x84, 0x7f, 0x7b,
+        0x01, 0x84, 0x93, 0x7b,
        0x02, 0x28, 0x19, 0x33,
        0x02, 0xa8, 0x50, 0x36,
-        0xff, 0x88, 0x7f, 0x73,
+        0xff, 0x88, 0x93, 0x73,
-        0x00, 0xe2, 0x52, 0x5b,
+        0x00, 0xe2, 0x66, 0x5b,
        0x02, 0xa8, 0x20, 0x33,
        0x04, 0xa4, 0x49, 0x03,
        0xff, 0xea, 0x1a, 0x03,
-        0xff, 0x2d, 0x8b, 0x63,
+        0xff, 0x2d, 0x9f, 0x63,
        0x02, 0xa8, 0x58, 0x32,
        0x02, 0xa8, 0x5c, 0x36,
        0x02, 0xa8, 0x40, 0x31,
        0x02, 0x2e, 0x51, 0x31,
        0x02, 0xa0, 0x18, 0x33,
        0x02, 0xa0, 0x5c, 0x36,
-        0xc0, 0x39, 0xd5, 0x6a,
+        0xc0, 0x39, 0xe9, 0x6a,
        0x04, 0x92, 0x25, 0x03,
-        0x20, 0x92, 0xaf, 0x6b,
+        0x20, 0x92, 0xc3, 0x6b,
        0x02, 0xa8, 0x40, 0x31,
        0xc0, 0x3a, 0xc1, 0x09,
        0x00, 0x3b, 0x51, 0x01,
@@ -480,60 +490,60 @@ static uint8_t seqprog[] = {
        0xf7, 0x57, 0xae, 0x08,
        0x08, 0xea, 0x98, 0x00,
        0x01, 0x44, 0xd4, 0x31,
-        0xee, 0x00, 0xb8, 0x6b,
+        0xee, 0x00, 0xcc, 0x6b,
        0x02, 0xea, 0xb4, 0x00,
        0xc0, 0xea, 0x72, 0x02,
-        0x09, 0x4c, 0xba, 0x7b,
+        0x09, 0x4c, 0xce, 0x7b,
        0x01, 0xea, 0x78, 0x02,
        0x08, 0x4c, 0x06, 0x68,
-        0x0b, 0xea, 0x64, 0x59,
+        0x0b, 0xea, 0x6e, 0x59,
        0x0b, 0xea, 0x04, 0x00,
        0x01, 0x44, 0xd4, 0x31,
-        0x20, 0x39, 0x15, 0x7a,
+        0x20, 0x39, 0x29, 0x7a,
-        0x00, 0xe2, 0xcc, 0x5b,
+        0x00, 0xe2, 0xe0, 0x5b,
-        0x00, 0xe2, 0x14, 0x42,
+        0x00, 0xe2, 0x28, 0x42,
-        0x01, 0x84, 0xd1, 0x7b,
+        0x01, 0x84, 0xe5, 0x7b,
        0x01, 0xa4, 0x49, 0x07,
        0x08, 0x60, 0x30, 0x33,
        0x08, 0x80, 0x41, 0x37,
        0xdf, 0x39, 0x73, 0x0a,
-        0xee, 0x00, 0xde, 0x6b,
+        0xee, 0x00, 0xf2, 0x6b,
        0x05, 0xea, 0xb4, 0x00,
-        0x33, 0xea, 0x5e, 0x59,
+        0x33, 0xea, 0x68, 0x59,
        0x33, 0xea, 0x00, 0x00,
-        0x00, 0xe2, 0x7e, 0x59,
+        0x00, 0xe2, 0x88, 0x59,
-        0x00, 0xe2, 0xdc, 0x42,
+        0x00, 0xe2, 0xf0, 0x42,
-        0xff, 0x42, 0xee, 0x6b,
+        0xff, 0x42, 0x02, 0x6c,
-        0x01, 0x41, 0xe2, 0x6b,
+        0x01, 0x41, 0xf6, 0x6b,
-        0x02, 0x41, 0xe2, 0x7b,
+        0x02, 0x41, 0xf6, 0x7b,
-        0xff, 0x42, 0xee, 0x6b,
+        0xff, 0x42, 0x02, 0x6c,
-        0x01, 0x41, 0xe2, 0x6b,
+        0x01, 0x41, 0xf6, 0x6b,
-        0x02, 0x41, 0xe2, 0x7b,
+        0x02, 0x41, 0xf6, 0x7b,
-        0xff, 0x42, 0xee, 0x7b,
+        0xff, 0x42, 0x02, 0x7c,
-        0x04, 0x4c, 0xe2, 0x6b,
+        0x04, 0x4c, 0xf6, 0x6b,
        0xe0, 0x41, 0x78, 0x0e,
        0x01, 0x44, 0xd4, 0x31,
-        0xff, 0x42, 0xf6, 0x7b,
+        0xff, 0x42, 0x0a, 0x7c,
-        0x04, 0x4c, 0xf6, 0x6b,
+        0x04, 0x4c, 0x0a, 0x6c,
        0xe0, 0x41, 0x78, 0x0a,
-        0xe0, 0x3c, 0x15, 0x62,
+        0xe0, 0x3c, 0x29, 0x62,
        0xff, 0xea, 0xca, 0x09,
        0x01, 0xe2, 0xc8, 0x31,
        0x01, 0x46, 0xda, 0x35,
        0x01, 0x44, 0xd4, 0x35,
        0x10, 0xea, 0x80, 0x00,
        0x01, 0xe2, 0x6e, 0x36,
-        0x04, 0xa6, 0x0e, 0x7c,
+        0x04, 0xa6, 0x22, 0x7c,
        0xff, 0xea, 0x5a, 0x09,
        0xff, 0xea, 0x4c, 0x0d,
-        0x01, 0xa6, 0x3a, 0x6c,
+        0x01, 0xa6, 0x4e, 0x6c,
        0x10, 0xad, 0x84, 0x78,
-        0x80, 0xad, 0x32, 0x6c,
+        0x80, 0xad, 0x46, 0x6c,
        0x08, 0xad, 0x84, 0x68,
-        0x20, 0x19, 0x26, 0x7c,
+        0x20, 0x19, 0x3a, 0x7c,
        0x80, 0xea, 0xb2, 0x01,
        0x11, 0x00, 0x00, 0x10,
-        0x02, 0xa6, 0x22, 0x7c,
+        0x02, 0xa6, 0x36, 0x7c,
        0xff, 0xea, 0xb2, 0x0d,
        0x11, 0x00, 0x00, 0x10,
        0xff, 0xea, 0xb2, 0x09,
@@ -561,7 +571,7 @@ static uint8_t seqprog[] = {
        0x00, 0x86, 0x0d, 0x23,
        0x00, 0x87, 0x0f, 0x23,
        0x01, 0x84, 0xc5, 0x31,
-        0x80, 0x83, 0x5d, 0x7c,
+        0x80, 0x83, 0x71, 0x7c,
        0x02, 0xe2, 0xc4, 0x01,
        0xff, 0xea, 0x4c, 0x09,
        0x01, 0xe2, 0x36, 0x30,
@@ -572,75 +582,75 @@ static uint8_t seqprog[] = {
        0xfe, 0xa6, 0x4c, 0x0d,
        0x0b, 0x98, 0xe1, 0x30,
        0xfd, 0xa4, 0x49, 0x09,
-        0x80, 0xa3, 0x71, 0x7c,
+        0x80, 0xa3, 0x85, 0x7c,
        0x02, 0xa4, 0x48, 0x01,
        0x01, 0xa4, 0x36, 0x30,
        0xa8, 0xea, 0x32, 0x00,
        0xfd, 0xa4, 0x49, 0x0b,
        0x05, 0xa3, 0x07, 0x33,
-        0x80, 0x83, 0x7d, 0x6c,
+        0x80, 0x83, 0x91, 0x6c,
        0x02, 0xea, 0x4c, 0x05,
        0xff, 0xea, 0x4c, 0x0d,
-        0x00, 0xe2, 0x56, 0x59,
+        0x00, 0xe2, 0x60, 0x59,
-        0x02, 0xa6, 0x10, 0x6c,
+        0x02, 0xa6, 0x24, 0x6c,
        0x80, 0xf9, 0xf2, 0x05,
-        0xc0, 0x39, 0x8b, 0x7c,
+        0xc0, 0x39, 0x9f, 0x7c,
-        0x03, 0xea, 0x64, 0x59,
+        0x03, 0xea, 0x6e, 0x59,
        0x03, 0xea, 0x04, 0x00,
-        0x20, 0x39, 0xaf, 0x7c,
+        0x20, 0x39, 0xc3, 0x7c,
-        0x01, 0x84, 0x95, 0x6c,
+        0x01, 0x84, 0xa9, 0x6c,
-        0x06, 0xea, 0x64, 0x59,
+        0x06, 0xea, 0x6e, 0x59,
        0x06, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0xb2, 0x44,
+        0x00, 0xe2, 0xc6, 0x44,
        0x01, 0x00, 0x6c, 0x32,
-        0xee, 0x00, 0x9e, 0x6c,
+        0xee, 0x00, 0xb2, 0x6c,
        0x05, 0xea, 0xb4, 0x00,
-        0x33, 0xea, 0x5e, 0x59,
+        0x33, 0xea, 0x68, 0x59,
        0x33, 0xea, 0x00, 0x00,
        0x80, 0x3d, 0x7a, 0x00,
-        0xfc, 0x42, 0xa0, 0x7c,
+        0xfc, 0x42, 0xb4, 0x7c,
        0x7f, 0x3d, 0x7a, 0x08,
-        0x00, 0x36, 0x5f, 0x59,
+        0x00, 0x36, 0x69, 0x59,
        0x01, 0x36, 0x01, 0x30,
-        0x09, 0xea, 0x64, 0x59,
+        0x09, 0xea, 0x6e, 0x59,
        0x09, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0x14, 0x42,
+        0x00, 0xe2, 0x28, 0x42,
-        0x01, 0xa4, 0x95, 0x6c,
+        0x01, 0xa4, 0xa9, 0x6c,
-        0x00, 0xe2, 0x68, 0x5c,
+        0x00, 0xe2, 0x7c, 0x5c,
        0x20, 0x39, 0x73, 0x02,
        0x01, 0x00, 0x6c, 0x32,
-        0x02, 0xa6, 0xba, 0x7c,
+        0x02, 0xa6, 0xce, 0x7c,
-        0x00, 0xe2, 0x7e, 0x5c,
+        0x00, 0xe2, 0x92, 0x5c,
        0x00, 0xe2, 0x76, 0x58,
        0x00, 0xe2, 0x86, 0x58,
        0x00, 0xe2, 0x5a, 0x58,
-        0x00, 0x36, 0x5f, 0x59,
+        0x00, 0x36, 0x69, 0x59,
        0x01, 0x36, 0x01, 0x30,
-        0x20, 0x19, 0xba, 0x6c,
+        0x20, 0x19, 0xce, 0x6c,
-        0x00, 0xe2, 0xea, 0x5c,
+        0x00, 0xe2, 0xfe, 0x5c,
-        0x04, 0x19, 0xd4, 0x6c,
+        0x04, 0x19, 0xe8, 0x6c,
        0x02, 0x19, 0x32, 0x00,
-        0x01, 0x84, 0xd5, 0x7c,
+        0x01, 0x84, 0xe9, 0x7c,
-        0x01, 0x1b, 0xce, 0x7c,
+        0x01, 0x1b, 0xe2, 0x7c,
-        0x01, 0x1a, 0xd4, 0x6c,
+        0x01, 0x1a, 0xe8, 0x6c,
-        0x00, 0xe2, 0x84, 0x44,
+        0x00, 0xe2, 0x98, 0x44,
-        0x80, 0x4b, 0xda, 0x6c,
+        0x80, 0x4b, 0xee, 0x6c,
-        0x01, 0x4c, 0xd6, 0x7c,
+        0x01, 0x4c, 0xea, 0x7c,
-        0x03, 0x42, 0x84, 0x6c,
+        0x03, 0x42, 0x98, 0x6c,
-        0x00, 0xe2, 0x0a, 0x5c,
+        0x00, 0xe2, 0x1e, 0x5c,
        0x80, 0xf9, 0xf2, 0x01,
-        0x04, 0x39, 0x15, 0x7a,
+        0x04, 0x39, 0x29, 0x7a,
-        0x00, 0xe2, 0x14, 0x42,
+        0x00, 0xe2, 0x28, 0x42,
-        0x08, 0x5d, 0xf2, 0x6c,
+        0x08, 0x5d, 0x06, 0x6d,
        0x00, 0xe2, 0x76, 0x58,
-        0x00, 0x36, 0x5f, 0x59,
+        0x00, 0x36, 0x69, 0x59,
        0x01, 0x36, 0x01, 0x30,
-        0x02, 0x1b, 0xe2, 0x7c,
+        0x02, 0x1b, 0xf6, 0x7c,
-        0x08, 0x5d, 0xf0, 0x7c,
+        0x08, 0x5d, 0x04, 0x7d,
        0x03, 0x68, 0x00, 0x37,
        0x01, 0x84, 0x09, 0x07,
-        0x80, 0x1b, 0xfc, 0x7c,
+        0x80, 0x1b, 0x10, 0x7d,
-        0x80, 0x84, 0xfd, 0x6c,
+        0x80, 0x84, 0x11, 0x6d,
        0xff, 0x85, 0x0b, 0x1b,
        0xff, 0x86, 0x0d, 0x23,
        0xff, 0x87, 0x0f, 0x23,
@@ -652,161 +662,164 @@ static uint8_t seqprog[] = {
        0xf9, 0xd9, 0xb2, 0x0d,
        0x01, 0xd9, 0xb2, 0x05,
        0x01, 0x52, 0x48, 0x31,
-        0x20, 0xa4, 0x26, 0x7d,
+        0x20, 0xa4, 0x3a, 0x7d,
-        0x20, 0x5b, 0x26, 0x7d,
+        0x20, 0x5b, 0x3a, 0x7d,
-        0x80, 0xf9, 0x34, 0x7d,
+        0x80, 0xf9, 0x48, 0x7d,
        0x02, 0xea, 0xb4, 0x00,
        0x11, 0x00, 0x00, 0x10,
-        0x04, 0x19, 0x40, 0x7d,
+        0x04, 0x19, 0x54, 0x7d,
        0xdf, 0x19, 0x32, 0x08,
-        0x60, 0x5b, 0x40, 0x6d,
+        0x60, 0x5b, 0x54, 0x6d,
-        0x01, 0x4c, 0x1a, 0x7d,
+        0x01, 0x4c, 0x2e, 0x7d,
        0x20, 0x19, 0x32, 0x00,
        0x01, 0xd9, 0xb2, 0x05,
        0x02, 0xea, 0xb4, 0x00,
        0x01, 0xd9, 0xb2, 0x05,
-        0x10, 0x5b, 0x38, 0x6d,
+        0x10, 0x5b, 0x4c, 0x6d,
-        0x08, 0x5b, 0x42, 0x6d,
+        0x08, 0x5b, 0x56, 0x6d,
-        0x20, 0x5b, 0x32, 0x6d,
+        0x20, 0x5b, 0x46, 0x6d,
-        0x02, 0x5b, 0x62, 0x6d,
+        0x02, 0x5b, 0x76, 0x6d,
-        0x0e, 0xea, 0x64, 0x59,
+        0x0e, 0xea, 0x6e, 0x59,
        0x0e, 0xea, 0x04, 0x00,
-        0x80, 0xf9, 0x22, 0x6d,
+        0x80, 0xf9, 0x36, 0x6d,
        0xdf, 0x5c, 0xb8, 0x08,
        0x01, 0xd9, 0xb2, 0x05,
-        0x01, 0xa4, 0x1d, 0x6e,
+        0x01, 0xa4, 0x37, 0x6e,
-        0x00, 0xe2, 0x68, 0x5c,
+        0x00, 0xe2, 0x7c, 0x5c,
-        0x00, 0xe2, 0x6c, 0x5d,
+        0x00, 0xe2, 0x80, 0x5d,
        0x01, 0x90, 0x21, 0x1b,
        0x01, 0xd9, 0xb2, 0x05,
-        0x00, 0xe2, 0x52, 0x5b,
+        0x00, 0xe2, 0x66, 0x5b,
        0xf3, 0x96, 0xd5, 0x19,
-        0x00, 0xe2, 0x50, 0x55,
+        0x00, 0xe2, 0x64, 0x55,
-        0x80, 0x96, 0x51, 0x6d,
+        0x80, 0x96, 0x65, 0x6d,
-        0x0f, 0xea, 0x64, 0x59,
+        0x0f, 0xea, 0x6e, 0x59,
        0x0f, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0x58, 0x45,
+        0x00, 0xe2, 0x6c, 0x45,
        0x04, 0x8c, 0xe1, 0x30,
        0x01, 0xea, 0xf2, 0x00,
        0x02, 0xea, 0x36, 0x00,
        0xa8, 0xea, 0x32, 0x00,
-        0xff, 0x97, 0x5f, 0x7d,
+        0xff, 0x97, 0x73, 0x7d,
-        0x14, 0xea, 0x64, 0x59,
+        0x14, 0xea, 0x6e, 0x59,
        0x14, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0xce, 0x5d,
+        0x00, 0xe2, 0xe2, 0x5d,
        0x01, 0xd9, 0xb2, 0x05,
        0x09, 0x80, 0xe1, 0x30,
        0x02, 0xea, 0x36, 0x00,
        0xa8, 0xea, 0x32, 0x00,
-        0x00, 0xe2, 0xc6, 0x5d,
+        0x00, 0xe2, 0xda, 0x5d,
        0x01, 0xd9, 0xb2, 0x05,
-        0x02, 0xa6, 0x7c, 0x7d,
+        0x02, 0xa6, 0x90, 0x7d,
-        0x00, 0xe2, 0x56, 0x59,
+        0x00, 0xe2, 0x60, 0x59,
-        0x20, 0x5b, 0x8a, 0x6d,
+        0x20, 0x5b, 0x9e, 0x6d,
-        0xfc, 0x42, 0x76, 0x7d,
+        0xfc, 0x42, 0x8a, 0x7d,
-        0x10, 0x40, 0x78, 0x6d,
+        0x10, 0x40, 0x8c, 0x6d,
-        0x20, 0x4d, 0x7a, 0x7d,
+        0x20, 0x4d, 0x8e, 0x7d,
-        0x08, 0x5d, 0x8a, 0x6d,
+        0x08, 0x5d, 0x9e, 0x6d,
-        0x02, 0xa6, 0x10, 0x6c,
+        0x02, 0xa6, 0x24, 0x6c,
-        0x00, 0xe2, 0x56, 0x59,
+        0x00, 0xe2, 0x60, 0x59,
-        0x20, 0x5b, 0x8a, 0x6d,
+        0x20, 0x5b, 0x9e, 0x6d,
-        0x01, 0x1b, 0xaa, 0x6d,
+        0x01, 0x1b, 0xbe, 0x6d,
-        0xfc, 0x42, 0x86, 0x7d,
+        0xfc, 0x42, 0x9a, 0x7d,
-        0x10, 0x40, 0x88, 0x6d,
+        0x10, 0x40, 0x9c, 0x6d,
        0x20, 0x4d, 0x84, 0x78,
        0x08, 0x5d, 0x84, 0x78,
        0x02, 0x19, 0x32, 0x00,
        0x01, 0x5b, 0x40, 0x31,
-        0x00, 0xe2, 0xea, 0x5c,
+        0x00, 0xe2, 0xfe, 0x5c,
-        0x00, 0xe2, 0xcc, 0x5b,
+        0x00, 0xe2, 0xe0, 0x5b,
        0x20, 0xea, 0xb6, 0x00,
-        0x00, 0xe2, 0x0a, 0x5c,
+        0x00, 0xe2, 0x1e, 0x5c,
        0x20, 0x5c, 0xb8, 0x00,
-        0x04, 0x19, 0xa0, 0x6d,
+        0x04, 0x19, 0xb4, 0x6d,
-        0x01, 0x1a, 0xa0, 0x6d,
+        0x01, 0x1a, 0xb4, 0x6d,
-        0x00, 0xe2, 0x56, 0x59,
+        0x00, 0xe2, 0x60, 0x59,
        0x01, 0x1a, 0x84, 0x78,
        0x80, 0xf9, 0xf2, 0x01,
-        0x20, 0xa0, 0x04, 0x7e,
+        0x20, 0xa0, 0x18, 0x7e,
        0xff, 0x90, 0x21, 0x1b,
-        0x08, 0x92, 0x63, 0x6b,
+        0x08, 0x92, 0x77, 0x6b,
        0x02, 0xea, 0xb4, 0x04,
        0x01, 0xa4, 0x49, 0x03,
-        0x40, 0x5b, 0xba, 0x6d,
+        0x40, 0x5b, 0xce, 0x6d,
-        0x00, 0xe2, 0x56, 0x59,
+        0x00, 0xe2, 0x60, 0x59,
-        0x40, 0x5b, 0xba, 0x6d,
+        0x40, 0x5b, 0xce, 0x6d,
-        0x04, 0x5d, 0x1e, 0x7e,
+        0x04, 0x5d, 0x38, 0x7e,
-        0x01, 0x1a, 0x1e, 0x7e,
+        0x01, 0x1a, 0x38, 0x7e,
        0x20, 0x4d, 0x84, 0x78,
-        0x40, 0x5b, 0x04, 0x7e,
+        0x40, 0x5b, 0x18, 0x7e,
-        0x04, 0x5d, 0x1e, 0x7e,
+        0x04, 0x5d, 0x38, 0x7e,
-        0x01, 0x1a, 0x1e, 0x7e,
+        0x01, 0x1a, 0x38, 0x7e,
        0x80, 0xf9, 0xf2, 0x01,
        0xff, 0x90, 0x21, 0x1b,
-        0x08, 0x92, 0x63, 0x6b,
+        0x08, 0x92, 0x77, 0x6b,
        0x02, 0xea, 0xb4, 0x04,
-        0x00, 0xe2, 0x56, 0x59,
+        0x00, 0xe2, 0x60, 0x59,
        0x01, 0x1b, 0x84, 0x78,
        0x80, 0xf9, 0xf2, 0x01,
        0x02, 0xea, 0xb4, 0x04,
-        0x00, 0xe2, 0x56, 0x59,
+        0x00, 0xe2, 0x60, 0x59,
-        0x01, 0x1b, 0xe2, 0x6d,
+        0x01, 0x1b, 0xf6, 0x6d,
-        0x40, 0x5b, 0xf0, 0x7d,
+        0x40, 0x5b, 0x04, 0x7e,
-        0x01, 0x1b, 0xe2, 0x6d,
+        0x01, 0x1b, 0xf6, 0x6d,
        0x02, 0x19, 0x32, 0x00,
        0x01, 0x1a, 0x84, 0x78,
        0x80, 0xf9, 0xf2, 0x01,
        0xff, 0xea, 0x10, 0x03,
        0x08, 0x92, 0x25, 0x03,
-        0x00, 0xe2, 0x62, 0x43,
+        0x00, 0xe2, 0x76, 0x43,
-        0x01, 0x1a, 0xec, 0x7d,
+        0x01, 0x1a, 0x00, 0x7e,
-        0x40, 0x5b, 0xe8, 0x7d,
+        0x40, 0x5b, 0xfc, 0x7d,
-        0x01, 0x1a, 0xd6, 0x6d,
+        0x01, 0x1a, 0xea, 0x6d,
        0xfc, 0x42, 0x84, 0x78,
-        0x01, 0x1a, 0xf0, 0x6d,
+        0x01, 0x1a, 0x04, 0x6e,
-        0x10, 0xea, 0x64, 0x59,
+        0x10, 0xea, 0x6e, 0x59,
        0x10, 0xea, 0x04, 0x00,
        0xfc, 0x42, 0x84, 0x78,
-        0x10, 0x40, 0xf6, 0x6d,
+        0x10, 0x40, 0x0a, 0x6e,
        0x20, 0x4d, 0x84, 0x78,
-        0x40, 0x5b, 0xd6, 0x6d,
+        0x40, 0x5b, 0xea, 0x6d,
        0x01, 0x1a, 0x84, 0x78,
        0x01, 0x90, 0x21, 0x1b,
        0x30, 0x3f, 0xc0, 0x09,
        0x30, 0xe0, 0x84, 0x60,
        0x40, 0x4b, 0x84, 0x68,
        0xff, 0xea, 0x52, 0x01,
-        0xee, 0x00, 0x0c, 0x6e,
+        0xee, 0x00, 0x20, 0x6e,
        0x80, 0xf9, 0xf2, 0x01,
        0xff, 0x90, 0x21, 0x1b,
        0x02, 0xea, 0xb4, 0x00,
        0x20, 0xea, 0x9a, 0x00,
-        0xf3, 0x42, 0x16, 0x6e,
+        0x04, 0x41, 0x26, 0x7e,
-        0x12, 0xea, 0x64, 0x59,
+        0x08, 0xea, 0x98, 0x00,
+        0x08, 0x57, 0xae, 0x00,
+        0xf3, 0x42, 0x30, 0x6e,
+        0x12, 0xea, 0x6e, 0x59,
        0x12, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0x14, 0x42,
+        0x00, 0xe2, 0x28, 0x42,
-        0x0d, 0xea, 0x64, 0x59,
+        0x0d, 0xea, 0x6e, 0x59,
        0x0d, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0x14, 0x42,
+        0x00, 0xe2, 0x28, 0x42,
        0x01, 0x90, 0x21, 0x1b,
-        0x11, 0xea, 0x64, 0x59,
+        0x11, 0xea, 0x6e, 0x59,
        0x11, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0x52, 0x5b,
+        0x00, 0xe2, 0x66, 0x5b,
        0x08, 0x5a, 0xb4, 0x00,
-        0x00, 0xe2, 0x44, 0x5e,
+        0x00, 0xe2, 0x5e, 0x5e,
        0xa8, 0xea, 0x32, 0x00,
-        0x00, 0xe2, 0x56, 0x59,
+        0x00, 0xe2, 0x60, 0x59,
-        0x80, 0x1a, 0x32, 0x7e,
+        0x80, 0x1a, 0x4c, 0x7e,
-        0x00, 0xe2, 0x44, 0x5e,
+        0x00, 0xe2, 0x5e, 0x5e,
        0x80, 0x19, 0x32, 0x00,
-        0x40, 0x5b, 0x38, 0x6e,
+        0x40, 0x5b, 0x52, 0x6e,
-        0x08, 0x5a, 0x38, 0x7e,
+        0x08, 0x5a, 0x52, 0x7e,
        0x20, 0x4d, 0x84, 0x78,
        0x02, 0x84, 0x09, 0x03,
-        0x40, 0x5b, 0x04, 0x7e,
+        0x40, 0x5b, 0x18, 0x7e,
        0xff, 0x90, 0x21, 0x1b,
        0x80, 0xf9, 0xf2, 0x01,
-        0x08, 0x92, 0x63, 0x6b,
+        0x08, 0x92, 0x77, 0x6b,
        0x02, 0xea, 0xb4, 0x04,
        0x01, 0x40, 0xe1, 0x30,
        0x05, 0x41, 0xe3, 0x98,
@@ -1039,138 +1052,138 @@ static struct patch {
        { ahd_patch0_func, 64, 1, 1 },
        { ahd_patch2_func, 67, 1, 2 },
        { ahd_patch0_func, 68, 1, 1 },
-        { ahd_patch4_func, 116, 1, 1 },
+        { ahd_patch4_func, 115, 1, 1 },
-        { ahd_patch2_func, 175, 3, 1 },
+        { ahd_patch2_func, 180, 3, 1 },
-        { ahd_patch1_func, 178, 2, 1 },
+        { ahd_patch1_func, 183, 2, 1 },
-        { ahd_patch5_func, 180, 1, 1 },
+        { ahd_patch5_func, 185, 1, 1 },
-        { ahd_patch2_func, 189, 1, 2 },
+        { ahd_patch2_func, 194, 1, 2 },
-        { ahd_patch0_func, 190, 1, 1 },
+        { ahd_patch0_func, 195, 1, 1 },
-        { ahd_patch6_func, 191, 2, 2 },
+        { ahd_patch6_func, 196, 2, 2 },
-        { ahd_patch0_func, 193, 6, 3 },
+        { ahd_patch0_func, 198, 6, 3 },
-        { ahd_patch2_func, 196, 1, 2 },
+        { ahd_patch2_func, 201, 1, 2 },
-        { ahd_patch0_func, 197, 1, 1 },
+        { ahd_patch0_func, 202, 1, 1 },
-        { ahd_patch2_func, 200, 1, 2 },
+        { ahd_patch2_func, 205, 1, 2 },
-        { ahd_patch0_func, 201, 1, 1 },
+        { ahd_patch0_func, 206, 1, 1 },
-        { ahd_patch3_func, 203, 1, 1 },
+        { ahd_patch3_func, 208, 1, 1 },
-        { ahd_patch7_func, 204, 3, 1 },
+        { ahd_patch7_func, 209, 3, 1 },
-        { ahd_patch3_func, 213, 1, 1 },
+        { ahd_patch3_func, 218, 1, 1 },
-        { ahd_patch5_func, 214, 16, 2 },
+        { ahd_patch5_func, 219, 16, 2 },
-        { ahd_patch0_func, 230, 1, 1 },
+        { ahd_patch0_func, 235, 1, 1 },
-        { ahd_patch8_func, 250, 2, 1 },
+        { ahd_patch8_func, 260, 2, 1 },
-        { ahd_patch1_func, 254, 1, 2 },
+        { ahd_patch1_func, 264, 1, 2 },
-        { ahd_patch0_func, 255, 1, 1 },
+        { ahd_patch0_func, 265, 1, 1 },
-        { ahd_patch7_func, 258, 3, 1 },
+        { ahd_patch7_func, 268, 3, 1 },
-        { ahd_patch1_func, 273, 1, 2 },
+        { ahd_patch1_func, 283, 1, 2 },
-        { ahd_patch0_func, 274, 1, 1 },
+        { ahd_patch0_func, 284, 1, 1 },
-        { ahd_patch1_func, 277, 1, 2 },
+        { ahd_patch1_func, 287, 1, 2 },
-        { ahd_patch0_func, 278, 1, 1 },
+        { ahd_patch0_func, 288, 1, 1 },
-        { ahd_patch2_func, 281, 1, 2 },
+        { ahd_patch2_func, 291, 1, 2 },
-        { ahd_patch0_func, 282, 1, 1 },
+        { ahd_patch0_func, 292, 1, 1 },
-        { ahd_patch9_func, 295, 2, 2 },
+        { ahd_patch9_func, 305, 2, 2 },
-        { ahd_patch0_func, 297, 1, 1 },
+        { ahd_patch0_func, 307, 1, 1 },
-        { ahd_patch1_func, 339, 1, 2 },
+        { ahd_patch1_func, 349, 1, 2 },
-        { ahd_patch0_func, 340, 1, 1 },
+        { ahd_patch0_func, 350, 1, 1 },
-        { ahd_patch2_func, 348, 1, 2 },
+        { ahd_patch2_func, 358, 1, 2 },
-        { ahd_patch0_func, 349, 1, 1 },
+        { ahd_patch0_func, 359, 1, 1 },
-        { ahd_patch2_func, 352, 1, 2 },
+        { ahd_patch2_func, 362, 1, 2 },
-        { ahd_patch0_func, 353, 1, 1 },
-        { ahd_patch1_func, 359, 1, 2 },
-        { ahd_patch0_func, 360, 1, 1 },
-        { ahd_patch1_func, 362, 1, 2 },
        { ahd_patch0_func, 363, 1, 1 },
-        { ahd_patch10_func, 382, 1, 1 },
+        { ahd_patch1_func, 369, 1, 2 },
-        { ahd_patch10_func, 385, 1, 1 },
+        { ahd_patch0_func, 370, 1, 1 },
-        { ahd_patch10_func, 387, 1, 1 },
+        { ahd_patch1_func, 372, 1, 2 },
-        { ahd_patch10_func, 399, 1, 1 },
+        { ahd_patch0_func, 373, 1, 1 },
-        { ahd_patch1_func, 409, 1, 2 },
+        { ahd_patch10_func, 392, 1, 1 },
-        { ahd_patch0_func, 410, 1, 1 },
+        { ahd_patch10_func, 395, 1, 1 },
-        { ahd_patch1_func, 412, 1, 2 },
+        { ahd_patch10_func, 397, 1, 1 },
-        { ahd_patch0_func, 413, 1, 1 },
+        { ahd_patch10_func, 409, 1, 1 },
-        { ahd_patch1_func, 421, 1, 2 },
+        { ahd_patch1_func, 419, 1, 2 },
-        { ahd_patch0_func, 422, 1, 1 },
+        { ahd_patch0_func, 420, 1, 1 },
-        { ahd_patch2_func, 435, 1, 2 },
+        { ahd_patch1_func, 422, 1, 2 },
-        { ahd_patch0_func, 436, 1, 1 },
+        { ahd_patch0_func, 423, 1, 1 },
-        { ahd_patch11_func, 472, 1, 1 },
+        { ahd_patch1_func, 431, 1, 2 },
-        { ahd_patch1_func, 480, 1, 2 },
+        { ahd_patch0_func, 432, 1, 1 },
-        { ahd_patch0_func, 481, 1, 1 },
+        { ahd_patch2_func, 445, 1, 2 },
-        { ahd_patch2_func, 493, 1, 2 },
+        { ahd_patch0_func, 446, 1, 1 },
-        { ahd_patch0_func, 494, 1, 1 },
+        { ahd_patch11_func, 482, 1, 1 },
-        { ahd_patch12_func, 497, 6, 2 },
+        { ahd_patch1_func, 490, 1, 2 },
-        { ahd_patch0_func, 503, 1, 1 },
+        { ahd_patch0_func, 491, 1, 1 },
-        { ahd_patch13_func, 524, 7, 1 },
+        { ahd_patch2_func, 503, 1, 2 },
-        { ahd_patch14_func, 533, 1, 1 },
+        { ahd_patch0_func, 504, 1, 1 },
-        { ahd_patch15_func, 542, 1, 1 },
+        { ahd_patch12_func, 507, 6, 2 },
-        { ahd_patch16_func, 543, 1, 2 },
+        { ahd_patch0_func, 513, 1, 1 },
-        { ahd_patch0_func, 544, 1, 1 },
+        { ahd_patch13_func, 534, 7, 1 },
-        { ahd_patch17_func, 547, 1, 1 },
+        { ahd_patch14_func, 543, 1, 1 },
-        { ahd_patch16_func, 548, 1, 1 },
+        { ahd_patch15_func, 552, 1, 1 },
-        { ahd_patch18_func, 559, 1, 2 },
+        { ahd_patch16_func, 553, 1, 2 },
-        { ahd_patch0_func, 560, 1, 1 },
+        { ahd_patch0_func, 554, 1, 1 },
-        { ahd_patch1_func, 579, 1, 2 },
+        { ahd_patch17_func, 557, 1, 1 },
-        { ahd_patch0_func, 580, 1, 1 },
+        { ahd_patch16_func, 558, 1, 1 },
-        { ahd_patch1_func, 583, 1, 2 },
+        { ahd_patch18_func, 569, 1, 2 },
-        { ahd_patch0_func, 584, 1, 1 },
+        { ahd_patch0_func, 570, 1, 1 },
-        { ahd_patch2_func, 589, 1, 2 },
+        { ahd_patch1_func, 589, 1, 2 },
        { ahd_patch0_func, 590, 1, 1 },
-        { ahd_patch2_func, 594, 1, 2 },
+        { ahd_patch1_func, 593, 1, 2 },
-        { ahd_patch0_func, 595, 1, 1 },
+        { ahd_patch0_func, 594, 1, 1 },
-        { ahd_patch1_func, 596, 1, 2 },
+        { ahd_patch2_func, 599, 1, 2 },
-        { ahd_patch0_func, 597, 1, 1 },
+        { ahd_patch0_func, 600, 1, 1 },
-        { ahd_patch2_func, 608, 1, 2 },
+        { ahd_patch2_func, 604, 1, 2 },
-        { ahd_patch0_func, 609, 1, 1 },
+        { ahd_patch0_func, 605, 1, 1 },
-        { ahd_patch19_func, 613, 1, 1 },
+        { ahd_patch1_func, 606, 1, 2 },
-        { ahd_patch20_func, 618, 1, 1 },
+        { ahd_patch0_func, 607, 1, 1 },
-        { ahd_patch21_func, 619, 2, 1 },
+        { ahd_patch2_func, 618, 1, 2 },
-        { ahd_patch20_func, 623, 1, 2 },
+        { ahd_patch0_func, 619, 1, 1 },
-        { ahd_patch0_func, 624, 1, 1 },
+        { ahd_patch19_func, 623, 1, 1 },
-        { ahd_patch2_func, 627, 1, 2 },
+        { ahd_patch20_func, 628, 1, 1 },
-        { ahd_patch0_func, 628, 1, 1 },
+        { ahd_patch21_func, 629, 2, 1 },
-        { ahd_patch2_func, 643, 1, 2 },
+        { ahd_patch20_func, 633, 1, 2 },
-        { ahd_patch0_func, 644, 1, 1 },
+        { ahd_patch0_func, 634, 1, 1 },
-        { ahd_patch13_func, 645, 14, 1 },
+        { ahd_patch2_func, 637, 1, 2 },
-        { ahd_patch1_func, 663, 1, 2 },
+        { ahd_patch0_func, 638, 1, 1 },
-        { ahd_patch0_func, 664, 1, 1 },
+        { ahd_patch2_func, 653, 1, 2 },
-        { ahd_patch13_func, 665, 1, 1 },
+        { ahd_patch0_func, 654, 1, 1 },
-        { ahd_patch1_func, 677, 1, 2 },
+        { ahd_patch13_func, 655, 14, 1 },
-        { ahd_patch0_func, 678, 1, 1 },
+        { ahd_patch1_func, 673, 1, 2 },
-        { ahd_patch1_func, 685, 1, 2 },
+        { ahd_patch0_func, 674, 1, 1 },
-        { ahd_patch0_func, 686, 1, 1 },
+        { ahd_patch13_func, 675, 1, 1 },
-        { ahd_patch19_func, 709, 1, 1 },
+        { ahd_patch1_func, 687, 1, 2 },
-        { ahd_patch19_func, 747, 1, 1 },
+        { ahd_patch0_func, 688, 1, 1 },
-        { ahd_patch1_func, 758, 1, 2 },
+        { ahd_patch1_func, 695, 1, 2 },
-        { ahd_patch0_func, 759, 1, 1 },
+        { ahd_patch0_func, 696, 1, 1 },
-        { ahd_patch1_func, 776, 1, 2 },
+        { ahd_patch19_func, 719, 1, 1 },
-        { ahd_patch0_func, 777, 1, 1 },
+        { ahd_patch19_func, 757, 1, 1 },
-        { ahd_patch1_func, 779, 1, 2 },
+        { ahd_patch1_func, 768, 1, 2 },
-        { ahd_patch0_func, 780, 1, 1 },
+        { ahd_patch0_func, 769, 1, 1 },
-        { ahd_patch1_func, 783, 1, 2 },
+        { ahd_patch7_func, 785, 3, 1 },
-        { ahd_patch0_func, 784, 1, 1 },
+        { ahd_patch1_func, 789, 1, 2 },
-        { ahd_patch22_func, 786, 1, 2 },
+        { ahd_patch0_func, 790, 1, 1 },
-        { ahd_patch0_func, 787, 2, 1 },
+        { ahd_patch1_func, 792, 1, 2 },
-        { ahd_patch23_func, 790, 4, 2 },
+        { ahd_patch0_func, 793, 1, 1 },
-        { ahd_patch0_func, 794, 1, 1 },
+        { ahd_patch1_func, 796, 1, 2 },
-        { ahd_patch23_func, 802, 11, 1 }
+        { ahd_patch0_func, 797, 1, 1 },
+        { ahd_patch22_func, 799, 1, 2 },
+        { ahd_patch0_func, 800, 2, 1 },
+        { ahd_patch23_func, 803, 4, 2 },
+        { ahd_patch0_func, 807, 1, 1 },
+        { ahd_patch23_func, 815, 11, 1 }
 };
 static struct cs {
        uint16_t        begin;
        uint16_t        end;
 } critical_sections[] = {
-        { 17, 28 },
+        { 17, 30 },
-        { 29, 30 },
        { 47, 58 },
        { 61, 63 },
        { 65, 66 },
        { 72, 92 },
-        { 110, 137 },
+        { 110, 142 },
-        { 138, 175 },
+        { 143, 180 },
-        { 180, 188 },
+        { 185, 193 },
-        { 213, 264 },
+        { 218, 274 },
-        { 425, 433 },
+        { 435, 443 },
-        { 443, 445 },
+        { 453, 455 },
-        { 448, 457 },
+        { 458, 467 },
-        { 709, 739 },
+        { 719, 749 },
-        { 749, 753 }
+        { 759, 763 }
 };
 static const int num_critical_sections = sizeof(critical_sections)
diff --git a/drivers/scsi/aic7xxx/aicasm/aicasm.c b/drivers/scsi/aic7xxx/aicasm/aicasm.c
index f936b691232f..924102720b14 100644
--- a/drivers/scsi/aic7xxx/aicasm/aicasm.c
+++ b/drivers/scsi/aic7xxx/aicasm/aicasm.c
@@ -37,7 +37,7 @@
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 *
- * $Id: //depot/aic7xxx/aic7xxx/aicasm/aicasm.c#22 $
+ * $Id: //depot/aic7xxx/aic7xxx/aicasm/aicasm.c#23 $
 *
 * $FreeBSD$
 */
@@ -609,10 +609,10 @@ output_listing(char *ifilename)
                while (line < cur_instr->srcline) {
                        fgets(buf, sizeof(buf), ifile);
-                                fprintf(listfile, "\t\t%s", buf);
+                                fprintf(listfile, "             \t%s", buf);
                                line++;
                }
-                fprintf(listfile, "%03x %02x%02x%02x%02x", instrptr,
+                fprintf(listfile, "%04x %02x%02x%02x%02x", instrptr,
 #ifdef __LITTLE_ENDIAN
                        cur_instr->format.bytes[0],
                        cur_instr->format.bytes[1],
@@ -624,14 +624,23 @@ output_listing(char *ifilename)
                        cur_instr->format.bytes[1],
                        cur_instr->format.bytes[0]);
 #endif
-                fgets(buf, sizeof(buf), ifile);
+                /*
-                fprintf(listfile, "\t%s", buf);
+                 * Macro expansions can cause several instructions
-                line++;
+                 * to be output for a single source line.  Only
+                 * advance the line once in these cases.
+                 */
+                if (line == cur_instr->srcline) {
+                        fgets(buf, sizeof(buf), ifile);
+                        fprintf(listfile, "\t%s", buf);
+                        line++;
+                } else {
+                        fprintf(listfile, "\n");
+                }
                instrptr++;
        }
        /* Dump the remainder of the file */
        while(fgets(buf, sizeof(buf), ifile) != NULL)
-                fprintf(listfile, "\t\t%s", buf);
+                fprintf(listfile, "             %s", buf);
        fclose(ifile);
 }
diff --git a/drivers/scsi/aic7xxx/aicasm/aicasm_gram.y b/drivers/scsi/aic7xxx/aicasm/aicasm_gram.y
index 67e046d96625..c328596def3c 100644
--- a/drivers/scsi/aic7xxx/aicasm/aicasm_gram.y
+++ b/drivers/scsi/aic7xxx/aicasm/aicasm_gram.y
@@ -38,7 +38,7 @@
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 *
- * $Id: //depot/aic7xxx/aic7xxx/aicasm/aicasm_gram.y#29 $
+ * $Id: //depot/aic7xxx/aic7xxx/aicasm/aicasm_gram.y#30 $
 *
 * $FreeBSD$
 */
@@ -157,6 +157,8 @@ static int  is_download_const(expression_t *immed);
 %token T_END_CS
+%token T_PAD_PAGE
 %token T_FIELD
 %token T_ENUM
@@ -189,6 +191,10 @@ static int  is_download_const(expression_t *immed);
 %token <value> T_OR
+/* 16 bit extensions */
+%token <value> T_OR16 T_AND16 T_XOR16 T_ADD16
+%token <value> T_ADC16 T_MVI16 T_TEST16 T_CMP16 T_CMPXCHG
 %token T_RET
 %token T_NOP
@@ -207,7 +213,7 @@ static int  is_download_const(expression_t *immed);
 %type <expression> expression immediate immediate_or_a
-%type <value> export ret f1_opcode f2_opcode jmp_jc_jnc_call jz_jnz je_jne
+%type <value> export ret f1_opcode f2_opcode f4_opcode jmp_jc_jnc_call jz_jnz je_jne
 %type <value> mode_value mode_list macro_arglist
@@ -1304,6 +1310,15 @@ f2_opcode:
 |       T_ROR { $$ = AIC_OP_ROR; }
 ;
+f4_opcode:
+        T_OR16  { $$ = AIC_OP_OR16; }
+|       T_AND16 { $$ = AIC_OP_AND16; }
+|       T_XOR16 { $$ = AIC_OP_XOR16; }
+|       T_ADD16 { $$ = AIC_OP_ADD16; }
+|       T_ADC16 { $$ = AIC_OP_ADC16; }
+|       T_MVI16 { $$ = AIC_OP_MVI16; }
+;
 code:
        f2_opcode destination ',' expression opt_source ret ';'
        {
diff --git a/drivers/scsi/aic7xxx/aicasm/aicasm_insformat.h b/drivers/scsi/aic7xxx/aicasm/aicasm_insformat.h
index e64f802bbaaa..9df9e2ce3538 100644
--- a/drivers/scsi/aic7xxx/aicasm/aicasm_insformat.h
+++ b/drivers/scsi/aic7xxx/aicasm/aicasm_insformat.h
@@ -37,13 +37,14 @@
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 *
- * $Id: //depot/aic7xxx/aic7xxx/aicasm/aicasm_insformat.h#11 $
+ * $Id: //depot/aic7xxx/aic7xxx/aicasm/aicasm_insformat.h#12 $
 *
 * $FreeBSD$
 */
 #include <asm/byteorder.h>
+/* 8bit ALU logic operations */
 struct ins_format1 {
 #ifdef __LITTLE_ENDIAN
        uint32_t        immediate       : 8,
@@ -62,6 +63,7 @@ struct ins_format1 {
 #endif
 };
+/* 8bit ALU shift/rotate operations */
 struct ins_format2 {
 #ifdef __LITTLE_ENDIAN
        uint32_t        shift_control   : 8,
@@ -80,6 +82,7 @@ struct ins_format2 {
 #endif
 };
+/* 8bit branch control operations */
 struct ins_format3 {
 #ifdef __LITTLE_ENDIAN
        uint32_t        immediate       : 8,
@@ -96,10 +99,68 @@ struct ins_format3 {
 #endif
 };
+/* 16bit ALU logic operations */
+struct ins_format4 {
+#ifdef __LITTLE_ENDIAN
+        uint32_t        opcode_ext      : 8,
+                        source          : 9,
+                        destination     : 9,
+                        ret             : 1,
+                        opcode          : 4,
+                        parity          : 1;
+#else
+        uint32_t        parity          : 1,
+                        opcode          : 4,
+                        ret             : 1,
+                        destination     : 9,
+                        source          : 9,
+                        opcode_ext      : 8;
+#endif
+};
+/* 16bit branch control operations */
+struct ins_format5 {
+#ifdef __LITTLE_ENDIAN
+        uint32_t        opcode_ext      : 8,
+                        source          : 9,
+                        address         : 10,
+                        opcode          : 4,
+                        parity          : 1;
+#else
+        uint32_t        parity          : 1,
+                        opcode          : 4,
+                        address         : 10,
+                        source          : 9,
+                        opcode_ext      : 8;
+#endif
+};
+/*  Far branch operations */
+struct ins_format6 {
+#ifdef __LITTLE_ENDIAN
+        uint32_t        page            : 3,
+                        opcode_ext      : 5,
+                        source          : 9,
+                        address         : 10,
+                        opcode          : 4,
+                        parity          : 1;
+#else
+        uint32_t        parity          : 1,
+                        opcode          : 4,
+                        address         : 10,
+                        source          : 9,
+                        opcode_ext      : 5,
+                        page            : 3;
+#endif
+};
 union ins_formats {
                struct ins_format1 format1;
                struct ins_format2 format2;
                struct ins_format3 format3;
+                struct ins_format4 format4;
+                struct ins_format5 format5;
+                struct ins_format6 format6;
                uint8_t            bytes[4];
                uint32_t           integer;
 };
@@ -118,6 +179,8 @@ struct instruction {
 #define AIC_OP_ROL      0x5
 #define AIC_OP_BMOV     0x6
+#define AIC_OP_MVI16    0x7
 #define AIC_OP_JMP      0x8
 #define AIC_OP_JC       0x9
 #define AIC_OP_JNC      0xa
@@ -131,3 +194,26 @@ struct instruction {
 #define AIC_OP_SHL      0x10
 #define AIC_OP_SHR      0x20
 #define AIC_OP_ROR      0x30
+/* 16bit Ops. Low byte main opcode.  High byte extended opcode. */ 
+#define AIC_OP_OR16     0x8005
+#define AIC_OP_AND16    0x8105
+#define AIC_OP_XOR16    0x8205
+#define AIC_OP_ADD16    0x8305
+#define AIC_OP_ADC16    0x8405
+#define AIC_OP_JNE16    0x8805
+#define AIC_OP_JNZ16    0x8905
+#define AIC_OP_JE16     0x8C05
+#define AIC_OP_JZ16     0x8B05
+#define AIC_OP_JMP16    0x9005
+#define AIC_OP_JC16     0x9105
+#define AIC_OP_JNC16    0x9205
+#define AIC_OP_CALL16   0x9305
+#define AIC_OP_CALL16   0x9305
+/* Page extension is low three bits of second opcode byte. */
+#define AIC_OP_JMPF     0xA005
+#define AIC_OP_CALLF    0xB005
+#define AIC_OP_JCF      0xC005
+#define AIC_OP_JNCF     0xD005
+#define AIC_OP_CMPXCHG  0xE005
diff --git a/drivers/scsi/aic7xxx/aicasm/aicasm_scan.l b/drivers/scsi/aic7xxx/aicasm/aicasm_scan.l
index 45c0b233d0bc..7c3983f868a9 100644
--- a/drivers/scsi/aic7xxx/aicasm/aicasm_scan.l
+++ b/drivers/scsi/aic7xxx/aicasm/aicasm_scan.l
@@ -38,7 +38,7 @@
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 *
- * $Id: //depot/aic7xxx/aic7xxx/aicasm/aicasm_scan.l#19 $
+ * $Id: //depot/aic7xxx/aic7xxx/aicasm/aicasm_scan.l#20 $
 *
 * $FreeBSD$
 */
@@ -132,7 +132,7 @@ if[ \t]*\(		{
                                                *string_buf_ptr++ = *yptr++;
                                }
                        }
+else                    { return T_ELSE; }
 VERSION                 { return T_VERSION; }
 PREFIX                  { return T_PREFIX; }
 PATCH_ARG_LIST          { return T_PATCH_ARG_LIST; }
@@ -173,10 +173,6 @@ RW|RO|WO		{
                                        yylval.value = WO;
                                 return T_MODE;
                        }
-BEGIN_CRITICAL          { return T_BEGIN_CS; }
-END_CRITICAL            { return T_END_CS; }
-SET_SRC_MODE            { return T_SET_SRC_MODE; }
-SET_DST_MODE            { return T_SET_DST_MODE; }
 field                   { return T_FIELD; }
 enum                    { return T_ENUM; }
 mask                    { return T_MASK; }
@@ -192,6 +188,13 @@ none			{ return T_NONE; }
 sindex                  { return T_SINDEX; }
 A                       { return T_A; }
+        /* Instruction Formatting */
+PAD_PAGE                { return T_PAD_PAGE; }
+BEGIN_CRITICAL          { return T_BEGIN_CS; }
+END_CRITICAL            { return T_END_CS; }
+SET_SRC_MODE            { return T_SET_SRC_MODE; }
+SET_DST_MODE            { return T_SET_DST_MODE; }
        /* Opcodes */
 shl                     { return T_SHL; }
 shr                     { return T_SHR; }
@@ -223,7 +226,17 @@ and			{ return T_AND;	}
 or                      { return T_OR;  }
 ret                     { return T_RET; }
 nop                     { return T_NOP; }
-else                    { return T_ELSE; }
+        /* ARP2 16bit extensions */
+or16                    { return T_OR16; }
+and16                   { return T_AND16; }
+xor16                   { return T_XOR16; }
+add16                   { return T_ADD16; }
+adc16                   { return T_ADC16; }
+mvi16                   { return T_MVI16; }
+test16                  { return T_TEST16; }
+cmp16                   { return T_CMP16; }
+cmpxchg                 { return T_CMPXCHG; }
        /* Allowed Symbols */
 \<\<                    { return T_EXPR_LSHIFT; }
diff --git a/drivers/scsi/dc395x.c b/drivers/scsi/dc395x.c
index c8a32cf47d73..cbf825263f3b 100644
--- a/drivers/scsi/dc395x.c
+++ b/drivers/scsi/dc395x.c
@@ -246,6 +246,7 @@ struct ScsiReqBlk {
         * total_xfer_length in xferred. These values are restored in
         * pci_unmap_srb_sense. This is the only place xferred is used.
         */
+        unsigned char *virt_addr_req;   /* Saved virtual address of the request buffer */
        u32 xferred;                    /* Saved copy of total_xfer_length */
        u16 state;
@@ -2017,7 +2018,7 @@ static void sg_update_list(struct ScsiReqBlk *srb, u32 left)
        sg_verify_length(srb);
        /* we need the corresponding virtual address */
-        if (!segment) {
+        if (!segment || (srb->flag & AUTO_REQSENSE)) {
                srb->virt_addr += xferred;
                return;
        }
@@ -3318,6 +3319,7 @@ static void pci_unmap_srb_sense(struct AdapterCtlBlk *acb,
            srb->segment_x[DC395x_MAX_SG_LISTENTRY - 1].address;
        srb->segment_x[0].length =
            srb->segment_x[DC395x_MAX_SG_LISTENTRY - 1].length;
+        srb->virt_addr = srb->virt_addr_req;
 }
@@ -3711,6 +3713,8 @@ static void request_sense(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
        srb->xferred = srb->total_xfer_length;
        /* srb->segment_x : a one entry of S/G list table */
        srb->total_xfer_length = sizeof(cmd->sense_buffer);
+        srb->virt_addr_req = srb->virt_addr;
+        srb->virt_addr = cmd->sense_buffer;
        srb->segment_x[0].length = sizeof(cmd->sense_buffer);
        /* Map sense buffer */
        srb->segment_x[0].address =
diff --git a/drivers/scsi/esp.c b/drivers/scsi/esp.c
index f6900538be90..87a8c3d2072c 100644
--- a/drivers/scsi/esp.c
+++ b/drivers/scsi/esp.c
@@ -2068,14 +2068,12 @@ static int esp_reset(struct scsi_cmnd *SCptr)
 {
        struct esp *esp = (struct esp *) SCptr->device->host->hostdata;
+        spin_lock_irq(esp->ehost->host_lock);
        (void) esp_do_resetbus(esp);
        spin_unlock_irq(esp->ehost->host_lock);
        wait_event(esp->reset_queue, (esp->resetting_bus == 0));
-        spin_lock_irq(esp->ehost->host_lock);
        return SUCCESS;
 }
diff --git a/drivers/scsi/gdth.c b/drivers/scsi/gdth.c
index bd3ffdf6c800..62e3cda859af 100644
--- a/drivers/scsi/gdth.c
+++ b/drivers/scsi/gdth.c
@@ -2816,7 +2816,7 @@ static int gdth_fill_cache_cmd(int hanum,Scsi_Cmnd *scp,ushort hdrive)
            }
 #endif
-        } else {
+        } else if (scp->request_bufflen) {
            scp->SCp.Status = GDTH_MAP_SINGLE;
            scp->SCp.Message = (read_write == 1 ? 
                PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
diff --git a/drivers/scsi/ibmvscsi/ibmvscsi.c b/drivers/scsi/ibmvscsi/ibmvscsi.c
index 822b9fa706f3..eaefeddb2b4a 100644
--- a/drivers/scsi/ibmvscsi/ibmvscsi.c
+++ b/drivers/scsi/ibmvscsi/ibmvscsi.c
@@ -87,7 +87,7 @@ static int max_channel = 3;
 static int init_timeout = 5;
 static int max_requests = 50;
-#define IBMVSCSI_VERSION "1.5.7"
+#define IBMVSCSI_VERSION "1.5.8"
 MODULE_DESCRIPTION("IBM Virtual SCSI");
 MODULE_AUTHOR("Dave Boutcher");
@@ -534,7 +534,6 @@ static int map_data_for_srp_cmd(struct scsi_cmnd *cmd,
 static int ibmvscsi_send_srp_event(struct srp_event_struct *evt_struct,
                                   struct ibmvscsi_host_data *hostdata)
 {
-        struct scsi_cmnd *cmnd;
        u64 *crq_as_u64 = (u64 *) &evt_struct->crq;
        int rc;
@@ -544,19 +543,8 @@ static int ibmvscsi_send_srp_event(struct srp_event_struct *evt_struct,
         * can handle more requests (can_queue) when we actually can't
         */
        if ((evt_struct->crq.format == VIOSRP_SRP_FORMAT) &&
-            (atomic_dec_if_positive(&hostdata->request_limit) < 0)) {
+            (atomic_dec_if_positive(&hostdata->request_limit) < 0))
-                /* See if the adapter is disabled */
+                goto send_error;
-                if (atomic_read(&hostdata->request_limit) < 0)
-                        goto send_error;
-        
-                printk(KERN_WARNING 
-                       "ibmvscsi: Warning, request_limit exceeded\n");
-                unmap_cmd_data(&evt_struct->iu.srp.cmd,
-                               evt_struct,
-                               hostdata->dev);
-                free_event_struct(&hostdata->pool, evt_struct);
-                return SCSI_MLQUEUE_HOST_BUSY;
-        }
        /* Copy the IU into the transfer area */
        *evt_struct->xfer_iu = evt_struct->iu;
@@ -572,7 +560,7 @@ static int ibmvscsi_send_srp_event(struct srp_event_struct *evt_struct,
             ibmvscsi_send_crq(hostdata, crq_as_u64[0], crq_as_u64[1])) != 0) {
                list_del(&evt_struct->list);
-                printk(KERN_ERR "ibmvscsi: failed to send event struct rc %d\n",
+                printk(KERN_ERR "ibmvscsi: send error %d\n",
                       rc);
                goto send_error;
        }
@@ -582,14 +570,8 @@ static int ibmvscsi_send_srp_event(struct srp_event_struct *evt_struct,
 send_error:
        unmap_cmd_data(&evt_struct->iu.srp.cmd, evt_struct, hostdata->dev);
-        if ((cmnd = evt_struct->cmnd) != NULL) {
-                cmnd->result = DID_ERROR << 16;
-                evt_struct->cmnd_done(cmnd);
-        } else if (evt_struct->done)
-                evt_struct->done(evt_struct);
-        
        free_event_struct(&hostdata->pool, evt_struct);
-        return 0;
+        return SCSI_MLQUEUE_HOST_BUSY;
 }
 /**
@@ -802,7 +784,8 @@ static void login_rsp(struct srp_event_struct *evt_struct)
        case SRP_LOGIN_RSP_TYPE:        /* it worked! */
                break;
        case SRP_LOGIN_REJ_TYPE:        /* refused! */
-                printk(KERN_INFO "ibmvscsi: SRP_LOGIN_REQ rejected\n");
+                printk(KERN_INFO "ibmvscsi: SRP_LOGIN_REJ reason %u\n",
+                       evt_struct->xfer_iu->srp.login_rej.reason);
                /* Login failed.  */
                atomic_set(&hostdata->request_limit, -1);
                return;
@@ -834,6 +817,9 @@ static void login_rsp(struct srp_event_struct *evt_struct)
                return;
        }
+        /* If we had any pending I/Os, kick them */
+        scsi_unblock_requests(hostdata->host);
        send_mad_adapter_info(hostdata);
        return;
 }
@@ -862,6 +848,7 @@ static int send_srp_login(struct ibmvscsi_host_data *hostdata)
                          init_timeout * HZ);
        login = &evt_struct->iu.srp.login_req;
+        memset(login, 0x00, sizeof(struct srp_login_req));
        login->type = SRP_LOGIN_REQ_TYPE;
        login->max_requested_initiator_to_target_iulen = sizeof(union srp_iu);
        login->required_buffer_formats = 0x0006;
@@ -1122,7 +1109,7 @@ static int ibmvscsi_eh_device_reset_handler(struct scsi_cmnd *cmd)
 * purge_requests: Our virtual adapter just shut down.  purge any sent requests
 * @hostdata:    the adapter
 */
-static void purge_requests(struct ibmvscsi_host_data *hostdata)
+static void purge_requests(struct ibmvscsi_host_data *hostdata, int error_code)
 {
        struct srp_event_struct *tmp_evt, *pos;
        unsigned long flags;
@@ -1131,7 +1118,7 @@ static void purge_requests(struct ibmvscsi_host_data *hostdata)
        list_for_each_entry_safe(tmp_evt, pos, &hostdata->sent, list) {
                list_del(&tmp_evt->list);
                if (tmp_evt->cmnd) {
-                        tmp_evt->cmnd->result = (DID_ERROR << 16);
+                        tmp_evt->cmnd->result = (error_code << 16);
                        unmap_cmd_data(&tmp_evt->iu.srp.cmd, 
                                       tmp_evt, 
                                       tmp_evt->hostdata->dev);
@@ -1186,12 +1173,30 @@ void ibmvscsi_handle_crq(struct viosrp_crq *crq,
                        printk(KERN_ERR "ibmvscsi: unknown crq message type\n");
                }
                return;
-        case 0xFF:              /* Hypervisor telling us the connection is closed */
+        case 0xFF:      /* Hypervisor telling us the connection is closed */
-                printk(KERN_INFO "ibmvscsi: Virtual adapter failed!\n");
+                scsi_block_requests(hostdata->host);
+                if (crq->format == 0x06) {
+                        /* We need to re-setup the interpartition connection */
+                        printk(KERN_INFO
+                               "ibmvscsi: Re-enabling adapter!\n");
+                        purge_requests(hostdata, DID_REQUEUE);
+                        if (ibmvscsi_reenable_crq_queue(&hostdata->queue,
+                                                        hostdata) == 0)
+                                if (ibmvscsi_send_crq(hostdata,
+                                                      0xC001000000000000LL, 0))
+                                        printk(KERN_ERR
+                                               "ibmvscsi: transmit error after"
+                                               " enable\n");
+                } else {
+                        printk(KERN_INFO
+                               "ibmvscsi: Virtual adapter failed rc %d!\n",
+                               crq->format);
-                atomic_set(&hostdata->request_limit, -1);
+                        atomic_set(&hostdata->request_limit, -1);
-                purge_requests(hostdata);
+                        purge_requests(hostdata, DID_ERROR);
-                ibmvscsi_reset_crq_queue(&hostdata->queue, hostdata);
+                        ibmvscsi_reset_crq_queue(&hostdata->queue, hostdata);
+                }
+                scsi_unblock_requests(hostdata->host);
                return;
        case 0x80:              /* real payload */
                break;
diff --git a/drivers/scsi/ibmvscsi/ibmvscsi.h b/drivers/scsi/ibmvscsi/ibmvscsi.h
index 5b0edd1f1921..4550d71e4744 100644
--- a/drivers/scsi/ibmvscsi/ibmvscsi.h
+++ b/drivers/scsi/ibmvscsi/ibmvscsi.h
@@ -103,6 +103,9 @@ void ibmvscsi_release_crq_queue(struct crq_queue *queue,
 int ibmvscsi_reset_crq_queue(struct crq_queue *queue,
                              struct ibmvscsi_host_data *hostdata);
+int ibmvscsi_reenable_crq_queue(struct crq_queue *queue,
+                                struct ibmvscsi_host_data *hostdata);
 void ibmvscsi_handle_crq(struct viosrp_crq *crq,
                         struct ibmvscsi_host_data *hostdata);
 int ibmvscsi_send_crq(struct ibmvscsi_host_data *hostdata,
diff --git a/drivers/scsi/ibmvscsi/iseries_vscsi.c b/drivers/scsi/ibmvscsi/iseries_vscsi.c
index ce15d9e39621..7eed0b098171 100644
--- a/drivers/scsi/ibmvscsi/iseries_vscsi.c
+++ b/drivers/scsi/ibmvscsi/iseries_vscsi.c
@@ -124,6 +124,19 @@ int ibmvscsi_reset_crq_queue(struct crq_queue *queue,
 }
 /**
+ * reenable_crq_queue: - reenables a crq after a failure
+ * @queue:      crq_queue to initialize and register
+ * @hostdata:   ibmvscsi_host_data of host
+ *
+ * no-op for iSeries
+ */
+int ibmvscsi_reenable_crq_queue(struct crq_queue *queue,
+                                struct ibmvscsi_host_data *hostdata)
+{
+        return 0;
+}
+/**
 * ibmvscsi_send_crq: - Send a CRQ
 * @hostdata:   the adapter
 * @word1:      the first 64 bits of the data
diff --git a/drivers/scsi/ibmvscsi/rpa_vscsi.c b/drivers/scsi/ibmvscsi/rpa_vscsi.c
index 75db2f5c545e..f47dd87c05e7 100644
--- a/drivers/scsi/ibmvscsi/rpa_vscsi.c
+++ b/drivers/scsi/ibmvscsi/rpa_vscsi.c
@@ -281,6 +281,28 @@ int ibmvscsi_init_crq_queue(struct crq_queue *queue,
 }
 /**
+ * reenable_crq_queue: - reenables a crq after
+ * @queue:      crq_queue to initialize and register
+ * @hostdata:   ibmvscsi_host_data of host
+ *
+ */
+int ibmvscsi_reenable_crq_queue(struct crq_queue *queue,
+                                 struct ibmvscsi_host_data *hostdata)
+{
+        int rc;
+        struct vio_dev *vdev = to_vio_dev(hostdata->dev);
+        /* Re-enable the CRQ */
+        do {
+                rc = plpar_hcall_norets(H_ENABLE_CRQ, vdev->unit_address);
+        } while ((rc == H_InProgress) || (rc == H_Busy) || (H_isLongBusy(rc)));
+        if (rc)
+                printk(KERN_ERR "ibmvscsi: Error %d enabling adapter\n", rc);
+        return rc;
+}
+/**
 * reset_crq_queue: - resets a crq after a failure
 * @queue:      crq_queue to initialize and register
 * @hostdata:   ibmvscsi_host_data of host
diff --git a/drivers/scsi/ide-scsi.c b/drivers/scsi/ide-scsi.c
index 3c688ef54660..0cf0e4c7ac0c 100644
--- a/drivers/scsi/ide-scsi.c
+++ b/drivers/scsi/ide-scsi.c
@@ -751,9 +751,8 @@ static void idescsi_setup (ide_drive_t *drive, idescsi_scsi_t *scsi)
        idescsi_add_settings(drive);
 }
-static int ide_scsi_remove(struct device *dev)
+static void ide_scsi_remove(ide_drive_t *drive)
 {
-        ide_drive_t *drive = to_ide_device(dev);
        struct Scsi_Host *scsihost = drive->driver_data;
        struct ide_scsi_obj *scsi = scsihost_to_idescsi(scsihost);
        struct gendisk *g = scsi->disk;
@@ -768,11 +767,9 @@ static int ide_scsi_remove(struct device *dev)
        scsi_remove_host(scsihost);
        ide_scsi_put(scsi);
-        return 0;
 }
-static int ide_scsi_probe(struct device *);
+static int ide_scsi_probe(ide_drive_t *);
 #ifdef CONFIG_PROC_FS
 static ide_proc_entry_t idescsi_proc[] = {
@@ -788,9 +785,9 @@ static ide_driver_t idescsi_driver = {
                .owner          = THIS_MODULE,
                .name           = "ide-scsi",
                .bus            = &ide_bus_type,
-                .probe          = ide_scsi_probe,
-                .remove         = ide_scsi_remove,
        },
+        .probe                  = ide_scsi_probe,
+        .remove                 = ide_scsi_remove,
        .version                = IDESCSI_VERSION,
        .media                  = ide_scsi,
        .supports_dsc_overlap   = 0,
@@ -1119,9 +1116,8 @@ static struct scsi_host_template idescsi_template = {
        .proc_name              = "ide-scsi",
 };
-static int ide_scsi_probe(struct device *dev)
+static int ide_scsi_probe(ide_drive_t *drive)
 {
-        ide_drive_t *drive = to_ide_device(dev);
        idescsi_scsi_t *idescsi;
        struct Scsi_Host *host;
        struct gendisk *g;
diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c
index 27acf78cf8d8..2bba5e55d7bc 100644
--- a/drivers/scsi/ipr.c
+++ b/drivers/scsi/ipr.c
@@ -4236,35 +4236,6 @@ static void ipr_scsi_done(struct ipr_cmnd *ipr_cmd)
 }
 /**
- * ipr_save_ioafp_mode_select - Save adapters mode select data
- * @ioa_cfg:    ioa config struct
- * @scsi_cmd:   scsi command struct
- *
- * This function saves mode select data for the adapter to
- * use following an adapter reset.
- *
- * Return value:
- *      0 on success / SCSI_MLQUEUE_HOST_BUSY on failure
- **/
-static int ipr_save_ioafp_mode_select(struct ipr_ioa_cfg *ioa_cfg,
-                                       struct scsi_cmnd *scsi_cmd)
-{
-        if (!ioa_cfg->saved_mode_pages) {
-                ioa_cfg->saved_mode_pages  = kmalloc(sizeof(struct ipr_mode_pages),
-                                                     GFP_ATOMIC);
-                if (!ioa_cfg->saved_mode_pages) {
-                        dev_err(&ioa_cfg->pdev->dev,
-                                "IOA mode select buffer allocation failed\n");
-                        return SCSI_MLQUEUE_HOST_BUSY;
-                }
-        }
-        memcpy(ioa_cfg->saved_mode_pages, scsi_cmd->buffer, scsi_cmd->cmnd[4]);
-        ioa_cfg->saved_mode_page_len = scsi_cmd->cmnd[4];
-        return 0;
-}
-/**
 * ipr_queuecommand - Queue a mid-layer request
 * @scsi_cmd:   scsi command struct
 * @done:               done function
@@ -4338,9 +4309,6 @@ static int ipr_queuecommand(struct scsi_cmnd *scsi_cmd,
            (!ipr_is_gscsi(res) || scsi_cmd->cmnd[0] == IPR_QUERY_RSRC_STATE))
                ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
-        if (ipr_is_ioa_resource(res) && scsi_cmd->cmnd[0] == MODE_SELECT)
-                rc = ipr_save_ioafp_mode_select(ioa_cfg, scsi_cmd);
        if (likely(rc == 0))
                rc = ipr_build_ioadl(ioa_cfg, ipr_cmd);
@@ -4829,17 +4797,11 @@ static int ipr_ioafp_mode_select_page28(struct ipr_cmnd *ipr_cmd)
        int length;
        ENTER;
-        if (ioa_cfg->saved_mode_pages) {
+        ipr_scsi_bus_speed_limit(ioa_cfg);
-                memcpy(mode_pages, ioa_cfg->saved_mode_pages,
+        ipr_check_term_power(ioa_cfg, mode_pages);
-                       ioa_cfg->saved_mode_page_len);
+        ipr_modify_ioafp_mode_page_28(ioa_cfg, mode_pages);
-                length = ioa_cfg->saved_mode_page_len;
+        length = mode_pages->hdr.length + 1;
-        } else {
+        mode_pages->hdr.length = 0;
-                ipr_scsi_bus_speed_limit(ioa_cfg);
-                ipr_check_term_power(ioa_cfg, mode_pages);
-                ipr_modify_ioafp_mode_page_28(ioa_cfg, mode_pages);
-                length = mode_pages->hdr.length + 1;
-                mode_pages->hdr.length = 0;
-        }
        ipr_build_mode_select(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE), 0x11,
                              ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, mode_pages),
@@ -5969,7 +5931,6 @@ static void ipr_free_mem(struct ipr_ioa_cfg *ioa_cfg)
        }
        ipr_free_dump(ioa_cfg);
-        kfree(ioa_cfg->saved_mode_pages);
        kfree(ioa_cfg->trace);
 }
diff --git a/drivers/scsi/ipr.h b/drivers/scsi/ipr.h
index b639332131f1..fd360bfe56dd 100644
--- a/drivers/scsi/ipr.h
+++ b/drivers/scsi/ipr.h
@@ -36,8 +36,8 @@
 /*
 * Literals
 */
-#define IPR_DRIVER_VERSION "2.1.1"
+#define IPR_DRIVER_VERSION "2.1.2"
-#define IPR_DRIVER_DATE "(November 15, 2005)"
+#define IPR_DRIVER_DATE "(February 8, 2006)"
 /*
 * IPR_MAX_CMD_PER_LUN: This defines the maximum number of outstanding
@@ -1000,7 +1000,6 @@ struct ipr_ioa_cfg {
        struct Scsi_Host *host;
        struct pci_dev *pdev;
        struct ipr_sglist *ucode_sglist;
-        struct ipr_mode_pages *saved_mode_pages;
        u8 saved_mode_page_len;
        struct work_struct work_q;
diff --git a/drivers/scsi/ips.c b/drivers/scsi/ips.c
index e5e1ca44e1ee..86c546164da9 100644
--- a/drivers/scsi/ips.c
+++ b/drivers/scsi/ips.c
@@ -3499,6 +3499,7 @@ ips_map_status(ips_ha_t * ha, ips_scb_t * scb, ips_stat_t * sp)
        int device_error;
        uint32_t transfer_len;
        IPS_DCDB_TABLE_TAPE *tapeDCDB;
+        IPS_SCSI_INQ_DATA inquiryData;
        METHOD_TRACE("ips_map_status", 1);
@@ -3557,13 +3558,13 @@ ips_map_status(ips_ha_t * ha, ips_scb_t * scb, ips_stat_t * sp)
                                errcode = DID_OK;
                                /* Restrict access to physical DASD */
-                                if ((scb->scsi_cmd->cmnd[0] == INQUIRY) &&
+                                if (scb->scsi_cmd->cmnd[0] == INQUIRY) {
-                                    ((((char *) scb->scsi_cmd->
+                                    ips_scmd_buf_read(scb->scsi_cmd, 
-                                       buffer)[0] & 0x1f) == TYPE_DISK)) {
+                                      &inquiryData, sizeof (inquiryData));
-                                        /* underflow -- no error               */
+                                    if ((inquiryData.DeviceType & 0x1f) == TYPE_DISK) {
-                                        /* restrict access to physical DASD    */
+                                        errcode = DID_TIME_OUT;
-                                        errcode = DID_TIME_OUT;
+                                        break;
-                                        break;
+                                    }
                                }
                        } else
                                errcode = DID_ERROR;
@@ -4135,6 +4136,7 @@ ips_chkstatus(ips_ha_t * ha, IPS_STATUS * pstatus)
        uint8_t basic_status;
        uint8_t ext_status;
        int errcode;
+        IPS_SCSI_INQ_DATA inquiryData;
        METHOD_TRACE("ips_chkstatus", 1);
@@ -4255,11 +4257,11 @@ ips_chkstatus(ips_ha_t * ha, IPS_STATUS * pstatus)
                        scb->scsi_cmd->result = errcode << 16;
                } else {        /* bus == 0 */
                        /* restrict access to physical drives */
-                        if ((scb->scsi_cmd->cmnd[0] == INQUIRY) &&
+                        if (scb->scsi_cmd->cmnd[0] == INQUIRY) { 
-                            ((((char *) scb->scsi_cmd->buffer)[0] & 0x1f) ==
+                            ips_scmd_buf_read(scb->scsi_cmd, 
-                             TYPE_DISK)) {
+                                  &inquiryData, sizeof (inquiryData));
+                            if ((inquiryData.DeviceType & 0x1f) == TYPE_DISK) 
-                                scb->scsi_cmd->result = DID_TIME_OUT << 16;
+                                scb->scsi_cmd->result = DID_TIME_OUT << 16;
                        }
                }               /* else */
        } else {                /* recovered error / success */
@@ -5012,7 +5014,7 @@ ips_init_copperhead(ips_ha_t * ha)
                                break;
                        /* Delay for 1 Second */
-                        MDELAY(IPS_ONE_SEC);
+                        msleep(IPS_ONE_SEC);
                }
                if (j >= 45)
@@ -5038,7 +5040,7 @@ ips_init_copperhead(ips_ha_t * ha)
                                break;
                        /* Delay for 1 Second */
-                        MDELAY(IPS_ONE_SEC);
+                        msleep(IPS_ONE_SEC);
                }
                if (j >= 240)
@@ -5056,7 +5058,7 @@ ips_init_copperhead(ips_ha_t * ha)
                        break;
                /* Delay for 1 Second */
-                MDELAY(IPS_ONE_SEC);
+                msleep(IPS_ONE_SEC);
        }
        if (i >= 240)
@@ -5106,7 +5108,7 @@ ips_init_copperhead_memio(ips_ha_t * ha)
                                break;
                        /* Delay for 1 Second */
-                        MDELAY(IPS_ONE_SEC);
+                        msleep(IPS_ONE_SEC);
                }
                if (j >= 45)
@@ -5132,7 +5134,7 @@ ips_init_copperhead_memio(ips_ha_t * ha)
                                break;
                        /* Delay for 1 Second */
-                        MDELAY(IPS_ONE_SEC);
+                        msleep(IPS_ONE_SEC);
                }
                if (j >= 240)
@@ -5150,7 +5152,7 @@ ips_init_copperhead_memio(ips_ha_t * ha)
                        break;
                /* Delay for 1 Second */
-                MDELAY(IPS_ONE_SEC);
+                msleep(IPS_ONE_SEC);
        }
        if (i >= 240)
@@ -5202,7 +5204,7 @@ ips_init_morpheus(ips_ha_t * ha)
                        break;
                /* Delay for 1 Second */
-                MDELAY(IPS_ONE_SEC);
+                msleep(IPS_ONE_SEC);
        }
        if (i >= 45) {
@@ -5228,7 +5230,7 @@ ips_init_morpheus(ips_ha_t * ha)
                        if (Post != 0x4F00)
                                break;
                        /* Delay for 1 Second */
-                        MDELAY(IPS_ONE_SEC);
+                        msleep(IPS_ONE_SEC);
                }
                if (i >= 120) {
@@ -5258,7 +5260,7 @@ ips_init_morpheus(ips_ha_t * ha)
                        break;
                /* Delay for 1 Second */
-                MDELAY(IPS_ONE_SEC);
+                msleep(IPS_ONE_SEC);
        }
        if (i >= 240) {
@@ -5318,12 +5320,12 @@ ips_reset_copperhead(ips_ha_t * ha)
                outb(IPS_BIT_RST, ha->io_addr + IPS_REG_SCPR);
                /* Delay for 1 Second */
-                MDELAY(IPS_ONE_SEC);
+                msleep(IPS_ONE_SEC);
                outb(0, ha->io_addr + IPS_REG_SCPR);
                /* Delay for 1 Second */
-                MDELAY(IPS_ONE_SEC);
+                msleep(IPS_ONE_SEC);
                if ((*ha->func.init) (ha))
                        break;
@@ -5363,12 +5365,12 @@ ips_reset_copperhead_memio(ips_ha_t * ha)
                writeb(IPS_BIT_RST, ha->mem_ptr + IPS_REG_SCPR);
                /* Delay for 1 Second */
-                MDELAY(IPS_ONE_SEC);
+                msleep(IPS_ONE_SEC);
                writeb(0, ha->mem_ptr + IPS_REG_SCPR);
                /* Delay for 1 Second */
-                MDELAY(IPS_ONE_SEC);
+                msleep(IPS_ONE_SEC);
                if ((*ha->func.init) (ha))
                        break;
@@ -5409,7 +5411,7 @@ ips_reset_morpheus(ips_ha_t * ha)
                writel(0x80000000, ha->mem_ptr + IPS_REG_I960_IDR);
                /* Delay for 5 Seconds */
-                MDELAY(5 * IPS_ONE_SEC);
+                msleep(5 * IPS_ONE_SEC);
                /* Do a PCI config read to wait for adapter */
                pci_read_config_byte(ha->pcidev, 4, &junk);
diff --git a/drivers/scsi/iscsi_tcp.c b/drivers/scsi/iscsi_tcp.c
index 780bfcc67096..ff79e68b347c 100644
--- a/drivers/scsi/iscsi_tcp.c
+++ b/drivers/scsi/iscsi_tcp.c
@@ -146,7 +146,7 @@ iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err)
        spin_unlock_irqrestore(&session->lock, flags);
        set_bit(SUSPEND_BIT, &conn->suspend_tx);
        set_bit(SUSPEND_BIT, &conn->suspend_rx);
-        iscsi_conn_error(iscsi_handle(conn), err);
+        iscsi_conn_error(conn->cls_conn, err);
 }
 static inline int
@@ -244,12 +244,10 @@ iscsi_ctask_cleanup(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
        if (sc->sc_data_direction == DMA_TO_DEVICE) {
                struct iscsi_data_task *dtask, *n;
                /* WRITE: cleanup Data-Out's if any */
-                spin_lock(&conn->lock);
                list_for_each_entry_safe(dtask, n, &ctask->dataqueue, item) {
                        list_del(&dtask->item);
                        mempool_free(dtask, ctask->datapool);
                }
-                spin_unlock(&conn->lock);
        }
        ctask->xmstate = XMSTATE_IDLE;
        ctask->r2t = NULL;
@@ -689,7 +687,7 @@ iscsi_hdr_recv(struct iscsi_conn *conn)
                                break;
                        if (!conn->in.datalen) {
-                                rc = iscsi_recv_pdu(iscsi_handle(conn), hdr,
+                                rc = iscsi_recv_pdu(conn->cls_conn, hdr,
                                                    NULL, 0);
                                if (conn->login_mtask != mtask) {
                                        spin_lock(&session->lock);
@@ -737,7 +735,7 @@ iscsi_hdr_recv(struct iscsi_conn *conn)
                        if (!conn->in.datalen) {
                                struct iscsi_mgmt_task *mtask;
-                                rc = iscsi_recv_pdu(iscsi_handle(conn), hdr,
+                                rc = iscsi_recv_pdu(conn->cls_conn, hdr,
                                                    NULL, 0);
                                mtask = (struct iscsi_mgmt_task *)
                                        session->mgmt_cmds[conn->in.itt -
@@ -761,7 +759,7 @@ iscsi_hdr_recv(struct iscsi_conn *conn)
                                rc = iscsi_check_assign_cmdsn(session,
                                                 (struct iscsi_nopin*)hdr);
                                if (!rc && hdr->ttt != ISCSI_RESERVED_TAG)
-                                        rc = iscsi_recv_pdu(iscsi_handle(conn),
+                                        rc = iscsi_recv_pdu(conn->cls_conn,
                                                            hdr, NULL, 0);
                        } else
                                rc = ISCSI_ERR_PROTO;
@@ -1044,7 +1042,7 @@ iscsi_data_recv(struct iscsi_conn *conn)
                        goto exit;
                }
-                rc = iscsi_recv_pdu(iscsi_handle(conn), conn->in.hdr,
+                rc = iscsi_recv_pdu(conn->cls_conn, conn->in.hdr,
                                    conn->data, conn->in.datalen);
                if (!rc && conn->datadgst_en &&
@@ -2428,19 +2426,20 @@ iscsi_pool_free(struct iscsi_queue *q, void **items)
 }
 static struct iscsi_cls_conn *
-iscsi_conn_create(struct Scsi_Host *shost, uint32_t conn_idx)
+iscsi_conn_create(struct iscsi_cls_session *cls_session, uint32_t conn_idx)
 {
+        struct Scsi_Host *shost = iscsi_session_to_shost(cls_session);
        struct iscsi_session *session = iscsi_hostdata(shost->hostdata);
        struct iscsi_conn *conn;
        struct iscsi_cls_conn *cls_conn;
-        cls_conn = iscsi_create_conn(hostdata_session(shost->hostdata),
+        cls_conn = iscsi_create_conn(cls_session, conn_idx);
-                                     conn_idx);
        if (!cls_conn)
                return NULL;
        conn = cls_conn->dd_data;
+        memset(conn, 0, sizeof(*conn));
-        memset(conn, 0, sizeof(struct iscsi_conn));
+        conn->cls_conn = cls_conn;
        conn->c_stage = ISCSI_CONN_INITIAL_STAGE;
        conn->in_progress = IN_PROGRESS_WAIT_HEADER;
        conn->id = conn_idx;
@@ -2452,8 +2451,6 @@ iscsi_conn_create(struct Scsi_Host *shost, uint32_t conn_idx)
        conn->data_size = DEFAULT_MAX_RECV_DATA_SEGMENT_LENGTH;
        conn->max_recv_dlength = DEFAULT_MAX_RECV_DATA_SEGMENT_LENGTH;
-        spin_lock_init(&conn->lock);
        /* initialize general xmit PDU commands queue */
        conn->xmitqueue = kfifo_alloc(session->cmds_max * sizeof(void*),
                                        GFP_KERNEL, NULL);
@@ -2625,11 +2622,13 @@ iscsi_conn_destroy(struct iscsi_cls_conn *cls_conn)
 }
 static int
-iscsi_conn_bind(iscsi_sessionh_t sessionh, iscsi_connh_t connh,
+iscsi_conn_bind(struct iscsi_cls_session *cls_session,
-                uint32_t transport_fd, int is_leading)
+                struct iscsi_cls_conn *cls_conn, uint32_t transport_fd,
+                int is_leading)
 {
-        struct iscsi_session *session = iscsi_ptr(sessionh);
+        struct Scsi_Host *shost = iscsi_session_to_shost(cls_session);
-        struct iscsi_conn *tmp = ERR_PTR(-EEXIST), *conn = iscsi_ptr(connh);
+        struct iscsi_session *session = iscsi_hostdata(shost->hostdata);
+        struct iscsi_conn *tmp = ERR_PTR(-EEXIST), *conn = cls_conn->dd_data;
        struct sock *sk;
        struct socket *sock;
        int err;
@@ -2703,9 +2702,9 @@ iscsi_conn_bind(iscsi_sessionh_t sessionh, iscsi_connh_t connh,
 }
 static int
-iscsi_conn_start(iscsi_connh_t connh)
+iscsi_conn_start(struct iscsi_cls_conn *cls_conn)
 {
-        struct iscsi_conn *conn = iscsi_ptr(connh);
+        struct iscsi_conn *conn = cls_conn->dd_data;
        struct iscsi_session *session = conn->session;
        struct sock *sk;
@@ -2754,9 +2753,9 @@ iscsi_conn_start(iscsi_connh_t connh)
 }
 static void
-iscsi_conn_stop(iscsi_connh_t connh, int flag)
+iscsi_conn_stop(struct iscsi_cls_conn *cls_conn, int flag)
 {
-        struct iscsi_conn *conn = iscsi_ptr(connh);
+        struct iscsi_conn *conn = cls_conn->dd_data;
        struct iscsi_session *session = conn->session;
        struct sock *sk;
        unsigned long flags;
@@ -3253,9 +3252,9 @@ static struct scsi_host_template iscsi_sht = {
 static struct iscsi_transport iscsi_tcp_transport;
-static struct Scsi_Host *
+static struct iscsi_cls_session *
 iscsi_session_create(struct scsi_transport_template *scsit,
-                     uint32_t initial_cmdsn)
+                     uint32_t initial_cmdsn, uint32_t *sid)
 {
        struct Scsi_Host *shost;
        struct iscsi_session *session;
@@ -3268,13 +3267,14 @@ iscsi_session_create(struct scsi_transport_template *scsit,
        session = iscsi_hostdata(shost->hostdata);
        memset(session, 0, sizeof(struct iscsi_session));
        session->host = shost;
-        session->state = ISCSI_STATE_LOGGED_IN;
+        session->state = ISCSI_STATE_FREE;
        session->mgmtpool_max = ISCSI_MGMT_CMDS_MAX;
        session->cmds_max = ISCSI_XMIT_CMDS_MAX;
        session->cmdsn = initial_cmdsn;
        session->exp_cmdsn = initial_cmdsn + 1;
        session->max_cmdsn = initial_cmdsn + 1;
        session->max_r2t = 1;
+        *sid = shost->host_no;
        /* initialize SCSI PDU commands pool */
        if (iscsi_pool_init(&session->cmdpool, session->cmds_max,
@@ -3311,22 +3311,24 @@ iscsi_session_create(struct scsi_transport_template *scsit,
        if (iscsi_r2tpool_alloc(session))
                goto r2tpool_alloc_fail;
-        return shost;
+        return hostdata_session(shost->hostdata);
 r2tpool_alloc_fail:
        for (cmd_i = 0; cmd_i < session->mgmtpool_max; cmd_i++)
                kfree(session->mgmt_cmds[cmd_i]->data);
-        iscsi_pool_free(&session->mgmtpool, (void**)session->mgmt_cmds);
 immdata_alloc_fail:
+        iscsi_pool_free(&session->mgmtpool, (void**)session->mgmt_cmds);
 mgmtpool_alloc_fail:
        iscsi_pool_free(&session->cmdpool, (void**)session->cmds);
 cmdpool_alloc_fail:
+        iscsi_transport_destroy_session(shost);
        return NULL;
 }
 static void
-iscsi_session_destroy(struct Scsi_Host *shost)
+iscsi_session_destroy(struct iscsi_cls_session *cls_session)
 {
+        struct Scsi_Host *shost = iscsi_session_to_shost(cls_session);
        struct iscsi_session *session = iscsi_hostdata(shost->hostdata);
        int cmd_i;
        struct iscsi_data_task *dtask, *n;
@@ -3350,10 +3352,10 @@ iscsi_session_destroy(struct Scsi_Host *shost)
 }
 static int
-iscsi_conn_set_param(iscsi_connh_t connh, enum iscsi_param param,
+iscsi_conn_set_param(struct iscsi_cls_conn *cls_conn, enum iscsi_param param,
                     uint32_t value)
 {
-        struct iscsi_conn *conn = iscsi_ptr(connh);
+        struct iscsi_conn *conn = cls_conn->dd_data;
        struct iscsi_session *session = conn->session;
        spin_lock_bh(&session->lock);
@@ -3495,9 +3497,10 @@ iscsi_conn_set_param(iscsi_connh_t connh, enum iscsi_param param,
 }
 static int
-iscsi_session_get_param(struct Scsi_Host *shost,
+iscsi_session_get_param(struct iscsi_cls_session *cls_session,
                        enum iscsi_param param, uint32_t *value)
 {
+        struct Scsi_Host *shost = iscsi_session_to_shost(cls_session);
        struct iscsi_session *session = iscsi_hostdata(shost->hostdata);
        switch(param) {
@@ -3539,9 +3542,10 @@ iscsi_session_get_param(struct Scsi_Host *shost,
 }
 static int
-iscsi_conn_get_param(void *data, enum iscsi_param param, uint32_t *value)
+iscsi_conn_get_param(struct iscsi_cls_conn *cls_conn,
+                     enum iscsi_param param, uint32_t *value)
 {
-        struct iscsi_conn *conn = data;
+        struct iscsi_conn *conn = cls_conn->dd_data;
        switch(param) {
        case ISCSI_PARAM_MAX_RECV_DLENGTH:
@@ -3564,9 +3568,9 @@ iscsi_conn_get_param(void *data, enum iscsi_param param, uint32_t *value)
 }
 static void
-iscsi_conn_get_stats(iscsi_connh_t connh, struct iscsi_stats *stats)
+iscsi_conn_get_stats(struct iscsi_cls_conn *cls_conn, struct iscsi_stats *stats)
 {
-        struct iscsi_conn *conn = iscsi_ptr(connh);
+        struct iscsi_conn *conn = cls_conn->dd_data;
        stats->txdata_octets = conn->txdata_octets;
        stats->rxdata_octets = conn->rxdata_octets;
@@ -3587,10 +3591,10 @@ iscsi_conn_get_stats(iscsi_connh_t connh, struct iscsi_stats *stats)
 }
 static int
-iscsi_conn_send_pdu(iscsi_connh_t connh, struct iscsi_hdr *hdr, char *data,
+iscsi_conn_send_pdu(struct iscsi_cls_conn *cls_conn, struct iscsi_hdr *hdr,
-                    uint32_t data_size)
+                    char *data, uint32_t data_size)
 {
-        struct iscsi_conn *conn = iscsi_ptr(connh);
+        struct iscsi_conn *conn = cls_conn->dd_data;
        int rc;
        mutex_lock(&conn->xmitmutex);
diff --git a/drivers/scsi/iscsi_tcp.h b/drivers/scsi/iscsi_tcp.h
index f95e61b76f70..ba26741ac154 100644
--- a/drivers/scsi/iscsi_tcp.h
+++ b/drivers/scsi/iscsi_tcp.h
@@ -113,7 +113,10 @@ struct iscsi_tcp_recv {
        int                     datadgst;
 };
+struct iscsi_cls_conn;
 struct iscsi_conn {
+        struct iscsi_cls_conn   *cls_conn;      /* ptr to class connection */
        struct iscsi_hdr        hdr;            /* header placeholder */
        char                    hdrext[4*sizeof(__u16) +
                                    sizeof(__u32)];
@@ -143,7 +146,6 @@ struct iscsi_conn {
        struct iscsi_mgmt_task  *login_mtask;   /* mtask used for login/text */
        struct iscsi_mgmt_task  *mtask;         /* xmit mtask in progress */
        struct iscsi_cmd_task   *ctask;         /* xmit ctask in progress */
-        spinlock_t              lock;           /* FIXME: to be removed */
        /* old values for socket callbacks */
        void                    (*old_data_ready)(struct sock *, int);
diff --git a/drivers/scsi/jazz_esp.c b/drivers/scsi/jazz_esp.c
index 23728d1c980c..fcd304e11c26 100644
--- a/drivers/scsi/jazz_esp.c
+++ b/drivers/scsi/jazz_esp.c
@@ -65,27 +65,6 @@ static int jazz_esp_release(struct Scsi_Host *shost)
        return 0;
 }
-static struct scsi_host_template driver_template = {
-        .proc_name              = "jazz_esp",
-        .proc_info              = &esp_proc_info,
-        .name                   = "ESP 100/100a/200",
-        .detect                 = jazz_esp_detect,
-        .slave_alloc            = esp_slave_alloc,
-        .slave_destroy          = esp_slave_destroy,
-        .release                = jazz_esp_release,
-        .info                   = esp_info,
-        .queuecommand           = esp_queue,
-        .eh_abort_handler       = esp_abort,
-        .eh_bus_reset_handler   = esp_reset,
-        .can_queue              = 7,
-        .this_id                = 7,
-        .sg_tablesize           = SG_ALL,
-        .cmd_per_lun            = 1,
-        .use_clustering         = DISABLE_CLUSTERING,
-};
-#include "scsi_module.c"
 /***************************************************************** Detection */
 static int jazz_esp_detect(struct scsi_host_template *tpnt)
 {
diff --git a/drivers/scsi/libata-core.c b/drivers/scsi/libata-core.c
index 46c4cdbaee86..4f91b0dc572b 100644
--- a/drivers/scsi/libata-core.c
+++ b/drivers/scsi/libata-core.c
@@ -82,6 +82,10 @@ int atapi_enabled = 0;
 module_param(atapi_enabled, int, 0444);
 MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on)");
+int libata_fua = 0;
+module_param_named(fua, libata_fua, int, 0444);
+MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)");
 MODULE_AUTHOR("Jeff Garzik");
 MODULE_DESCRIPTION("Library module for ATA devices");
 MODULE_LICENSE("GPL");
@@ -614,7 +618,7 @@ int ata_rwcmd_protocol(struct ata_queued_cmd *qc)
        } else if (lba48 && (qc->ap->flags & ATA_FLAG_PIO_LBA48)) {
                /* Unable to use DMA due to host limitation */
                tf->protocol = ATA_PROT_PIO;
-                index = dev->multi_count ? 0 : 4;
+                index = dev->multi_count ? 0 : 8;
        } else {
                tf->protocol = ATA_PROT_DMA;
                index = 16;
@@ -2514,7 +2518,7 @@ static void ata_sg_clean(struct ata_queued_cmd *qc)
        assert(sg != NULL);
        if (qc->flags & ATA_QCFLAG_SINGLE)
-                assert(qc->n_elem == 1);
+                assert(qc->n_elem <= 1);
        VPRINTK("unmapping %u sg elements\n", qc->n_elem);
@@ -2537,7 +2541,7 @@ static void ata_sg_clean(struct ata_queued_cmd *qc)
                        kunmap_atomic(addr, KM_IRQ0);
                }
        } else {
-                if (sg_dma_len(&sg[0]) > 0)
+                if (qc->n_elem)
                        dma_unmap_single(ap->host_set->dev,
                                sg_dma_address(&sg[0]), sg_dma_len(&sg[0]),
                                dir);
@@ -2570,7 +2574,7 @@ static void ata_fill_sg(struct ata_queued_cmd *qc)
        unsigned int idx;
        assert(qc->__sg != NULL);
-        assert(qc->n_elem > 0);
+        assert(qc->n_elem > 0 || qc->pad_len > 0);
        idx = 0;
        ata_for_each_sg(sg, qc) {
@@ -2715,6 +2719,7 @@ static int ata_sg_setup_one(struct ata_queued_cmd *qc)
        int dir = qc->dma_dir;
        struct scatterlist *sg = qc->__sg;
        dma_addr_t dma_address;
+        int trim_sg = 0;
        /* we must lengthen transfers to end on a 32-bit boundary */
        qc->pad_len = sg->length & 3;
@@ -2734,13 +2739,15 @@ static int ata_sg_setup_one(struct ata_queued_cmd *qc)
                sg_dma_len(psg) = ATA_DMA_PAD_SZ;
                /* trim sg */
                sg->length -= qc->pad_len;
+                if (sg->length == 0)
+                        trim_sg = 1;
                DPRINTK("padding done, sg->length=%u pad_len=%u\n",
                        sg->length, qc->pad_len);
        }
-        if (!sg->length) {
+        if (trim_sg) {
-                sg_dma_address(sg) = 0;
+                qc->n_elem--;
                goto skip_map;
        }
@@ -2753,9 +2760,9 @@ static int ata_sg_setup_one(struct ata_queued_cmd *qc)
        }
        sg_dma_address(sg) = dma_address;
-skip_map:
        sg_dma_len(sg) = sg->length;
+skip_map:
        DPRINTK("mapped buffer of %d bytes for %s\n", sg_dma_len(sg),
                qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
@@ -3357,11 +3364,12 @@ static void ata_pio_error(struct ata_port *ap)
 {
        struct ata_queued_cmd *qc;
-        printk(KERN_WARNING "ata%u: PIO error\n", ap->id);
        qc = ata_qc_from_tag(ap, ap->active_tag);
        assert(qc != NULL);
+        if (qc->tf.command != ATA_CMD_PACKET)
+                printk(KERN_WARNING "ata%u: PIO error\n", ap->id);
        /* make sure qc->err_mask is available to 
         * know what's wrong and recover
         */
diff --git a/drivers/scsi/libata-scsi.c b/drivers/scsi/libata-scsi.c
index cfbceb504718..59503c9ccac9 100644
--- a/drivers/scsi/libata-scsi.c
+++ b/drivers/scsi/libata-scsi.c
@@ -1700,6 +1700,33 @@ static unsigned int ata_msense_rw_recovery(u8 **ptr_io, const u8 *last)
        return sizeof(def_rw_recovery_mpage);
 }
+/*
+ * We can turn this into a real blacklist if it's needed, for now just
+ * blacklist any Maxtor BANC1G10 revision firmware
+ */
+static int ata_dev_supports_fua(u16 *id)
+{
+        unsigned char model[41], fw[9];
+        if (!libata_fua)
+                return 0;
+        if (!ata_id_has_fua(id))
+                return 0;
+        model[40] = '\0';
+        fw[8] = '\0';
+        ata_dev_id_string(id, model, ATA_ID_PROD_OFS, sizeof(model) - 1);
+        ata_dev_id_string(id, fw, ATA_ID_FW_REV_OFS, sizeof(fw) - 1);
+        if (strncmp(model, "Maxtor", 6))
+                return 1;
+        if (strncmp(fw, "BANC1G10", 8))
+                return 1;
+        return 0; /* blacklisted */
+}
 /**
 *      ata_scsiop_mode_sense - Simulate MODE SENSE 6, 10 commands
 *      @args: device IDENTIFY data / SCSI command of interest.
@@ -1797,7 +1824,7 @@ unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
                return 0;
        dpofua = 0;
-        if (ata_id_has_fua(args->id) && dev->flags & ATA_DFLAG_LBA48 &&
+        if (ata_dev_supports_fua(args->id) && dev->flags & ATA_DFLAG_LBA48 &&
            (!(dev->flags & ATA_DFLAG_PIO) || dev->multi_count))
                dpofua = 1 << 4;
diff --git a/drivers/scsi/libata.h b/drivers/scsi/libata.h
index e03ce48b7b4b..fddaf479a544 100644
--- a/drivers/scsi/libata.h
+++ b/drivers/scsi/libata.h
@@ -41,6 +41,7 @@ struct ata_scsi_args {
 /* libata-core.c */
 extern int atapi_enabled;
+extern int libata_fua;
 extern struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap,
                                      struct ata_device *dev);
 extern int ata_rwcmd_protocol(struct ata_queued_cmd *qc);
diff --git a/drivers/scsi/mac53c94.c b/drivers/scsi/mac53c94.c
index 311a4122bd70..93edaa8696cf 100644
--- a/drivers/scsi/mac53c94.c
+++ b/drivers/scsi/mac53c94.c
@@ -537,9 +537,9 @@ static int mac53c94_remove(struct macio_dev *mdev)
        free_irq(fp->intr, fp);
        if (fp->regs)
-                iounmap((void *) fp->regs);
+                iounmap(fp->regs);
        if (fp->dma)
-                iounmap((void *) fp->dma);
+                iounmap(fp->dma);
        kfree(fp->dma_cmd_space);
        scsi_host_put(host);
diff --git a/drivers/scsi/megaraid.c b/drivers/scsi/megaraid.c
index d101a8a6f4e8..7144674bc8e6 100644
--- a/drivers/scsi/megaraid.c
+++ b/drivers/scsi/megaraid.c
@@ -5049,7 +5049,7 @@ static struct pci_device_id megaraid_pci_tbl[] = {
 MODULE_DEVICE_TABLE(pci, megaraid_pci_tbl);
 static struct pci_driver megaraid_pci_driver = {
-        .name           = "megaraid",
+        .name           = "megaraid_legacy",
        .id_table       = megaraid_pci_tbl,
        .probe          = megaraid_probe_one,
        .remove         = __devexit_p(megaraid_remove_one),
diff --git a/drivers/scsi/megaraid.h b/drivers/scsi/megaraid.h
index 4b3e0d6e5afa..4b75fe619d9c 100644
--- a/drivers/scsi/megaraid.h
+++ b/drivers/scsi/megaraid.h
@@ -5,7 +5,7 @@
 #include <linux/mutex.h>
 #define MEGARAID_VERSION        \
-        "v2.00.3 (Release Date: Wed Feb 19 08:51:30 EST 2003)\n"
+        "v2.00.4 (Release Date: Thu Feb 9 08:51:30 EST 2006)\n"
 /*
 * Driver features - change the values to enable or disable features in the
diff --git a/drivers/scsi/megaraid/megaraid_sas.c b/drivers/scsi/megaraid/megaraid_sas.c
index 511ed52a5807..4f39dd01936d 100644
--- a/drivers/scsi/megaraid/megaraid_sas.c
+++ b/drivers/scsi/megaraid/megaraid_sas.c
@@ -10,7 +10,7 @@
 *         2 of the License, or (at your option) any later version.
 *
 * FILE         : megaraid_sas.c
- * Version      : v00.00.02.00-rc4
+ * Version      : v00.00.02.04
 *
 * Authors:
 *      Sreenivas Bagalkote     <Sreenivas.Bagalkote@lsil.com>
@@ -55,13 +55,19 @@ static struct pci_device_id megasas_pci_table[] = {
        {
         PCI_VENDOR_ID_LSI_LOGIC,
-         PCI_DEVICE_ID_LSI_SAS1064R,
+         PCI_DEVICE_ID_LSI_SAS1064R, // xscale IOP
         PCI_ANY_ID,
         PCI_ANY_ID,
         },
        {
+         PCI_VENDOR_ID_LSI_LOGIC,
+         PCI_DEVICE_ID_LSI_SAS1078R, // ppc IOP
+         PCI_ANY_ID,
+         PCI_ANY_ID,
+        },
+        {
         PCI_VENDOR_ID_DELL,
-         PCI_DEVICE_ID_DELL_PERC5,
+         PCI_DEVICE_ID_DELL_PERC5, // xscale IOP
         PCI_ANY_ID,
         PCI_ANY_ID,
         },
@@ -119,12 +125,18 @@ megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
        spin_unlock_irqrestore(&instance->cmd_pool_lock, flags);
 }
+/**
+*       The following functions are defined for xscale 
+*       (deviceid : 1064R, PERC5) controllers
+*/
 /**
- * megasas_enable_intr -        Enables interrupts
+ * megasas_enable_intr_xscale - Enables interrupts
 * @regs:                       MFI register set
 */
 static inline void
-megasas_enable_intr(struct megasas_register_set __iomem * regs)
+megasas_enable_intr_xscale(struct megasas_register_set __iomem * regs)
 {
        writel(1, &(regs)->outbound_intr_mask);
@@ -133,13 +145,153 @@ megasas_enable_intr(struct megasas_register_set __iomem * regs)
 }
 /**
+ * megasas_read_fw_status_reg_xscale - returns the current FW status value
+ * @regs:                       MFI register set
+ */
+static u32
+megasas_read_fw_status_reg_xscale(struct megasas_register_set __iomem * regs)
+{
+        return readl(&(regs)->outbound_msg_0);
+}
+/**
+ * megasas_clear_interrupt_xscale -     Check & clear interrupt
+ * @regs:                               MFI register set
+ */
+static int 
+megasas_clear_intr_xscale(struct megasas_register_set __iomem * regs)
+{
+        u32 status;
+        /*
+         * Check if it is our interrupt
+         */
+        status = readl(&regs->outbound_intr_status);
+        if (!(status & MFI_OB_INTR_STATUS_MASK)) {
+                return 1;
+        }
+        /*
+         * Clear the interrupt by writing back the same value
+         */
+        writel(status, &regs->outbound_intr_status);
+        return 0;
+}
+/**
+ * megasas_fire_cmd_xscale -    Sends command to the FW
+ * @frame_phys_addr :           Physical address of cmd
+ * @frame_count :               Number of frames for the command
+ * @regs :                      MFI register set
+ */
+static inline void 
+megasas_fire_cmd_xscale(dma_addr_t frame_phys_addr,u32 frame_count, struct megasas_register_set __iomem *regs)
+{
+        writel((frame_phys_addr >> 3)|(frame_count),
+               &(regs)->inbound_queue_port);
+}
+static struct megasas_instance_template megasas_instance_template_xscale = {
+        .fire_cmd = megasas_fire_cmd_xscale,
+        .enable_intr = megasas_enable_intr_xscale,
+        .clear_intr = megasas_clear_intr_xscale,
+        .read_fw_status_reg = megasas_read_fw_status_reg_xscale,
+};
+/**
+*       This is the end of set of functions & definitions specific 
+*       to xscale (deviceid : 1064R, PERC5) controllers
+*/
+/**
+*       The following functions are defined for ppc (deviceid : 0x60) 
+*       controllers
+*/
+/**
+ * megasas_enable_intr_ppc -    Enables interrupts
+ * @regs:                       MFI register set
+ */
+static inline void
+megasas_enable_intr_ppc(struct megasas_register_set __iomem * regs)
+{
+        writel(0xFFFFFFFF, &(regs)->outbound_doorbell_clear);
+    
+        writel(~0x80000004, &(regs)->outbound_intr_mask);
+        /* Dummy readl to force pci flush */
+        readl(&regs->outbound_intr_mask);
+}
+/**
+ * megasas_read_fw_status_reg_ppc - returns the current FW status value
+ * @regs:                       MFI register set
+ */
+static u32
+megasas_read_fw_status_reg_ppc(struct megasas_register_set __iomem * regs)
+{
+        return readl(&(regs)->outbound_scratch_pad);
+}
+/**
+ * megasas_clear_interrupt_ppc -        Check & clear interrupt
+ * @regs:                               MFI register set
+ */
+static int 
+megasas_clear_intr_ppc(struct megasas_register_set __iomem * regs)
+{
+        u32 status;
+        /*
+         * Check if it is our interrupt
+         */
+        status = readl(&regs->outbound_intr_status);
+        if (!(status & MFI_REPLY_1078_MESSAGE_INTERRUPT)) {
+                return 1;
+        }
+        /*
+         * Clear the interrupt by writing back the same value
+         */
+        writel(status, &regs->outbound_doorbell_clear);
+        return 0;
+}
+/**
+ * megasas_fire_cmd_ppc -       Sends command to the FW
+ * @frame_phys_addr :           Physical address of cmd
+ * @frame_count :               Number of frames for the command
+ * @regs :                      MFI register set
+ */
+static inline void 
+megasas_fire_cmd_ppc(dma_addr_t frame_phys_addr, u32 frame_count, struct megasas_register_set __iomem *regs)
+{
+        writel((frame_phys_addr | (frame_count<<1))|1, 
+                        &(regs)->inbound_queue_port);
+}
+static struct megasas_instance_template megasas_instance_template_ppc = {
+        
+        .fire_cmd = megasas_fire_cmd_ppc,
+        .enable_intr = megasas_enable_intr_ppc,
+        .clear_intr = megasas_clear_intr_ppc,
+        .read_fw_status_reg = megasas_read_fw_status_reg_ppc,
+};
+/**
+*       This is the end of set of functions & definitions
+*       specific to ppc (deviceid : 0x60) controllers
+*/
+/**
 * megasas_disable_intr -       Disables interrupts
 * @regs:                       MFI register set
 */
 static inline void
 megasas_disable_intr(struct megasas_register_set __iomem * regs)
 {
-        u32 mask = readl(&regs->outbound_intr_mask) & (~0x00000001);
+        u32 mask = 0x1f; 
        writel(mask, &regs->outbound_intr_mask);
        /* Dummy readl to force pci flush */
@@ -167,8 +319,7 @@ megasas_issue_polled(struct megasas_instance *instance, struct megasas_cmd *cmd)
        /*
         * Issue the frame using inbound queue port
         */
-        writel(cmd->frame_phys_addr >> 3,
+        instance->instancet->fire_cmd(cmd->frame_phys_addr ,0,instance->reg_set);
-               &instance->reg_set->inbound_queue_port);
        /*
         * Wait for cmd_status to change
@@ -198,8 +349,7 @@ megasas_issue_blocked_cmd(struct megasas_instance *instance,
 {
        cmd->cmd_status = ENODATA;
-        writel(cmd->frame_phys_addr >> 3,
+        instance->instancet->fire_cmd(cmd->frame_phys_addr ,0,instance->reg_set);
-               &instance->reg_set->inbound_queue_port);
        wait_event(instance->int_cmd_wait_q, (cmd->cmd_status != ENODATA));
@@ -242,8 +392,7 @@ megasas_issue_blocked_abort_cmd(struct megasas_instance *instance,
        cmd->sync_cmd = 1;
        cmd->cmd_status = 0xFF;
-        writel(cmd->frame_phys_addr >> 3,
+        instance->instancet->fire_cmd(cmd->frame_phys_addr ,0,instance->reg_set);
-               &instance->reg_set->inbound_queue_port);
        /*
         * Wait for this cmd to complete
@@ -558,112 +707,29 @@ megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp,
 }
 /**
- * megasas_build_cmd -  Prepares a command packet
+ * megasas_is_ldio -            Checks if the cmd is for logical drive
- * @instance:           Adapter soft state
+ * @scmd:                       SCSI command
- * @scp:                SCSI command
+ *      
- * @frame_count:        [OUT] Number of frames used to prepare this command
+ * Called by megasas_queue_command to find out if the command to be queued
+ * is a logical drive command   
 */
-static struct megasas_cmd *megasas_build_cmd(struct megasas_instance
+static inline int megasas_is_ldio(struct scsi_cmnd *cmd)
-                                                    *instance,
-                                                    struct scsi_cmnd *scp,
-                                                    int *frame_count)
 {
-        u32 logical_cmd;
+        if (!MEGASAS_IS_LOGICAL(cmd))
-        struct megasas_cmd *cmd;
+                return 0;
+        switch (cmd->cmnd[0]) {
-        /*
+        case READ_10:
-         * Find out if this is logical or physical drive command.
+        case WRITE_10:
-         */
+        case READ_12:
-        logical_cmd = MEGASAS_IS_LOGICAL(scp);
+        case WRITE_12:
+        case READ_6:
-        /*
+        case WRITE_6:
-         * Logical drive command
+        case READ_16:
-         */
+        case WRITE_16:
-        if (logical_cmd) {
+                return 1;
+        default:
-                if (scp->device->id >= MEGASAS_MAX_LD) {
+                return 0;
-                        scp->result = DID_BAD_TARGET << 16;
-                        return NULL;
-                }
-                switch (scp->cmnd[0]) {
-                case READ_10:
-                case WRITE_10:
-                case READ_12:
-                case WRITE_12:
-                case READ_6:
-                case WRITE_6:
-                case READ_16:
-                case WRITE_16:
-                        /*
-                         * Fail for LUN > 0
-                         */
-                        if (scp->device->lun) {
-                                scp->result = DID_BAD_TARGET << 16;
-                                return NULL;
-                        }
-                        cmd = megasas_get_cmd(instance);
-                        if (!cmd) {
-                                scp->result = DID_IMM_RETRY << 16;
-                                return NULL;
-                        }
-                        *frame_count = megasas_build_ldio(instance, scp, cmd);
-                        if (!(*frame_count)) {
-                                megasas_return_cmd(instance, cmd);
-                                return NULL;
-                        }
-                        return cmd;
-                default:
-                        /*
-                         * Fail for LUN > 0
-                         */
-                        if (scp->device->lun) {
-                                scp->result = DID_BAD_TARGET << 16;
-                                return NULL;
-                        }
-                        cmd = megasas_get_cmd(instance);
-                        if (!cmd) {
-                                scp->result = DID_IMM_RETRY << 16;
-                                return NULL;
-                        }
-                        *frame_count = megasas_build_dcdb(instance, scp, cmd);
-                        if (!(*frame_count)) {
-                                megasas_return_cmd(instance, cmd);
-                                return NULL;
-                        }
-                        return cmd;
-                }
-        } else {
-                cmd = megasas_get_cmd(instance);
-                if (!cmd) {
-                        scp->result = DID_IMM_RETRY << 16;
-                        return NULL;
-                }
-                *frame_count = megasas_build_dcdb(instance, scp, cmd);
-                if (!(*frame_count)) {
-                        megasas_return_cmd(instance, cmd);
-                        return NULL;
-                }
-                return cmd;
        }
-        return NULL;
 }
 /**
@@ -684,13 +750,27 @@ megasas_queue_command(struct scsi_cmnd *scmd, void (*done) (struct scsi_cmnd *))
        scmd->scsi_done = done;
        scmd->result = 0;
-        cmd = megasas_build_cmd(instance, scmd, &frame_count);
+        if (MEGASAS_IS_LOGICAL(scmd) &&
+            (scmd->device->id >= MEGASAS_MAX_LD || scmd->device->lun)) {
-        if (!cmd) {
+                scmd->result = DID_BAD_TARGET << 16;
-                done(scmd);
+                goto out_done;
-                return 0;
        }
+        cmd = megasas_get_cmd(instance);
+        if (!cmd)
+                return SCSI_MLQUEUE_HOST_BUSY;
+        /*
+         * Logical drive command
+         */
+        if (megasas_is_ldio(scmd))
+                frame_count = megasas_build_ldio(instance, scmd, cmd);
+        else
+                frame_count = megasas_build_dcdb(instance, scmd, cmd);
+        if (!frame_count)
+                goto out_return_cmd;
        cmd->scmd = scmd;
        scmd->SCp.ptr = (char *)cmd;
        scmd->SCp.sent_command = jiffies;
@@ -702,9 +782,28 @@ megasas_queue_command(struct scsi_cmnd *scmd, void (*done) (struct scsi_cmnd *))
        instance->fw_outstanding++;
        spin_unlock_irqrestore(&instance->instance_lock, flags);
-        writel(((cmd->frame_phys_addr >> 3) | (cmd->frame_count - 1)),
+        instance->instancet->fire_cmd(cmd->frame_phys_addr ,cmd->frame_count-1,instance->reg_set);
-               &instance->reg_set->inbound_queue_port);
+        return 0;
+ out_return_cmd:
+        megasas_return_cmd(instance, cmd);
+ out_done:
+        done(scmd);
+        return 0;
+}
+static int megasas_slave_configure(struct scsi_device *sdev)
+{
+        /*
+         * Don't export physical disk devices to the disk driver.
+         *
+         * FIXME: Currently we don't export them to the midlayer at all.
+         *        That will be fixed once LSI engineers have audited the
+         *        firmware for possible issues.
+         */
+        if (sdev->channel < MEGASAS_MAX_PD_CHANNELS && sdev->type == TYPE_DISK)
+                return -ENXIO;
        return 0;
 }
@@ -858,6 +957,7 @@ static struct scsi_host_template megasas_template = {
        .module = THIS_MODULE,
        .name = "LSI Logic SAS based MegaRAID driver",
        .proc_name = "megaraid_sas",
+        .slave_configure = megasas_slave_configure,
        .queuecommand = megasas_queue_command,
        .eh_device_reset_handler = megasas_reset_device,
        .eh_bus_reset_handler = megasas_reset_bus_host,
@@ -986,20 +1086,6 @@ megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
                        break;
                }
-                /*
-                 * Don't export physical disk devices to mid-layer.
-                 */
-                if (!MEGASAS_IS_LOGICAL(cmd->scmd) &&
-                    (hdr->cmd_status == MFI_STAT_OK) &&
-                    (cmd->scmd->cmnd[0] == INQUIRY)) {
-                        if (((*(u8 *) cmd->scmd->request_buffer) & 0x1F) ==
-                            TYPE_DISK) {
-                                cmd->scmd->result = DID_BAD_TARGET << 16;
-                                exception = 1;
-                        }
-                }
        case MFI_CMD_LD_READ:
        case MFI_CMD_LD_WRITE:
@@ -1108,7 +1194,6 @@ megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
 static int
 megasas_deplete_reply_queue(struct megasas_instance *instance, u8 alt_status)
 {
-        u32 status;
        u32 producer;
        u32 consumer;
        u32 context;
@@ -1116,17 +1201,10 @@ megasas_deplete_reply_queue(struct megasas_instance *instance, u8 alt_status)
        /*
         * Check if it is our interrupt
+         * Clear the interrupt 
         */
-        status = readl(&instance->reg_set->outbound_intr_status);
+        if(instance->instancet->clear_intr(instance->reg_set))
-        if (!(status & MFI_OB_INTR_STATUS_MASK)) {
                return IRQ_NONE;
-        }
-        /*
-         * Clear the interrupt by writing back the same value
-         */
-        writel(status, &instance->reg_set->outbound_intr_status);
        producer = *instance->producer;
        consumer = *instance->consumer;
@@ -1160,7 +1238,7 @@ static irqreturn_t megasas_isr(int irq, void *devp, struct pt_regs *regs)
 /**
 * megasas_transition_to_ready -        Move the FW to READY state
- * @reg_set:                            MFI register set
+ * @instance:                           Adapter soft state
 *
 * During the initialization, FW passes can potentially be in any one of
 * several possible states. If the FW in operational, waiting-for-handshake
@@ -1168,14 +1246,14 @@ static irqreturn_t megasas_isr(int irq, void *devp, struct pt_regs *regs)
 * has to wait for the ready state.
 */
 static int
-megasas_transition_to_ready(struct megasas_register_set __iomem * reg_set)
+megasas_transition_to_ready(struct megasas_instance* instance)
 {
        int i;
        u8 max_wait;
        u32 fw_state;
        u32 cur_state;
-        fw_state = readl(&reg_set->outbound_msg_0) & MFI_STATE_MASK;
+        fw_state = instance->instancet->read_fw_status_reg(instance->reg_set) & MFI_STATE_MASK;
        while (fw_state != MFI_STATE_READY) {
@@ -1193,7 +1271,7 @@ megasas_transition_to_ready(struct megasas_register_set __iomem * reg_set)
                         * Set the CLR bit in inbound doorbell
                         */
                        writel(MFI_INIT_CLEAR_HANDSHAKE,
-                               &reg_set->inbound_doorbell);
+                                &instance->reg_set->inbound_doorbell);
                        max_wait = 2;
                        cur_state = MFI_STATE_WAIT_HANDSHAKE;
@@ -1203,8 +1281,8 @@ megasas_transition_to_ready(struct megasas_register_set __iomem * reg_set)
                        /*
                         * Bring it to READY state; assuming max wait 2 secs
                         */
-                        megasas_disable_intr(reg_set);
+                        megasas_disable_intr(instance->reg_set);
-                        writel(MFI_INIT_READY, &reg_set->inbound_doorbell);
+                        writel(MFI_INIT_READY, &instance->reg_set->inbound_doorbell);
                        max_wait = 10;
                        cur_state = MFI_STATE_OPERATIONAL;
@@ -1253,8 +1331,8 @@ megasas_transition_to_ready(struct megasas_register_set __iomem * reg_set)
                 * The cur_state should not last for more than max_wait secs
                 */
                for (i = 0; i < (max_wait * 1000); i++) {
-                        fw_state = MFI_STATE_MASK &
+                        fw_state = instance->instancet->read_fw_status_reg(instance->reg_set) &  
-                            readl(&reg_set->outbound_msg_0);
+                                        MFI_STATE_MASK ;
                        if (fw_state == cur_state) {
                                msleep(1);
@@ -1616,18 +1694,30 @@ static int megasas_init_mfi(struct megasas_instance *instance)
        reg_set = instance->reg_set;
+        switch(instance->pdev->device)
+        {
+                case PCI_DEVICE_ID_LSI_SAS1078R:        
+                        instance->instancet = &megasas_instance_template_ppc;
+                        break;
+                case PCI_DEVICE_ID_LSI_SAS1064R:
+                case PCI_DEVICE_ID_DELL_PERC5:
+                default:
+                        instance->instancet = &megasas_instance_template_xscale;
+                        break;
+        }
        /*
         * We expect the FW state to be READY
         */
-        if (megasas_transition_to_ready(instance->reg_set))
+        if (megasas_transition_to_ready(instance))
                goto fail_ready_state;
        /*
         * Get various operational parameters from status register
         */
-        instance->max_fw_cmds = readl(&reg_set->outbound_msg_0) & 0x00FFFF;
+        instance->max_fw_cmds = instance->instancet->read_fw_status_reg(reg_set) & 0x00FFFF;
-        instance->max_num_sge = (readl(&reg_set->outbound_msg_0) & 0xFF0000) >>
+        instance->max_num_sge = (instance->instancet->read_fw_status_reg(reg_set) & 0xFF0000) >> 
-            0x10;
+                                        0x10;
        /*
         * Create a pool of commands
         */
@@ -1936,8 +2026,7 @@ megasas_register_aen(struct megasas_instance *instance, u32 seq_num,
        /*
         * Issue the aen registration frame
         */
-        writel(cmd->frame_phys_addr >> 3,
+        instance->instancet->fire_cmd(cmd->frame_phys_addr ,0,instance->reg_set);
-               &instance->reg_set->inbound_queue_port);
        return 0;
 }
@@ -1991,6 +2080,7 @@ static int megasas_io_attach(struct megasas_instance *instance)
        host->max_channel = MEGASAS_MAX_CHANNELS - 1;
        host->max_id = MEGASAS_MAX_DEV_PER_CHANNEL;
        host->max_lun = MEGASAS_MAX_LUN;
+        host->max_cmd_len = 16;
        /*
         * Notify the mid-layer about the new controller
@@ -2126,7 +2216,7 @@ megasas_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
                goto fail_irq;
        }
-        megasas_enable_intr(instance->reg_set);
+        instance->instancet->enable_intr(instance->reg_set);
        /*
         * Store instance in PCI softstate
@@ -2681,9 +2771,8 @@ megasas_mgmt_compat_ioctl(struct file *file, unsigned int cmd,
                          unsigned long arg)
 {
        switch (cmd) {
-        case MEGASAS_IOC_FIRMWARE:{
+        case MEGASAS_IOC_FIRMWARE32:
-                        return megasas_mgmt_compat_ioctl_fw(file, arg);
+                return megasas_mgmt_compat_ioctl_fw(file, arg);
-                }
        case MEGASAS_IOC_GET_AEN:
                return megasas_mgmt_ioctl_aen(file, arg);
        }
diff --git a/drivers/scsi/megaraid/megaraid_sas.h b/drivers/scsi/megaraid/megaraid_sas.h
index eaec9d531424..89639f0c38ef 100644
--- a/drivers/scsi/megaraid/megaraid_sas.h
+++ b/drivers/scsi/megaraid/megaraid_sas.h
@@ -18,10 +18,9 @@
 /**
 * MegaRAID SAS Driver meta data
 */
-#define MEGASAS_VERSION                         "00.00.02.00-rc4"
+#define MEGASAS_VERSION                         "00.00.02.04"
-#define MEGASAS_RELDATE                         "Sep 16, 2005"
+#define MEGASAS_RELDATE                         "Feb 03, 2006"
-#define MEGASAS_EXT_VERSION                     "Fri Sep 16 12:37:08 EDT 2005"
+#define MEGASAS_EXT_VERSION                     "Fri Feb 03 14:31:44 PST 2006"
 /*
 * =====================================
 * MegaRAID SAS MFI firmware definitions
@@ -554,31 +553,46 @@ struct megasas_ctrl_info {
 #define MFI_OB_INTR_STATUS_MASK                 0x00000002
 #define MFI_POLL_TIMEOUT_SECS                   10
+#define MFI_REPLY_1078_MESSAGE_INTERRUPT        0x80000000
+#define PCI_DEVICE_ID_LSI_SAS1078R              0x00000060
+ 
 struct megasas_register_set {
+        u32     reserved_0[4];                  /*0000h*/
+        u32     inbound_msg_0;                  /*0010h*/
+        u32     inbound_msg_1;                  /*0014h*/
+        u32     outbound_msg_0;                 /*0018h*/
+        u32     outbound_msg_1;                 /*001Ch*/
+        u32     inbound_doorbell;               /*0020h*/
+        u32     inbound_intr_status;            /*0024h*/
+        u32     inbound_intr_mask;              /*0028h*/
+        u32     outbound_doorbell;              /*002Ch*/
+        u32     outbound_intr_status;           /*0030h*/
+        u32     outbound_intr_mask;             /*0034h*/
-        u32 reserved_0[4];      /*0000h */
+        u32     reserved_1[2];                  /*0038h*/
-        u32 inbound_msg_0;      /*0010h */
+        u32     inbound_queue_port;             /*0040h*/
-        u32 inbound_msg_1;      /*0014h */
+        u32     outbound_queue_port;            /*0044h*/
-        u32 outbound_msg_0;     /*0018h */
-        u32 outbound_msg_1;     /*001Ch */
-        u32 inbound_doorbell;   /*0020h */
+        u32     reserved_2[22];                 /*0048h*/
-        u32 inbound_intr_status;        /*0024h */
-        u32 inbound_intr_mask;  /*0028h */
-        u32 outbound_doorbell;  /*002Ch */
+        u32     outbound_doorbell_clear;        /*00A0h*/
-        u32 outbound_intr_status;       /*0030h */
-        u32 outbound_intr_mask; /*0034h */
-        u32 reserved_1[2];      /*0038h */
+        u32     reserved_3[3];                  /*00A4h*/
-        u32 inbound_queue_port; /*0040h */
+        u32     outbound_scratch_pad ;          /*00B0h*/
-        u32 outbound_queue_port;        /*0044h */
-        u32 reserved_2;         /*004Ch */
+        u32     reserved_4[3];                  /*00B4h*/
-        u32 index_registers[1004];      /*0050h */
+        u32     inbound_low_queue_port ;        /*00C0h*/
+        u32     inbound_high_queue_port ;       /*00C4h*/
+        u32     reserved_5;                     /*00C8h*/
+        u32     index_registers[820];           /*00CCh*/
 } __attribute__ ((packed));
@@ -1013,6 +1027,16 @@ struct megasas_evt_detail {
 } __attribute__ ((packed));
+ struct megasas_instance_template {
+        void (*fire_cmd)(dma_addr_t ,u32 ,struct megasas_register_set __iomem *);
+        void (*enable_intr)(struct megasas_register_set __iomem *) ;
+        int (*clear_intr)(struct megasas_register_set __iomem *);
+        u32 (*read_fw_status_reg)(struct megasas_register_set __iomem *);
+ };
 struct megasas_instance {
        u32 *producer;
@@ -1056,6 +1080,8 @@ struct megasas_instance {
        u32 fw_outstanding;
        u32 hw_crit_error;
        spinlock_t instance_lock;
+        struct megasas_instance_template *instancet;
 };
 #define MEGASAS_IS_LOGICAL(scp)                                         \
@@ -1125,11 +1151,10 @@ struct compat_megasas_iocpacket {
        struct compat_iovec sgl[MAX_IOCTL_SGE];
 } __attribute__ ((packed));
-#define MEGASAS_IOC_FIRMWARE    _IOWR('M', 1, struct compat_megasas_iocpacket)
-#else
-#define MEGASAS_IOC_FIRMWARE    _IOWR('M', 1, struct megasas_iocpacket)
 #endif
+#define MEGASAS_IOC_FIRMWARE    _IOWR('M', 1, struct megasas_iocpacket)
+#define MEGASAS_IOC_FIRMWARE32  _IOWR('M', 1, struct compat_megasas_iocpacket)
 #define MEGASAS_IOC_GET_AEN     _IOW('M', 3, struct megasas_aen)
 struct megasas_mgmt_info {
diff --git a/drivers/scsi/pcmcia/Kconfig b/drivers/scsi/pcmcia/Kconfig
index df52190f4d94..eac8e179cfff 100644
--- a/drivers/scsi/pcmcia/Kconfig
+++ b/drivers/scsi/pcmcia/Kconfig
@@ -8,6 +8,7 @@ menu "PCMCIA SCSI adapter support"
 config PCMCIA_AHA152X
        tristate "Adaptec AHA152X PCMCIA support"
        depends on m && !64BIT
+        select SCSI_SPI_ATTRS
        help
          Say Y here if you intend to attach this type of PCMCIA SCSI host
          adapter to your computer.
diff --git a/drivers/scsi/pcmcia/aha152x_stub.c b/drivers/scsi/pcmcia/aha152x_stub.c
index 0c9edb7051f4..5609847e254a 100644
--- a/drivers/scsi/pcmcia/aha152x_stub.c
+++ b/drivers/scsi/pcmcia/aha152x_stub.c
@@ -275,10 +275,8 @@ static int aha152x_resume(struct pcmcia_device *dev)
        link->state &= ~DEV_SUSPEND;
        if (link->state & DEV_CONFIG) {
-                Scsi_Cmnd tmp;
                pcmcia_request_configuration(link->handle, &link->conf);
-                tmp.device->host = info->host;
+                aha152x_host_reset_host(info->host);
-                aha152x_host_reset(&tmp);
        }
        return 0;
diff --git a/drivers/scsi/qla1280.c b/drivers/scsi/qla1280.c
index 0878f95b5449..e0230249fa0f 100644
--- a/drivers/scsi/qla1280.c
+++ b/drivers/scsi/qla1280.c
@@ -17,9 +17,11 @@
 * General Public License for more details.
 *
 ******************************************************************************/
-#define QLA1280_VERSION      "3.25"
+#define QLA1280_VERSION      "3.26"
 /*****************************************************************************
    Revision History:
+    Rev  3.26, January 16, 2006 Jes Sorensen
+        - Ditch all < 2.6 support
    Rev  3.25.1, February 10, 2005 Christoph Hellwig
        - use pci_map_single to map non-S/G requests
        - remove qla1280_proc_info
@@ -356,25 +358,18 @@
 #include <asm/types.h>
 #include <asm/system.h>
-#if LINUX_VERSION_CODE >= 0x020545
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_tcq.h>
-#else
-#include <linux/blk.h>
-#include "scsi.h"
-#include <scsi/scsi_host.h>
-#include "sd.h"
-#endif
 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
 #include <asm/sn/io.h>
 #endif
-#if LINUX_VERSION_CODE < 0x020407
+#if LINUX_VERSION_CODE < 0x020600
-#error "Kernels older than 2.4.7 are no longer supported"
+#error "Kernels older than 2.6.0 are no longer supported"
 #endif
@@ -441,52 +436,6 @@
 #define NVRAM_DELAY()                   udelay(500)     /* 2 microseconds */
-#if LINUX_VERSION_CODE < 0x020500
-#define HOST_LOCK                       &io_request_lock
-#define irqreturn_t                     void
-#define IRQ_RETVAL(foo)
-#define MSG_ORDERED_TAG                 1
-#define DMA_BIDIRECTIONAL       SCSI_DATA_UNKNOWN
-#define DMA_TO_DEVICE           SCSI_DATA_WRITE
-#define DMA_FROM_DEVICE         SCSI_DATA_READ
-#define DMA_NONE                SCSI_DATA_NONE
-#ifndef HAVE_SECTOR_T
-typedef unsigned int sector_t;
-#endif
-static inline void
-scsi_adjust_queue_depth(struct scsi_device *device, int tag, int depth)
-{
-        if (tag) {
-                device->tagged_queue = tag;
-                device->current_tag = 0;
-        }
-        device->queue_depth = depth;
-}
-static inline struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *t, size_t s)
-{
-        return scsi_register(t, s);
-}
-static inline void scsi_host_put(struct Scsi_Host *h)
-{
-        scsi_unregister(h);
-}
-#else
-#define HOST_LOCK                       ha->host->host_lock
-#endif
-#if LINUX_VERSION_CODE < 0x020600
-#define DEV_SIMPLE_TAGS(device)         device->tagged_queue
-/*
- * Hack around that qla1280_remove_one is called from
- * qla1280_release in 2.4
- */
-#undef __devexit
-#define __devexit
-#else
-#define DEV_SIMPLE_TAGS(device)         device->simple_tags
-#endif
 #if defined(__ia64__) && !defined(ia64_platform_is)
 #define ia64_platform_is(foo)           (!strcmp(x, platform_name))
 #endif
@@ -506,9 +455,6 @@ static void qla1280_remove_one(struct pci_dev *);
 *  QLogic Driver Support Function Prototypes.
 */
 static void qla1280_done(struct scsi_qla_host *);
-#if LINUX_VERSION_CODE < 0x020545
-static void qla1280_get_target_options(struct scsi_cmnd *, struct scsi_qla_host *);
-#endif
 static int qla1280_get_token(char *);
 static int qla1280_setup(char *s) __init;
@@ -610,11 +556,7 @@ __setup("qla1280=", qla1280_setup);
 #define CMD_SNSLEN(Cmnd)        sizeof(Cmnd->sense_buffer)
 #define CMD_RESULT(Cmnd)        Cmnd->result
 #define CMD_HANDLE(Cmnd)        Cmnd->host_scribble
-#if LINUX_VERSION_CODE < 0x020545
-#define CMD_REQUEST(Cmnd)       Cmnd->request.cmd
-#else
 #define CMD_REQUEST(Cmnd)       Cmnd->request->cmd
-#endif
 #define CMD_HOST(Cmnd)          Cmnd->device->host
 #define SCSI_BUS_32(Cmnd)       Cmnd->device->channel
@@ -1064,10 +1006,10 @@ qla1280_error_action(struct scsi_cmnd *cmd, enum action action)
        add_timer(&timer);
        /* wait for the action to complete (or the timer to expire) */
-        spin_unlock_irq(HOST_LOCK);
+        spin_unlock_irq(ha->host->host_lock);
        wait_for_completion(&wait);
        del_timer_sync(&timer);
-        spin_lock_irq(HOST_LOCK);
+        spin_lock_irq(ha->host->host_lock);
        sp->wait = NULL;
        /* the only action we might get a fail for is abort */
@@ -1173,96 +1115,6 @@ qla1280_biosparam(struct scsi_device *sdev, struct block_device *bdev,
        return 0;
 }
-#if LINUX_VERSION_CODE < 0x020600
-static int
-qla1280_detect(struct scsi_host_template *template)
-{
-        struct pci_device_id *id = &qla1280_pci_tbl[0];
-        struct pci_dev *pdev = NULL;
-        int num_hosts = 0;
-        if (sizeof(struct srb) > sizeof(Scsi_Pointer)) {
-                printk(KERN_WARNING
-                       "qla1280: struct srb too big, aborting\n");
-                return 0;
-        }
-        if ((DMA_BIDIRECTIONAL != PCI_DMA_BIDIRECTIONAL) ||
-            (DMA_TO_DEVICE != PCI_DMA_TODEVICE) ||
-            (DMA_FROM_DEVICE != PCI_DMA_FROMDEVICE) ||
-            (DMA_NONE != PCI_DMA_NONE)) {
-                printk(KERN_WARNING
-                       "qla1280: dma direction bits don't match\n");
-                return 0;
-        }
-#ifdef MODULE
-        /*
-         * If we are called as a module, the qla1280 pointer may not be null
-         * and it would point to our bootup string, just like on the lilo
-         * command line.  IF not NULL, then process this config string with
-         * qla1280_setup
-         *
-         * Boot time Options
-         * To add options at boot time add a line to your lilo.conf file like:
-         * append="qla1280=verbose,max_tags:{{255,255,255,255},{255,255,255,255}}"
-         * which will result in the first four devices on the first two
-         * controllers being set to a tagged queue depth of 32.
-         */
-        if (qla1280)
-                qla1280_setup(qla1280);
-#endif
-        /* First Initialize QLA12160 on PCI Bus 1 Dev 2 */
-        while ((pdev = pci_find_device(id->vendor, id->device, pdev))) {
-                if (pdev->bus->number == 1 && PCI_SLOT(pdev->devfn) == 2) {
-                        if (!qla1280_probe_one(pdev, id))
-                                num_hosts++;
-                }
-        }
-        pdev = NULL;
-        /* Try and find each different type of adapter we support */
-        for (id = &qla1280_pci_tbl[0]; id->device; id++) {
-                while ((pdev = pci_find_device(id->vendor, id->device, pdev))) {
-                        /*
-                         * skip QLA12160 already initialized on
-                         * PCI Bus 1 Dev 2 since we already initialized
-                         * and presented it
-                         */
-                        if (id->device == PCI_DEVICE_ID_QLOGIC_ISP12160 &&
-                            pdev->bus->number == 1 &&
-                            PCI_SLOT(pdev->devfn) == 2)
-                                continue;
-                        if (!qla1280_probe_one(pdev, id))
-                                num_hosts++;
-                }
-        }
-        return num_hosts;
-}
-/*
- * This looks a bit ugly as we could just pass down host to
- * qla1280_remove_one, but I want to keep qla1280_release purely a wrapper
- * around pci_driver::remove as used from 2.6 onwards.
- */
-static int
-qla1280_release(struct Scsi_Host *host)
-{
-        struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
-        qla1280_remove_one(ha->pdev);
-        return 0;
-}
-static int
-qla1280_biosparam_old(Disk * disk, kdev_t dev, int geom[])
-{
-        return qla1280_biosparam(disk->device, NULL, disk->capacity, geom);
-}
-#endif
 
 /* disable risc and host interrupts */
 static inline void
@@ -1295,7 +1147,7 @@ qla1280_intr_handler(int irq, void *dev_id, struct pt_regs *regs)
        ENTER_INTR ("qla1280_intr_handler");
        ha = (struct scsi_qla_host *)dev_id;
-        spin_lock(HOST_LOCK);
+        spin_lock(ha->host->host_lock);
        ha->isr_count++;
        reg = ha->iobase;
@@ -1311,7 +1163,7 @@ qla1280_intr_handler(int irq, void *dev_id, struct pt_regs *regs)
        if (!list_empty(&ha->done_q))
                qla1280_done(ha);
-        spin_unlock(HOST_LOCK);
+        spin_unlock(ha->host->host_lock);
        qla1280_enable_intrs(ha);
@@ -1411,11 +1263,9 @@ qla1280_slave_configure(struct scsi_device *device)
                scsi_adjust_queue_depth(device, 0, default_depth);
        }
-#if LINUX_VERSION_CODE > 0x020500
        nv->bus[bus].target[target].parameter.enable_sync = device->sdtr;
        nv->bus[bus].target[target].parameter.enable_wide = device->wdtr;
        nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = device->ppr;
-#endif
        if (driver_setup.no_sync ||
            (driver_setup.sync_mask &&
@@ -1432,38 +1282,14 @@ qla1280_slave_configure(struct scsi_device *device)
                        nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 0;
        }
-        spin_lock_irqsave(HOST_LOCK, flags);
+        spin_lock_irqsave(ha->host->host_lock, flags);
        if (nv->bus[bus].target[target].parameter.enable_sync)
                status = qla1280_set_target_parameters(ha, bus, target);
        qla1280_get_target_parameters(ha, device);
-        spin_unlock_irqrestore(HOST_LOCK, flags);
+        spin_unlock_irqrestore(ha->host->host_lock, flags);
        return status;
 }
-#if LINUX_VERSION_CODE < 0x020545
-/**************************************************************************
- *   qla1280_select_queue_depth
- *
- *   Sets the queue depth for each SCSI device hanging off the input
- *   host adapter.  We use a queue depth of 2 for devices that do not
- *   support tagged queueing.
- **************************************************************************/
-static void
-qla1280_select_queue_depth(struct Scsi_Host *host, struct scsi_device *sdev_q)
-{
-        struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
-        struct scsi_device *sdev;
-        ENTER("qla1280_select_queue_depth");
-        for (sdev = sdev_q; sdev; sdev = sdev->next)
-                if (sdev->host == host)
-                        qla1280_slave_configure(sdev);
-        if (sdev_q)
-                qla1280_check_for_dead_scsi_bus(ha, sdev_q->channel);
-        LEAVE("qla1280_select_queue_depth");
-}
-#endif
 /*
 * qla1280_done
@@ -1523,10 +1349,6 @@ qla1280_done(struct scsi_qla_host *ha)
                CMD_HANDLE(sp->cmd) = (unsigned char *)INVALID_HANDLE;
                ha->actthreads--;
-#if LINUX_VERSION_CODE < 0x020500
-                if (cmd->cmnd[0] == INQUIRY)
-                        qla1280_get_target_options(cmd, ha);
-#endif
                (*(cmd)->scsi_done)(cmd);
                if(sp->wait != NULL)
@@ -1655,9 +1477,7 @@ qla1280_initialize_adapter(struct scsi_qla_host *ha)
        struct device_reg __iomem *reg;
        int status;
        int bus;
-#if LINUX_VERSION_CODE > 0x020500
        unsigned long flags;
-#endif
        ENTER("qla1280_initialize_adapter");
@@ -1695,15 +1515,12 @@ qla1280_initialize_adapter(struct scsi_qla_host *ha)
                        "NVRAM\n");
        }
-#if LINUX_VERSION_CODE >= 0x020500
        /*
         * It's necessary to grab the spin here as qla1280_mailbox_command
         * needs to be able to drop the lock unconditionally to wait
         * for completion.
-         * In 2.4 ->detect is called with the io_request_lock held.
         */
-        spin_lock_irqsave(HOST_LOCK, flags);
+        spin_lock_irqsave(ha->host->host_lock, flags);
-#endif
        status = qla1280_load_firmware(ha);
        if (status) {
@@ -1735,9 +1552,8 @@ qla1280_initialize_adapter(struct scsi_qla_host *ha)
        ha->flags.online = 1;
 out:
-#if LINUX_VERSION_CODE >= 0x020500
+        spin_unlock_irqrestore(ha->host->host_lock, flags);
-        spin_unlock_irqrestore(HOST_LOCK, flags);
-#endif
        if (status)
                dprintk(2, "qla1280_initialize_adapter: **** FAILED ****\n");
@@ -2650,14 +2466,14 @@ qla1280_mailbox_command(struct scsi_qla_host *ha, uint8_t mr, uint16_t *mb)
        timer.function = qla1280_mailbox_timeout;
        add_timer(&timer);
-        spin_unlock_irq(HOST_LOCK);
+        spin_unlock_irq(ha->host->host_lock);
        WRT_REG_WORD(&reg->host_cmd, HC_SET_HOST_INT);
        data = qla1280_debounce_register(&reg->istatus);
        wait_for_completion(&wait);
        del_timer_sync(&timer);
-        spin_lock_irq(HOST_LOCK);
+        spin_lock_irq(ha->host->host_lock);
        ha->mailbox_wait = NULL;
@@ -2770,9 +2586,9 @@ qla1280_bus_reset(struct scsi_qla_host *ha, int bus)
                        ha->bus_settings[bus].scsi_bus_dead = 1;
                ha->bus_settings[bus].failed_reset_count++;
        } else {
-                spin_unlock_irq(HOST_LOCK);
+                spin_unlock_irq(ha->host->host_lock);
                ssleep(reset_delay);
-                spin_lock_irq(HOST_LOCK);
+                spin_lock_irq(ha->host->host_lock);
                ha->bus_settings[bus].scsi_bus_dead = 0;
                ha->bus_settings[bus].failed_reset_count = 0;
@@ -3078,7 +2894,7 @@ qla1280_64bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
                (SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd);
        /* Enable simple tag queuing if device supports it. */
-        if (DEV_SIMPLE_TAGS(cmd->device))
+        if (cmd->device->simple_tags)
                pkt->control_flags |= cpu_to_le16(BIT_3);
        /* Load SCSI command packet. */
@@ -3377,7 +3193,7 @@ qla1280_32bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
                (SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd);
        /* Enable simple tag queuing if device supports it. */
-        if (DEV_SIMPLE_TAGS(cmd->device))
+        if (cmd->device->simple_tags)
                pkt->control_flags |= cpu_to_le16(BIT_3);
        /* Load SCSI command packet. */
@@ -3889,50 +3705,6 @@ qla1280_rst_aen(struct scsi_qla_host *ha)
 }
-#if LINUX_VERSION_CODE < 0x020500
-/*
- *
- */
-static void
-qla1280_get_target_options(struct scsi_cmnd *cmd, struct scsi_qla_host *ha)
-{
-        unsigned char *result;
-        struct nvram *n;
-        int bus, target, lun;
-        bus = SCSI_BUS_32(cmd);
-        target = SCSI_TCN_32(cmd);
-        lun = SCSI_LUN_32(cmd);
-        /*
-         * Make sure to not touch anything if someone is using the
-         * sg interface.
-         */
-        if (cmd->use_sg || (CMD_RESULT(cmd) >> 16) != DID_OK || lun)
-                return;
-        result = cmd->request_buffer;
-        n = &ha->nvram;
-        n->bus[bus].target[target].parameter.enable_wide = 0;
-        n->bus[bus].target[target].parameter.enable_sync = 0;
-        n->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 0;
-        if (result[7] & 0x60)
-                n->bus[bus].target[target].parameter.enable_wide = 1;
-        if (result[7] & 0x10)
-                n->bus[bus].target[target].parameter.enable_sync = 1;
-        if ((result[2] >= 3) && (result[4] + 5 > 56) &&
-            (result[56] & 0x4))
-                n->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 1;
-        dprintk(2, "get_target_options(): wide %i, sync %i, ppr %i\n",
-                n->bus[bus].target[target].parameter.enable_wide,
-                n->bus[bus].target[target].parameter.enable_sync,
-                n->bus[bus].target[target].ppr_1x160.flags.enable_ppr);
-}
-#endif
 /*
 *  qla1280_status_entry
 *      Processes received ISP status entry.
@@ -4271,7 +4043,7 @@ qla1280_get_target_parameters(struct scsi_qla_host *ha,
        } else
                printk(" Async");
-        if (DEV_SIMPLE_TAGS(device))
+        if (device->simple_tags)
                printk(", Tagged queuing: depth %d", device->queue_depth);
        printk("\n");
 }
@@ -4485,7 +4257,7 @@ qla1280_get_token(char *str)
        return ret;
 }
-#if LINUX_VERSION_CODE >= 0x020600
 static struct scsi_host_template qla1280_driver_template = {
        .module                 = THIS_MODULE,
        .proc_name              = "qla1280",
@@ -4504,27 +4276,7 @@ static struct scsi_host_template qla1280_driver_template = {
        .cmd_per_lun            = 1,
        .use_clustering         = ENABLE_CLUSTERING,
 };
-#else
-static struct scsi_host_template qla1280_driver_template = {
-        .proc_name              = "qla1280",
-        .name                   = "Qlogic ISP 1280/12160",
-        .detect                 = qla1280_detect,
-        .release                = qla1280_release,
-        .info                   = qla1280_info,
-        .queuecommand           = qla1280_queuecommand,
-        .eh_abort_handler       = qla1280_eh_abort,
-        .eh_device_reset_handler= qla1280_eh_device_reset,
-        .eh_bus_reset_handler   = qla1280_eh_bus_reset,
-        .eh_host_reset_handler  = qla1280_eh_adapter_reset,
-        .bios_param             = qla1280_biosparam_old,
-        .can_queue              = 0xfffff,
-        .this_id                = -1,
-        .sg_tablesize           = SG_ALL,
-        .cmd_per_lun            = 1,
-        .use_clustering         = ENABLE_CLUSTERING,
-        .use_new_eh_code        = 1,
-};
-#endif
 static int __devinit
 qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
@@ -4615,10 +4367,6 @@ qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
        host->max_sectors = 1024;
        host->unique_id = host->host_no;
-#if LINUX_VERSION_CODE < 0x020545
-        host->select_queue_depths = qla1280_select_queue_depth;
-#endif
        error = -ENODEV;
 #if MEMORY_MAPPED_IO
@@ -4666,21 +4414,15 @@ qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
        pci_set_drvdata(pdev, host);
-#if LINUX_VERSION_CODE >= 0x020600
        error = scsi_add_host(host, &pdev->dev);
        if (error)
                goto error_disable_adapter;
        scsi_scan_host(host);
-#else
-        scsi_set_pci_device(host, pdev);
-#endif
        return 0;
-#if LINUX_VERSION_CODE >= 0x020600
 error_disable_adapter:
        qla1280_disable_intrs(ha);
-#endif
 error_free_irq:
        free_irq(pdev->irq, ha);
 error_release_region:
@@ -4712,9 +4454,7 @@ qla1280_remove_one(struct pci_dev *pdev)
        struct Scsi_Host *host = pci_get_drvdata(pdev);
        struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
-#if LINUX_VERSION_CODE >= 0x020600
        scsi_remove_host(host);
-#endif
        qla1280_disable_intrs(ha);
@@ -4738,7 +4478,6 @@ qla1280_remove_one(struct pci_dev *pdev)
        scsi_host_put(host);
 }
-#if LINUX_VERSION_CODE >= 0x020600
 static struct pci_driver qla1280_pci_driver = {
        .name           = "qla1280",
        .id_table       = qla1280_pci_tbl,
@@ -4784,10 +4523,6 @@ qla1280_exit(void)
 module_init(qla1280_init);
 module_exit(qla1280_exit);
-#else
-# define driver_template qla1280_driver_template
-# include "scsi_module.c"
-#endif
 MODULE_AUTHOR("Qlogic & Jes Sorensen");
 MODULE_DESCRIPTION("Qlogic ISP SCSI (qla1x80/qla1x160) driver");
diff --git a/drivers/scsi/qla2xxx/qla_attr.c b/drivers/scsi/qla2xxx/qla_attr.c
index b17ee62dd1a9..92b3e13e9061 100644
--- a/drivers/scsi/qla2xxx/qla_attr.c
+++ b/drivers/scsi/qla2xxx/qla_attr.c
@@ -7,7 +7,6 @@
 #include "qla_def.h"
 #include <linux/vmalloc.h>
-#include <scsi/scsi_transport_fc.h>
 /* SYSFS attributes --------------------------------------------------------- */
@@ -114,7 +113,7 @@ qla2x00_sysfs_read_nvram(struct kobject *kobj, char *buf, loff_t off,
            struct device, kobj)));
        unsigned long   flags;
-        if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->nvram_size)
+        if (!capable(CAP_SYS_ADMIN) || off != 0)
                return 0;
        /* Read NVRAM. */
@@ -123,7 +122,7 @@ qla2x00_sysfs_read_nvram(struct kobject *kobj, char *buf, loff_t off,
            ha->nvram_size);
        spin_unlock_irqrestore(&ha->hardware_lock, flags);
-        return (count);
+        return ha->nvram_size;
 }
 static ssize_t
@@ -175,19 +174,150 @@ static struct bin_attribute sysfs_nvram_attr = {
                .mode = S_IRUSR | S_IWUSR,
                .owner = THIS_MODULE,
        },
-        .size = 0,
+        .size = 512,
        .read = qla2x00_sysfs_read_nvram,
        .write = qla2x00_sysfs_write_nvram,
 };
+static ssize_t
+qla2x00_sysfs_read_optrom(struct kobject *kobj, char *buf, loff_t off,
+    size_t count)
+{
+        struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
+            struct device, kobj)));
+        if (ha->optrom_state != QLA_SREADING)
+                return 0;
+        if (off > ha->optrom_size)
+                return 0;
+        if (off + count > ha->optrom_size)
+                count = ha->optrom_size - off;
+        memcpy(buf, &ha->optrom_buffer[off], count);
+        return count;
+}
+static ssize_t
+qla2x00_sysfs_write_optrom(struct kobject *kobj, char *buf, loff_t off,
+    size_t count)
+{
+        struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
+            struct device, kobj)));
+        if (ha->optrom_state != QLA_SWRITING)
+                return -EINVAL;
+        if (off > ha->optrom_size)
+                return -ERANGE;
+        if (off + count > ha->optrom_size)
+                count = ha->optrom_size - off;
+        memcpy(&ha->optrom_buffer[off], buf, count);
+        return count;
+}
+static struct bin_attribute sysfs_optrom_attr = {
+        .attr = {
+                .name = "optrom",
+                .mode = S_IRUSR | S_IWUSR,
+                .owner = THIS_MODULE,
+        },
+        .size = OPTROM_SIZE_24XX,
+        .read = qla2x00_sysfs_read_optrom,
+        .write = qla2x00_sysfs_write_optrom,
+};
+static ssize_t
+qla2x00_sysfs_write_optrom_ctl(struct kobject *kobj, char *buf, loff_t off,
+    size_t count)
+{
+        struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
+            struct device, kobj)));
+        int val;
+        if (off)
+                return 0;
+        if (sscanf(buf, "%d", &val) != 1)
+                return -EINVAL;
+        switch (val) {
+        case 0:
+                if (ha->optrom_state != QLA_SREADING &&
+                    ha->optrom_state != QLA_SWRITING)
+                        break;
+                ha->optrom_state = QLA_SWAITING;
+                vfree(ha->optrom_buffer);
+                ha->optrom_buffer = NULL;
+                break;
+        case 1:
+                if (ha->optrom_state != QLA_SWAITING)
+                        break;
+                ha->optrom_state = QLA_SREADING;
+                ha->optrom_buffer = (uint8_t *)vmalloc(ha->optrom_size);
+                if (ha->optrom_buffer == NULL) {
+                        qla_printk(KERN_WARNING, ha,
+                            "Unable to allocate memory for optrom retrieval "
+                            "(%x).\n", ha->optrom_size);
+                        ha->optrom_state = QLA_SWAITING;
+                        return count;
+                }
+                memset(ha->optrom_buffer, 0, ha->optrom_size);
+                ha->isp_ops.read_optrom(ha, ha->optrom_buffer, 0,
+                    ha->optrom_size);
+                break;
+        case 2:
+                if (ha->optrom_state != QLA_SWAITING)
+                        break;
+                ha->optrom_state = QLA_SWRITING;
+                ha->optrom_buffer = (uint8_t *)vmalloc(ha->optrom_size);
+                if (ha->optrom_buffer == NULL) {
+                        qla_printk(KERN_WARNING, ha,
+                            "Unable to allocate memory for optrom update "
+                            "(%x).\n", ha->optrom_size);
+                        ha->optrom_state = QLA_SWAITING;
+                        return count;
+                }
+                memset(ha->optrom_buffer, 0, ha->optrom_size);
+                break;
+        case 3:
+                if (ha->optrom_state != QLA_SWRITING)
+                        break;
+                ha->isp_ops.write_optrom(ha, ha->optrom_buffer, 0,
+                    ha->optrom_size);
+                break;
+        }
+        return count;
+}
+static struct bin_attribute sysfs_optrom_ctl_attr = {
+        .attr = {
+                .name = "optrom_ctl",
+                .mode = S_IWUSR,
+                .owner = THIS_MODULE,
+        },
+        .size = 0,
+        .write = qla2x00_sysfs_write_optrom_ctl,
+};
 void
 qla2x00_alloc_sysfs_attr(scsi_qla_host_t *ha)
 {
        struct Scsi_Host *host = ha->host;
        sysfs_create_bin_file(&host->shost_gendev.kobj, &sysfs_fw_dump_attr);
-        sysfs_nvram_attr.size = ha->nvram_size;
        sysfs_create_bin_file(&host->shost_gendev.kobj, &sysfs_nvram_attr);
+        sysfs_create_bin_file(&host->shost_gendev.kobj, &sysfs_optrom_attr);
+        sysfs_create_bin_file(&host->shost_gendev.kobj,
+            &sysfs_optrom_ctl_attr);
 }
 void
@@ -197,6 +327,12 @@ qla2x00_free_sysfs_attr(scsi_qla_host_t *ha)
        sysfs_remove_bin_file(&host->shost_gendev.kobj, &sysfs_fw_dump_attr);
        sysfs_remove_bin_file(&host->shost_gendev.kobj, &sysfs_nvram_attr);
+        sysfs_remove_bin_file(&host->shost_gendev.kobj, &sysfs_optrom_attr);
+        sysfs_remove_bin_file(&host->shost_gendev.kobj,
+            &sysfs_optrom_ctl_attr);
+        if (ha->beacon_blink_led == 1)
+                ha->isp_ops.beacon_off(ha);
 }
 /* Scsi_Host attributes. */
@@ -384,6 +520,50 @@ qla2x00_zio_timer_store(struct class_device *cdev, const char *buf,
        return strlen(buf);
 }
+static ssize_t
+qla2x00_beacon_show(struct class_device *cdev, char *buf)
+{
+        scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
+        int len = 0;
+        if (ha->beacon_blink_led)
+                len += snprintf(buf + len, PAGE_SIZE-len, "Enabled\n");
+        else
+                len += snprintf(buf + len, PAGE_SIZE-len, "Disabled\n");
+        return len;
+}
+static ssize_t
+qla2x00_beacon_store(struct class_device *cdev, const char *buf,
+    size_t count)
+{
+        scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
+        int val = 0;
+        int rval;
+        if (IS_QLA2100(ha) || IS_QLA2200(ha))
+                return -EPERM;
+        if (test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags)) {
+                qla_printk(KERN_WARNING, ha,
+                    "Abort ISP active -- ignoring beacon request.\n");
+                return -EBUSY;
+        }
+        if (sscanf(buf, "%d", &val) != 1)
+                return -EINVAL;
+        if (val)
+                rval = ha->isp_ops.beacon_on(ha);
+        else
+                rval = ha->isp_ops.beacon_off(ha);
+        if (rval != QLA_SUCCESS)
+                count = 0;
+        return count;
+}
 static CLASS_DEVICE_ATTR(driver_version, S_IRUGO, qla2x00_drvr_version_show,
        NULL);
 static CLASS_DEVICE_ATTR(fw_version, S_IRUGO, qla2x00_fw_version_show, NULL);
@@ -398,6 +578,8 @@ static CLASS_DEVICE_ATTR(zio, S_IRUGO | S_IWUSR, qla2x00_zio_show,
    qla2x00_zio_store);
 static CLASS_DEVICE_ATTR(zio_timer, S_IRUGO | S_IWUSR, qla2x00_zio_timer_show,
    qla2x00_zio_timer_store);
+static CLASS_DEVICE_ATTR(beacon, S_IRUGO | S_IWUSR, qla2x00_beacon_show,
+    qla2x00_beacon_store);
 struct class_device_attribute *qla2x00_host_attrs[] = {
        &class_device_attr_driver_version,
@@ -411,6 +593,7 @@ struct class_device_attribute *qla2x00_host_attrs[] = {
        &class_device_attr_state,
        &class_device_attr_zio,
        &class_device_attr_zio_timer,
+        &class_device_attr_beacon,
        NULL,
 };
@@ -426,6 +609,49 @@ qla2x00_get_host_port_id(struct Scsi_Host *shost)
 }
 static void
+qla2x00_get_host_speed(struct Scsi_Host *shost)
+{
+        scsi_qla_host_t *ha = to_qla_host(shost);
+        uint32_t speed = 0;
+        switch (ha->link_data_rate) {
+        case LDR_1GB:
+                speed = 1;
+                break;
+        case LDR_2GB:
+                speed = 2;
+                break;
+        case LDR_4GB:
+                speed = 4;
+                break;
+        }
+        fc_host_speed(shost) = speed;
+}
+static void
+qla2x00_get_host_port_type(struct Scsi_Host *shost)
+{
+        scsi_qla_host_t *ha = to_qla_host(shost);
+        uint32_t port_type = FC_PORTTYPE_UNKNOWN;
+        switch (ha->current_topology) {
+        case ISP_CFG_NL:
+                port_type = FC_PORTTYPE_LPORT;
+                break;
+        case ISP_CFG_FL:
+                port_type = FC_PORTTYPE_NLPORT;
+                break;
+        case ISP_CFG_N:
+                port_type = FC_PORTTYPE_PTP;
+                break;
+        case ISP_CFG_F:
+                port_type = FC_PORTTYPE_NPORT;
+                break;
+        }
+        fc_host_port_type(shost) = port_type;
+}
+static void
 qla2x00_get_starget_node_name(struct scsi_target *starget)
 {
        struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
@@ -512,6 +738,41 @@ qla2x00_issue_lip(struct Scsi_Host *shost)
        return 0;
 }
+static struct fc_host_statistics *
+qla2x00_get_fc_host_stats(struct Scsi_Host *shost)
+{
+        scsi_qla_host_t *ha = to_qla_host(shost);
+        int rval;
+        uint16_t mb_stat[1];
+        link_stat_t stat_buf;
+        struct fc_host_statistics *pfc_host_stat;
+        pfc_host_stat = &ha->fc_host_stat;
+        memset(pfc_host_stat, -1, sizeof(struct fc_host_statistics));
+        if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) {
+                rval = qla24xx_get_isp_stats(ha, (uint32_t *)&stat_buf,
+                    sizeof(stat_buf) / 4, mb_stat);
+        } else {
+                rval = qla2x00_get_link_status(ha, ha->loop_id, &stat_buf,
+                    mb_stat);
+        }
+        if (rval != 0) {
+                qla_printk(KERN_WARNING, ha,
+                    "Unable to retrieve host statistics (%d).\n", mb_stat[0]);
+                return pfc_host_stat;
+        }
+        pfc_host_stat->link_failure_count = stat_buf.link_fail_cnt;
+        pfc_host_stat->loss_of_sync_count = stat_buf.loss_sync_cnt;
+        pfc_host_stat->loss_of_signal_count = stat_buf.loss_sig_cnt;
+        pfc_host_stat->prim_seq_protocol_err_count = stat_buf.prim_seq_err_cnt;
+        pfc_host_stat->invalid_tx_word_count = stat_buf.inval_xmit_word_cnt;
+        pfc_host_stat->invalid_crc_count = stat_buf.inval_crc_cnt;
+        return pfc_host_stat;
+}
 struct fc_function_template qla2xxx_transport_functions = {
        .show_host_node_name = 1,
@@ -520,6 +781,10 @@ struct fc_function_template qla2xxx_transport_functions = {
        .get_host_port_id = qla2x00_get_host_port_id,
        .show_host_port_id = 1,
+        .get_host_speed = qla2x00_get_host_speed,
+        .show_host_speed = 1,
+        .get_host_port_type = qla2x00_get_host_port_type,
+        .show_host_port_type = 1,
        .dd_fcrport_size = sizeof(struct fc_port *),
        .show_rport_supported_classes = 1,
@@ -536,6 +801,7 @@ struct fc_function_template qla2xxx_transport_functions = {
        .show_rport_dev_loss_tmo = 1,
        .issue_fc_host_lip = qla2x00_issue_lip,
+        .get_fc_host_stats = qla2x00_get_fc_host_stats,
 };
 void
diff --git a/drivers/scsi/qla2xxx/qla_def.h b/drivers/scsi/qla2xxx/qla_def.h
index 79d8a914f9d0..b31a03bbd14f 100644
--- a/drivers/scsi/qla2xxx/qla_def.h
+++ b/drivers/scsi/qla2xxx/qla_def.h
@@ -29,6 +29,7 @@
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_cmnd.h>
+#include <scsi/scsi_transport_fc.h>
 #if defined(CONFIG_SCSI_QLA2XXX_EMBEDDED_FIRMWARE)
 #if defined(CONFIG_SCSI_QLA21XX) || defined(CONFIG_SCSI_QLA21XX_MODULE)
@@ -181,6 +182,13 @@
 #define WRT_REG_DWORD(addr, data)       writel(data,addr)
 /*
+ * The ISP2312 v2 chip cannot access the FLASH/GPIO registers via MMIO in an
+ * 133Mhz slot.
+ */
+#define RD_REG_WORD_PIO(addr)           (inw((unsigned long)addr))
+#define WRT_REG_WORD_PIO(addr, data)    (outw(data,(unsigned long)addr))
+/*
 * Fibre Channel device definitions.
 */
 #define WWN_SIZE                8       /* Size of WWPN, WWN & WWNN */
@@ -432,6 +440,9 @@ struct device_reg_2xxx {
 #define GPIO_LED_GREEN_ON_AMBER_OFF     0x0040
 #define GPIO_LED_GREEN_OFF_AMBER_ON     0x0080
 #define GPIO_LED_GREEN_ON_AMBER_ON      0x00C0
+#define GPIO_LED_ALL_OFF                0x0000
+#define GPIO_LED_RED_ON_OTHER_OFF       0x0001  /* isp2322 */
+#define GPIO_LED_RGA_ON                 0x00C1  /* isp2322: red green amber */
        union {
                struct {
@@ -1680,7 +1691,8 @@ typedef struct fc_port {
        uint8_t mp_byte;                /* multi-path byte (not used) */
        uint8_t cur_path;               /* current path id */
-        struct fc_rport *rport;
+        spinlock_t rport_lock;
+        struct fc_rport *rport, *drport;
        u32 supported_classes;
        struct work_struct rport_add_work;
        struct work_struct rport_del_work;
@@ -2198,6 +2210,15 @@ struct isp_operations {
        void (*fw_dump) (struct scsi_qla_host *, int);
        void (*ascii_fw_dump) (struct scsi_qla_host *);
+        int (*beacon_on) (struct scsi_qla_host *);
+        int (*beacon_off) (struct scsi_qla_host *);
+        void (*beacon_blink) (struct scsi_qla_host *);
+        uint8_t * (*read_optrom) (struct scsi_qla_host *, uint8_t *,
+                uint32_t, uint32_t);
+        int (*write_optrom) (struct scsi_qla_host *, uint8_t *, uint32_t,
+                uint32_t);
 };
 /*
@@ -2270,6 +2291,7 @@ typedef struct scsi_qla_host {
 #define LOOP_RESET_NEEDED       24
 #define BEACON_BLINK_NEEDED     25
 #define REGISTER_FDMI_NEEDED    26
+#define FCPORT_UPDATE_NEEDED    27
        uint32_t        device_flags;
 #define DFLG_LOCAL_DEVICES              BIT_0
@@ -2329,6 +2351,10 @@ typedef struct scsi_qla_host {
        uint16_t        min_external_loopid;    /* First external loop Id */
        uint16_t        link_data_rate;         /* F/W operating speed */
+#define LDR_1GB         0
+#define LDR_2GB         1
+#define LDR_4GB         3
+#define LDR_UNKNOWN     0xFFFF
        uint8_t         current_topology;
        uint8_t         prev_topology;
@@ -2484,12 +2510,26 @@ typedef struct scsi_qla_host {
        uint8_t         *port_name;
        uint32_t    isp_abort_cnt;
+        /* Option ROM information. */
+        char            *optrom_buffer;
+        uint32_t        optrom_size;
+        int             optrom_state;
+#define QLA_SWAITING    0
+#define QLA_SREADING    1
+#define QLA_SWRITING    2
        /* Needed for BEACON */
        uint16_t        beacon_blink_led;
-        uint16_t        beacon_green_on;
+        uint8_t         beacon_color_state;
+#define QLA_LED_GRN_ON          0x01
+#define QLA_LED_YLW_ON          0x02
+#define QLA_LED_ABR_ON          0x04
+#define QLA_LED_ALL_ON          0x07    /* yellow, green, amber. */
+                                        /* ISP2322: red, green, amber. */
        uint16_t        zio_mode;
        uint16_t        zio_timer;
+        struct fc_host_statistics fc_host_stat;
 } scsi_qla_host_t;
@@ -2555,7 +2595,9 @@ struct _qla2x00stats  {
 /*
 * Flash support definitions
 */
-#define FLASH_IMAGE_SIZE        131072
+#define OPTROM_SIZE_2300        0x20000
+#define OPTROM_SIZE_2322        0x100000
+#define OPTROM_SIZE_24XX        0x100000
 #include "qla_gbl.h"
 #include "qla_dbg.h"
diff --git a/drivers/scsi/qla2xxx/qla_gbl.h b/drivers/scsi/qla2xxx/qla_gbl.h
index 32be4c14cccb..ffdc2680f049 100644
--- a/drivers/scsi/qla2xxx/qla_gbl.h
+++ b/drivers/scsi/qla2xxx/qla_gbl.h
@@ -47,9 +47,11 @@ extern int qla2x00_local_device_login(scsi_qla_host_t *, uint16_t);
 extern void qla2x00_restart_queues(scsi_qla_host_t *, uint8_t);
 extern void qla2x00_rescan_fcports(scsi_qla_host_t *);
+extern void qla2x00_update_fcports(scsi_qla_host_t *);
 extern int qla2x00_abort_isp(scsi_qla_host_t *);
+extern void qla2x00_update_fcport(scsi_qla_host_t *, fc_port_t *);
 extern void qla2x00_reg_remote_port(scsi_qla_host_t *, fc_port_t *);
 /*
@@ -70,15 +72,15 @@ extern char *qla2x00_get_fw_version_str(struct scsi_qla_host *, char *);
 extern void qla2x00_cmd_timeout(srb_t *);
-extern void qla2x00_mark_device_lost(scsi_qla_host_t *, fc_port_t *, int);
+extern void qla2x00_mark_device_lost(scsi_qla_host_t *, fc_port_t *, int, int);
-extern void qla2x00_mark_all_devices_lost(scsi_qla_host_t *);
+extern void qla2x00_mark_all_devices_lost(scsi_qla_host_t *, int);
-extern void qla2x00_blink_led(scsi_qla_host_t *);
 extern int qla2x00_down_timeout(struct semaphore *, unsigned long);
 extern struct fw_blob *qla2x00_request_firmware(scsi_qla_host_t *);
+extern int qla2x00_wait_for_hba_online(scsi_qla_host_t *);
 /*
 * Global Function Prototypes in qla_iocb.c source file.
 */
@@ -183,6 +185,13 @@ qla2x00_get_resource_cnts(scsi_qla_host_t *, uint16_t *, uint16_t *, uint16_t *,
 extern int
 qla2x00_get_fcal_position_map(scsi_qla_host_t *ha, char *pos_map);
+extern int
+qla2x00_get_link_status(scsi_qla_host_t *, uint16_t, link_stat_t *,
+    uint16_t *);
+extern int
+qla24xx_get_isp_stats(scsi_qla_host_t *, uint32_t *, uint32_t, uint16_t *);
 extern int qla24xx_abort_command(scsi_qla_host_t *, srb_t *);
 extern int qla24xx_abort_target(fc_port_t *);
@@ -226,6 +235,22 @@ extern int qla2x00_write_nvram_data(scsi_qla_host_t *, uint8_t *, uint32_t,
 extern int qla24xx_write_nvram_data(scsi_qla_host_t *, uint8_t *, uint32_t,
    uint32_t);
+extern int qla2x00_beacon_on(struct scsi_qla_host *);
+extern int qla2x00_beacon_off(struct scsi_qla_host *);
+extern void qla2x00_beacon_blink(struct scsi_qla_host *);
+extern int qla24xx_beacon_on(struct scsi_qla_host *);
+extern int qla24xx_beacon_off(struct scsi_qla_host *);
+extern void qla24xx_beacon_blink(struct scsi_qla_host *);
+extern uint8_t *qla2x00_read_optrom_data(struct scsi_qla_host *, uint8_t *,
+    uint32_t, uint32_t);
+extern int qla2x00_write_optrom_data(struct scsi_qla_host *, uint8_t *,
+    uint32_t, uint32_t);
+extern uint8_t *qla24xx_read_optrom_data(struct scsi_qla_host *, uint8_t *,
+    uint32_t, uint32_t);
+extern int qla24xx_write_optrom_data(struct scsi_qla_host *, uint8_t *,
+    uint32_t, uint32_t);
 /*
 * Global Function Prototypes in qla_dbg.c source file.
 */
diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c
index a91fea69ad63..634ee174bff2 100644
--- a/drivers/scsi/qla2xxx/qla_init.c
+++ b/drivers/scsi/qla2xxx/qla_init.c
@@ -8,7 +8,6 @@
 #include <linux/delay.h>
 #include <linux/vmalloc.h>
-#include <scsi/scsi_transport_fc.h>
 #include "qla_devtbl.h"
@@ -32,7 +31,6 @@ static int qla2x00_fw_ready(scsi_qla_host_t *);
 static int qla2x00_configure_hba(scsi_qla_host_t *);
 static int qla2x00_configure_loop(scsi_qla_host_t *);
 static int qla2x00_configure_local_loop(scsi_qla_host_t *);
-static void qla2x00_update_fcport(scsi_qla_host_t *, fc_port_t *);
 static int qla2x00_configure_fabric(scsi_qla_host_t *);
 static int qla2x00_find_all_fabric_devs(scsi_qla_host_t *, struct list_head *);
 static int qla2x00_device_resync(scsi_qla_host_t *);
@@ -1688,10 +1686,16 @@ static void
 qla2x00_rport_del(void *data)
 {
        fc_port_t *fcport = data;
+        struct fc_rport *rport;
+        unsigned long flags;
+        spin_lock_irqsave(&fcport->rport_lock, flags);
+        rport = fcport->drport;
+        fcport->drport = NULL;
+        spin_unlock_irqrestore(&fcport->rport_lock, flags);
+        if (rport)
+                fc_remote_port_delete(rport);
-        if (fcport->rport)
-                fc_remote_port_delete(fcport->rport);
-        fcport->rport = NULL;
 }
 /**
@@ -1719,6 +1723,7 @@ qla2x00_alloc_fcport(scsi_qla_host_t *ha, gfp_t flags)
        atomic_set(&fcport->state, FCS_UNCONFIGURED);
        fcport->flags = FCF_RLC_SUPPORT;
        fcport->supported_classes = FC_COS_UNSPECIFIED;
+        spin_lock_init(&fcport->rport_lock);
        INIT_WORK(&fcport->rport_add_work, qla2x00_rport_add, fcport);
        INIT_WORK(&fcport->rport_del_work, qla2x00_rport_del, fcport);
@@ -2008,7 +2013,7 @@ qla2x00_probe_for_all_luns(scsi_qla_host_t *ha)
 {
        fc_port_t       *fcport;
-        qla2x00_mark_all_devices_lost(ha);
+        qla2x00_mark_all_devices_lost(ha, 0);
        list_for_each_entry(fcport, &ha->fcports, list) {
                if (fcport->port_type != FCT_TARGET)
                        continue;
@@ -2032,13 +2037,9 @@ qla2x00_probe_for_all_luns(scsi_qla_host_t *ha)
 * Context:
 *      Kernel context.
 */
-static void
+void
 qla2x00_update_fcport(scsi_qla_host_t *ha, fc_port_t *fcport)
 {
-        uint16_t        index;
-        unsigned long flags;
-        srb_t *sp;
        fcport->ha = ha;
        fcport->login_retry = 0;
        fcport->port_login_retry_count = ha->port_down_retry_count *
@@ -2047,28 +2048,6 @@ qla2x00_update_fcport(scsi_qla_host_t *ha, fc_port_t *fcport)
            PORT_RETRY_TIME);
        fcport->flags &= ~FCF_LOGIN_NEEDED;
-        /*
-         * Check for outstanding cmd on tape Bypass LUN discovery if active
-         * command on tape.
-         */
-        if (fcport->flags & FCF_TAPE_PRESENT) {
-                spin_lock_irqsave(&ha->hardware_lock, flags);
-                for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) {
-                        fc_port_t *sfcp;
-                        if ((sp = ha->outstanding_cmds[index]) != 0) {
-                                sfcp = sp->fcport;
-                                if (sfcp == fcport) {
-                                        atomic_set(&fcport->state, FCS_ONLINE);
-                                        spin_unlock_irqrestore(
-                                            &ha->hardware_lock, flags);
-                                        return;
-                                }
-                        }
-                }
-                spin_unlock_irqrestore(&ha->hardware_lock, flags);
-        }
        if (fcport->port_type == FCT_INITIATOR ||
            fcport->port_type == FCT_BROADCAST)
                fcport->device_type = TYPE_PROCESSOR;
@@ -2084,24 +2063,29 @@ qla2x00_reg_remote_port(scsi_qla_host_t *ha, fc_port_t *fcport)
 {
        struct fc_rport_identifiers rport_ids;
        struct fc_rport *rport;
+        unsigned long flags;
-        if (fcport->rport) {
+        if (fcport->drport)
-                fc_remote_port_delete(fcport->rport);
+                qla2x00_rport_del(fcport);
-                fcport->rport = NULL;
+        if (fcport->rport)
-        }
+                return;
        rport_ids.node_name = wwn_to_u64(fcport->node_name);
        rport_ids.port_name = wwn_to_u64(fcport->port_name);
        rport_ids.port_id = fcport->d_id.b.domain << 16 |
            fcport->d_id.b.area << 8 | fcport->d_id.b.al_pa;
        rport_ids.roles = FC_RPORT_ROLE_UNKNOWN;
-        fcport->rport = rport = fc_remote_port_add(ha->host, 0, &rport_ids);
+        rport = fc_remote_port_add(ha->host, 0, &rport_ids);
        if (!rport) {
                qla_printk(KERN_WARNING, ha,
                    "Unable to allocate fc remote port!\n");
                return;
        }
+        spin_lock_irqsave(&fcport->rport_lock, flags);
+        fcport->rport = rport;
        *((fc_port_t **)rport->dd_data) = fcport;
+        spin_unlock_irqrestore(&fcport->rport_lock, flags);
        rport->supported_classes = fcport->supported_classes;
        rport_ids.roles = FC_RPORT_ROLE_UNKNOWN;
@@ -2217,12 +2201,11 @@ qla2x00_configure_fabric(scsi_qla_host_t *ha)
                        if (atomic_read(&fcport->state) == FCS_DEVICE_LOST) {
                                qla2x00_mark_device_lost(ha, fcport,
-                                    ql2xplogiabsentdevice);
+                                    ql2xplogiabsentdevice, 0);
                                if (fcport->loop_id != FC_NO_LOOP_ID &&
                                    (fcport->flags & FCF_TAPE_PRESENT) == 0 &&
                                    fcport->port_type != FCT_INITIATOR &&
                                    fcport->port_type != FCT_BROADCAST) {
                                        ha->isp_ops.fabric_logout(ha,
                                            fcport->loop_id,
                                            fcport->d_id.b.domain,
@@ -2694,7 +2677,8 @@ qla2x00_device_resync(scsi_qla_host_t *ha)
                        if (atomic_read(&fcport->state) == FCS_ONLINE) {
                                if (format != 3 ||
                                    fcport->port_type != FCT_INITIATOR) {
-                                        qla2x00_mark_device_lost(ha, fcport, 0);
+                                        qla2x00_mark_device_lost(ha, fcport,
+                                            0, 0);
                                }
                        }
                        fcport->flags &= ~FCF_FARP_DONE;
@@ -2741,8 +2725,7 @@ qla2x00_fabric_dev_login(scsi_qla_host_t *ha, fc_port_t *fcport,
                        ha->isp_ops.fabric_logout(ha, fcport->loop_id,
                            fcport->d_id.b.domain, fcport->d_id.b.area,
                            fcport->d_id.b.al_pa);
-                        qla2x00_mark_device_lost(ha, fcport, 1);
+                        qla2x00_mark_device_lost(ha, fcport, 1, 0);
                } else {
                        qla2x00_update_fcport(ha, fcport);
                }
@@ -2855,7 +2838,7 @@ qla2x00_fabric_login(scsi_qla_host_t *ha, fc_port_t *fcport,
                        ha->isp_ops.fabric_logout(ha, fcport->loop_id,
                            fcport->d_id.b.domain, fcport->d_id.b.area,
                            fcport->d_id.b.al_pa);
-                        qla2x00_mark_device_lost(ha, fcport, 1);
+                        qla2x00_mark_device_lost(ha, fcport, 1, 0);
                        rval = 1;
                        break;
@@ -2990,6 +2973,17 @@ qla2x00_rescan_fcports(scsi_qla_host_t *ha)
        qla2x00_probe_for_all_luns(ha);
 }
+void
+qla2x00_update_fcports(scsi_qla_host_t *ha)
+{
+        fc_port_t *fcport;
+        /* Go with deferred removal of rport references. */
+        list_for_each_entry(fcport, &ha->fcports, list)
+                if (fcport->drport)
+                        qla2x00_rport_del(fcport);
+}
 /*
 *  qla2x00_abort_isp
 *      Resets ISP and aborts all outstanding commands.
@@ -3019,7 +3013,7 @@ qla2x00_abort_isp(scsi_qla_host_t *ha)
                atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME);
                if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
                        atomic_set(&ha->loop_state, LOOP_DOWN);
-                        qla2x00_mark_all_devices_lost(ha);
+                        qla2x00_mark_all_devices_lost(ha, 0);
                } else {
                        if (!atomic_read(&ha->loop_down_timer))
                                atomic_set(&ha->loop_down_timer,
diff --git a/drivers/scsi/qla2xxx/qla_iocb.c b/drivers/scsi/qla2xxx/qla_iocb.c
index 7ec0b8d6f07b..6544b6d0891d 100644
--- a/drivers/scsi/qla2xxx/qla_iocb.c
+++ b/drivers/scsi/qla2xxx/qla_iocb.c
@@ -814,6 +814,7 @@ qla24xx_start_scsi(srb_t *sp)
        cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain;
        int_to_scsilun(sp->cmd->device->lun, &cmd_pkt->lun);
+        host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun));
        /* Load SCSI command packet. */
        memcpy(cmd_pkt->fcp_cdb, cmd->cmnd, cmd->cmd_len);
diff --git a/drivers/scsi/qla2xxx/qla_isr.c b/drivers/scsi/qla2xxx/qla_isr.c
index f63af081d4ff..42aa7a7c1a73 100644
--- a/drivers/scsi/qla2xxx/qla_isr.c
+++ b/drivers/scsi/qla2xxx/qla_isr.c
@@ -389,7 +389,7 @@ qla2x00_async_event(scsi_qla_host_t *ha, uint16_t *mb)
                if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
                        atomic_set(&ha->loop_state, LOOP_DOWN);
                        atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME);
-                        qla2x00_mark_all_devices_lost(ha);
+                        qla2x00_mark_all_devices_lost(ha, 1);
                }
                set_bit(REGISTER_FC4_NEEDED, &ha->dpc_flags);
@@ -402,9 +402,9 @@ qla2x00_async_event(scsi_qla_host_t *ha, uint16_t *mb)
                break;
        case MBA_LOOP_UP:               /* Loop Up Event */
-                ha->link_data_rate = 0;
                if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
                        link_speed = link_speeds[0];
+                        ha->link_data_rate = LDR_1GB;
                } else {
                        link_speed = link_speeds[LS_UNKNOWN];
                        if (mb[1] < 5)
@@ -432,11 +432,11 @@ qla2x00_async_event(scsi_qla_host_t *ha, uint16_t *mb)
                        atomic_set(&ha->loop_state, LOOP_DOWN);
                        atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME);
                        ha->device_flags |= DFLG_NO_CABLE;
-                        qla2x00_mark_all_devices_lost(ha);
+                        qla2x00_mark_all_devices_lost(ha, 1);
                }
                ha->flags.management_server_logged_in = 0;
-                ha->link_data_rate = 0;
+                ha->link_data_rate = LDR_UNKNOWN;
                if (ql2xfdmienable)
                        set_bit(REGISTER_FDMI_NEEDED, &ha->dpc_flags);
@@ -453,7 +453,7 @@ qla2x00_async_event(scsi_qla_host_t *ha, uint16_t *mb)
                if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
                        atomic_set(&ha->loop_state, LOOP_DOWN);
                        atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME);
-                        qla2x00_mark_all_devices_lost(ha);
+                        qla2x00_mark_all_devices_lost(ha, 1);
                }
                set_bit(RESET_MARKER_NEEDED, &ha->dpc_flags);
@@ -482,7 +482,7 @@ qla2x00_async_event(scsi_qla_host_t *ha, uint16_t *mb)
                        if (!atomic_read(&ha->loop_down_timer))
                                atomic_set(&ha->loop_down_timer,
                                    LOOP_DOWN_TIME);
-                        qla2x00_mark_all_devices_lost(ha);
+                        qla2x00_mark_all_devices_lost(ha, 1);
                }
                if (!(test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags))) {
@@ -506,7 +506,7 @@ qla2x00_async_event(scsi_qla_host_t *ha, uint16_t *mb)
                        if (!atomic_read(&ha->loop_down_timer))
                                atomic_set(&ha->loop_down_timer,
                                    LOOP_DOWN_TIME);
-                        qla2x00_mark_all_devices_lost(ha);
+                        qla2x00_mark_all_devices_lost(ha, 1);
                }
                set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);
@@ -580,7 +580,7 @@ qla2x00_async_event(scsi_qla_host_t *ha, uint16_t *mb)
                 */
                atomic_set(&ha->loop_state, LOOP_UP);
-                qla2x00_mark_all_devices_lost(ha);
+                qla2x00_mark_all_devices_lost(ha, 1);
                ha->flags.rscn_queue_overflow = 1;
@@ -1091,7 +1091,7 @@ qla2x00_status_entry(scsi_qla_host_t *ha, void *pkt)
                cp->result = DID_BUS_BUSY << 16;
                if (atomic_read(&fcport->state) == FCS_ONLINE) {
-                        qla2x00_mark_device_lost(ha, fcport, 1);
+                        qla2x00_mark_device_lost(ha, fcport, 1, 1);
                }
                break;
@@ -1135,7 +1135,7 @@ qla2x00_status_entry(scsi_qla_host_t *ha, void *pkt)
                /* Check to see if logout occurred. */
                if ((le16_to_cpu(sts->status_flags) & SF_LOGOUT_SENT))
-                        qla2x00_mark_device_lost(ha, fcport, 1);
+                        qla2x00_mark_device_lost(ha, fcport, 1, 1);
                break;
        case CS_QUEUE_FULL:
diff --git a/drivers/scsi/qla2xxx/qla_mbx.c b/drivers/scsi/qla2xxx/qla_mbx.c
index 3099b379de9d..363dfdd042b0 100644
--- a/drivers/scsi/qla2xxx/qla_mbx.c
+++ b/drivers/scsi/qla2xxx/qla_mbx.c
@@ -7,7 +7,6 @@
 #include "qla_def.h"
 #include <linux/delay.h>
-#include <scsi/scsi_transport_fc.h>
 static void
 qla2x00_mbx_sem_timeout(unsigned long data)
@@ -1874,7 +1873,8 @@ qla2x00_get_id_list(scsi_qla_host_t *ha, void *id_list, dma_addr_t id_list_dma,
                mcp->mb[3] = LSW(id_list_dma);
                mcp->mb[6] = MSW(MSD(id_list_dma));
                mcp->mb[7] = LSW(MSD(id_list_dma));
-                mcp->out_mb |= MBX_7|MBX_6|MBX_3|MBX_2;
+                mcp->mb[8] = 0;
+                mcp->out_mb |= MBX_8|MBX_7|MBX_6|MBX_3|MBX_2;
        } else {
                mcp->mb[1] = MSW(id_list_dma);
                mcp->mb[2] = LSW(id_list_dma);
@@ -2017,8 +2017,109 @@ qla2x00_get_fcal_position_map(scsi_qla_host_t *ha, char *pos_map)
        return rval;
 }
+#endif
+/*
+ * qla2x00_get_link_status
+ *
+ * Input:
+ *      ha = adapter block pointer.
+ *      loop_id = device loop ID.
+ *      ret_buf = pointer to link status return buffer.
+ *
+ * Returns:
+ *      0 = success.
+ *      BIT_0 = mem alloc error.
+ *      BIT_1 = mailbox error.
+ */
+int
+qla2x00_get_link_status(scsi_qla_host_t *ha, uint16_t loop_id,
+    link_stat_t *ret_buf, uint16_t *status)
+{
+        int rval;
+        mbx_cmd_t mc;
+        mbx_cmd_t *mcp = &mc;
+        link_stat_t *stat_buf;
+        dma_addr_t stat_buf_dma;
+        DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no);)
+        stat_buf = dma_pool_alloc(ha->s_dma_pool, GFP_ATOMIC, &stat_buf_dma);
+        if (stat_buf == NULL) {
+                DEBUG2_3_11(printk("%s(%ld): Failed to allocate memory.\n",
+                    __func__, ha->host_no));
+                return BIT_0;
+        }
+        memset(stat_buf, 0, sizeof(link_stat_t));
+        mcp->mb[0] = MBC_GET_LINK_STATUS;
+        mcp->mb[2] = MSW(stat_buf_dma);
+        mcp->mb[3] = LSW(stat_buf_dma);
+        mcp->mb[6] = MSW(MSD(stat_buf_dma));
+        mcp->mb[7] = LSW(MSD(stat_buf_dma));
+        mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
+        mcp->in_mb = MBX_0;
+        if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) {
+                mcp->mb[1] = loop_id;
+                mcp->mb[4] = 0;
+                mcp->mb[10] = 0;
+                mcp->out_mb |= MBX_10|MBX_4|MBX_1;
+                mcp->in_mb |= MBX_1;
+        } else if (HAS_EXTENDED_IDS(ha)) {
+                mcp->mb[1] = loop_id;
+                mcp->mb[10] = 0;
+                mcp->out_mb |= MBX_10|MBX_1;
+        } else {
+                mcp->mb[1] = loop_id << 8;
+                mcp->out_mb |= MBX_1;
+        }
+        mcp->tov = 30;
+        mcp->flags = IOCTL_CMD;
+        rval = qla2x00_mailbox_command(ha, mcp);
+        if (rval == QLA_SUCCESS) {
+                if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
+                        DEBUG2_3_11(printk("%s(%ld): cmd failed. mbx0=%x.\n",
+                            __func__, ha->host_no, mcp->mb[0]);)
+                        status[0] = mcp->mb[0];
+                        rval = BIT_1;
+                } else {
+                        /* copy over data -- firmware data is LE. */
+                        ret_buf->link_fail_cnt =
+                            le32_to_cpu(stat_buf->link_fail_cnt);
+                        ret_buf->loss_sync_cnt =
+                            le32_to_cpu(stat_buf->loss_sync_cnt);
+                        ret_buf->loss_sig_cnt =
+                            le32_to_cpu(stat_buf->loss_sig_cnt);
+                        ret_buf->prim_seq_err_cnt =
+                            le32_to_cpu(stat_buf->prim_seq_err_cnt);
+                        ret_buf->inval_xmit_word_cnt =
+                            le32_to_cpu(stat_buf->inval_xmit_word_cnt);
+                        ret_buf->inval_crc_cnt =
+                            le32_to_cpu(stat_buf->inval_crc_cnt);
+                        DEBUG11(printk("%s(%ld): stat dump: fail_cnt=%d "
+                            "loss_sync=%d loss_sig=%d seq_err=%d "
+                            "inval_xmt_word=%d inval_crc=%d.\n", __func__,
+                            ha->host_no, stat_buf->link_fail_cnt,
+                            stat_buf->loss_sync_cnt, stat_buf->loss_sig_cnt,
+                            stat_buf->prim_seq_err_cnt,
+                            stat_buf->inval_xmit_word_cnt,
+                            stat_buf->inval_crc_cnt);)
+                }
+        } else {
+                /* Failed. */
+                DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
+                    ha->host_no, rval);)
+                rval = BIT_1;
+        }
+        dma_pool_free(ha->s_dma_pool, stat_buf, stat_buf_dma);
-uint8_t
+        return rval;
+}
+int
 qla24xx_get_isp_stats(scsi_qla_host_t *ha, uint32_t *dwbuf, uint32_t dwords,
    uint16_t *status)
 {
@@ -2080,7 +2181,6 @@ qla24xx_get_isp_stats(scsi_qla_host_t *ha, uint32_t *dwbuf, uint32_t dwords,
        return rval;
 }
-#endif
 int
 qla24xx_abort_command(scsi_qla_host_t *ha, srb_t *sp)
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index 4916847d84ec..9f91f1a20542 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -366,6 +366,12 @@ qla2x00_queuecommand(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
                goto qc_fail_command;
        }
+        /* Close window on fcport/rport state-transitioning. */
+        if (!*(fc_port_t **)rport->dd_data) {
+                cmd->result = DID_IMM_RETRY << 16;
+                goto qc_fail_command;
+        }
        if (atomic_read(&fcport->state) != FCS_ONLINE) {
                if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD ||
                    atomic_read(&ha->loop_state) == LOOP_DEAD) {
@@ -421,6 +427,12 @@ qla24xx_queuecommand(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
                goto qc24_fail_command;
        }
+        /* Close window on fcport/rport state-transitioning. */
+        if (!*(fc_port_t **)rport->dd_data) {
+                cmd->result = DID_IMM_RETRY << 16;
+                goto qc24_fail_command;
+        }
        if (atomic_read(&fcport->state) != FCS_ONLINE) {
                if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD ||
                    atomic_read(&ha->loop_state) == LOOP_DEAD) {
@@ -513,7 +525,7 @@ qla2x00_eh_wait_on_command(scsi_qla_host_t *ha, struct scsi_cmnd *cmd)
 *    Success (Adapter is online) : 0
 *    Failed  (Adapter is offline/disabled) : 1
 */
-static int
+int
 qla2x00_wait_for_hba_online(scsi_qla_host_t *ha)
 {
        int             return_status;
@@ -756,7 +768,7 @@ qla2xxx_eh_device_reset(struct scsi_cmnd *cmd)
                if (ret == SUCCESS) {
                        if (fcport->flags & FC_FABRIC_DEVICE) {
                                ha->isp_ops.fabric_logout(ha, fcport->loop_id);
-                                qla2x00_mark_device_lost(ha, fcport);
+                                qla2x00_mark_device_lost(ha, fcport, 0, 0);
                        }
                }
 #endif
@@ -1312,6 +1324,8 @@ int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info)
        ha->ports = MAX_BUSES;
        ha->init_cb_size = sizeof(init_cb_t);
        ha->mgmt_svr_loop_id = MANAGEMENT_SERVER;
+        ha->link_data_rate = LDR_UNKNOWN;
+        ha->optrom_size = OPTROM_SIZE_2300;
        /* Assign ISP specific operations. */
        ha->isp_ops.pci_config          = qla2100_pci_config;
@@ -1339,6 +1353,8 @@ int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info)
        ha->isp_ops.write_nvram         = qla2x00_write_nvram_data;
        ha->isp_ops.fw_dump             = qla2100_fw_dump;
        ha->isp_ops.ascii_fw_dump       = qla2100_ascii_fw_dump;
+        ha->isp_ops.read_optrom         = qla2x00_read_optrom_data;
+        ha->isp_ops.write_optrom        = qla2x00_write_optrom_data;
        if (IS_QLA2100(ha)) {
                host->max_id = MAX_TARGETS_2100;
                ha->mbx_count = MAILBOX_REGISTER_COUNT_2100;
@@ -1364,7 +1380,12 @@ int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info)
                ha->isp_ops.intr_handler = qla2300_intr_handler;
                ha->isp_ops.fw_dump = qla2300_fw_dump;
                ha->isp_ops.ascii_fw_dump = qla2300_ascii_fw_dump;
+                ha->isp_ops.beacon_on = qla2x00_beacon_on;
+                ha->isp_ops.beacon_off = qla2x00_beacon_off;
+                ha->isp_ops.beacon_blink = qla2x00_beacon_blink;
                ha->gid_list_info_size = 6;
+                if (IS_QLA2322(ha) || IS_QLA6322(ha))
+                        ha->optrom_size = OPTROM_SIZE_2322;
        } else if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) {
                host->max_id = MAX_TARGETS_2200;
                ha->mbx_count = MAILBOX_REGISTER_COUNT;
@@ -1400,7 +1421,13 @@ int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info)
                ha->isp_ops.write_nvram = qla24xx_write_nvram_data;
                ha->isp_ops.fw_dump = qla24xx_fw_dump;
                ha->isp_ops.ascii_fw_dump = qla24xx_ascii_fw_dump;
+                ha->isp_ops.read_optrom = qla24xx_read_optrom_data;
+                ha->isp_ops.write_optrom = qla24xx_write_optrom_data;
+                ha->isp_ops.beacon_on = qla24xx_beacon_on;
+                ha->isp_ops.beacon_off = qla24xx_beacon_off;
+                ha->isp_ops.beacon_blink = qla24xx_beacon_blink;
                ha->gid_list_info_size = 8;
+                ha->optrom_size = OPTROM_SIZE_24XX;
        }
        host->can_queue = ha->request_q_length + 128;
@@ -1642,6 +1669,33 @@ qla2x00_free_device(scsi_qla_host_t *ha)
        pci_disable_device(ha->pdev);
 }
+static inline void
+qla2x00_schedule_rport_del(struct scsi_qla_host *ha, fc_port_t *fcport,
+    int defer)
+{
+        unsigned long flags;
+        struct fc_rport *rport;
+        if (!fcport->rport)
+                return;
+        rport = fcport->rport;
+        if (defer) {
+                spin_lock_irqsave(&fcport->rport_lock, flags);
+                fcport->drport = rport;
+                fcport->rport = NULL;
+                *(fc_port_t **)rport->dd_data = NULL;
+                spin_unlock_irqrestore(&fcport->rport_lock, flags);
+                set_bit(FCPORT_UPDATE_NEEDED, &ha->dpc_flags);
+        } else {
+                spin_lock_irqsave(&fcport->rport_lock, flags);
+                fcport->rport = NULL;
+                *(fc_port_t **)rport->dd_data = NULL;
+                spin_unlock_irqrestore(&fcport->rport_lock, flags);
+                fc_remote_port_delete(rport);
+        }
+}
 /*
 * qla2x00_mark_device_lost Updates fcport state when device goes offline.
 *
@@ -1652,10 +1706,10 @@ qla2x00_free_device(scsi_qla_host_t *ha)
 * Context:
 */
 void qla2x00_mark_device_lost(scsi_qla_host_t *ha, fc_port_t *fcport,
-    int do_login)
+    int do_login, int defer)
 {
-        if (atomic_read(&fcport->state) == FCS_ONLINE && fcport->rport)
+        if (atomic_read(&fcport->state) == FCS_ONLINE)
-                schedule_work(&fcport->rport_del_work);
+                qla2x00_schedule_rport_del(ha, fcport, defer);
        /*
         * We may need to retry the login, so don't change the state of the
@@ -1702,7 +1756,7 @@ void qla2x00_mark_device_lost(scsi_qla_host_t *ha, fc_port_t *fcport,
 * Context:
 */
 void
-qla2x00_mark_all_devices_lost(scsi_qla_host_t *ha)
+qla2x00_mark_all_devices_lost(scsi_qla_host_t *ha, int defer)
 {
        fc_port_t *fcport;
@@ -1716,10 +1770,13 @@ qla2x00_mark_all_devices_lost(scsi_qla_host_t *ha)
                 */
                if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD)
                        continue;
-                if (atomic_read(&fcport->state) == FCS_ONLINE && fcport->rport)
+                if (atomic_read(&fcport->state) == FCS_ONLINE)
-                        schedule_work(&fcport->rport_del_work);
+                        qla2x00_schedule_rport_del(ha, fcport, defer);
                atomic_set(&fcport->state, FCS_DEVICE_LOST);
        }
+        if (defer && ha->dpc_wait && !ha->dpc_active)
+                up(ha->dpc_wait);
 }
 /*
@@ -2038,6 +2095,8 @@ qla2x00_mem_free(scsi_qla_host_t *ha)
        ha->fw_dumped = 0;
        ha->fw_dump_reading = 0;
        ha->fw_dump_buffer = NULL;
+        vfree(ha->optrom_buffer);
 }
 /*
@@ -2161,6 +2220,9 @@ qla2x00_do_dpc(void *data)
                            ha->host_no));
                }
+                if (test_and_clear_bit(FCPORT_UPDATE_NEEDED, &ha->dpc_flags))
+                        qla2x00_update_fcports(ha);
                if (test_and_clear_bit(LOOP_RESET_NEEDED, &ha->dpc_flags)) {
                        DEBUG(printk("scsi(%ld): dpc: sched loop_reset()\n",
                            ha->host_no));
@@ -2219,13 +2281,8 @@ qla2x00_do_dpc(void *data)
                                                DEBUG(printk("scsi(%ld): port login OK: logged in ID 0x%x\n",
                                                    ha->host_no, fcport->loop_id));
-                                                fcport->port_login_retry_count =
+                                                qla2x00_update_fcport(ha,
-                                                    ha->port_down_retry_count * PORT_RETRY_TIME;
+                                                    fcport);
-                                                atomic_set(&fcport->state, FCS_ONLINE);
-                                                atomic_set(&fcport->port_down_timer,
-                                                    ha->port_down_retry_count * PORT_RETRY_TIME);
-                                                fcport->login_retry = 0;
                                        } else if (status == 1) {
                                                set_bit(RELOGIN_NEEDED, &ha->dpc_flags);
                                                /* retry the login again */
@@ -2288,6 +2345,9 @@ qla2x00_do_dpc(void *data)
                if (!ha->interrupts_on)
                        ha->isp_ops.enable_intrs(ha);
+                if (test_and_clear_bit(BEACON_BLINK_NEEDED, &ha->dpc_flags))
+                        ha->isp_ops.beacon_blink(ha);
                ha->dpc_active = 0;
        } /* End of while(1) */
@@ -2465,13 +2525,21 @@ qla2x00_timer(scsi_qla_host_t *ha)
                    atomic_read(&ha->loop_down_timer)));
        }
+        /* Check if beacon LED needs to be blinked */
+        if (ha->beacon_blink_led == 1) {
+                set_bit(BEACON_BLINK_NEEDED, &ha->dpc_flags);
+                start_dpc++;
+        }
        /* Schedule the DPC routine if needed */
        if ((test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags) ||
            test_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags) ||
            test_bit(LOOP_RESET_NEEDED, &ha->dpc_flags) ||
+            test_bit(FCPORT_UPDATE_NEEDED, &ha->dpc_flags) ||
            start_dpc ||
            test_bit(LOGIN_RETRY_NEEDED, &ha->dpc_flags) ||
            test_bit(RESET_MARKER_NEEDED, &ha->dpc_flags) ||
+            test_bit(BEACON_BLINK_NEEDED, &ha->dpc_flags) ||
            test_bit(RELOGIN_NEEDED, &ha->dpc_flags)) &&
            ha->dpc_wait && !ha->dpc_active) {
diff --git a/drivers/scsi/qla2xxx/qla_rscn.c b/drivers/scsi/qla2xxx/qla_rscn.c
index 2c3342108dd8..b70bebe18c01 100644
--- a/drivers/scsi/qla2xxx/qla_rscn.c
+++ b/drivers/scsi/qla2xxx/qla_rscn.c
@@ -6,8 +6,6 @@
 */
 #include "qla_def.h"
-#include <scsi/scsi_transport_fc.h>
 /**
 * IO descriptor handle definitions.
 *
diff --git a/drivers/scsi/qla2xxx/qla_sup.c b/drivers/scsi/qla2xxx/qla_sup.c
index f4d755a643e4..3866a5760f15 100644
--- a/drivers/scsi/qla2xxx/qla_sup.c
+++ b/drivers/scsi/qla2xxx/qla_sup.c
@@ -695,3 +695,966 @@ qla24xx_write_nvram_data(scsi_qla_host_t *ha, uint8_t *buf, uint32_t naddr,
        return ret;
 }
+static inline void
+qla2x00_flip_colors(scsi_qla_host_t *ha, uint16_t *pflags)
+{
+        if (IS_QLA2322(ha)) {
+                /* Flip all colors. */
+                if (ha->beacon_color_state == QLA_LED_ALL_ON) {
+                        /* Turn off. */
+                        ha->beacon_color_state = 0;
+                        *pflags = GPIO_LED_ALL_OFF;
+                } else {
+                        /* Turn on. */
+                        ha->beacon_color_state = QLA_LED_ALL_ON;
+                        *pflags = GPIO_LED_RGA_ON;
+                }
+        } else {
+                /* Flip green led only. */
+                if (ha->beacon_color_state == QLA_LED_GRN_ON) {
+                        /* Turn off. */
+                        ha->beacon_color_state = 0;
+                        *pflags = GPIO_LED_GREEN_OFF_AMBER_OFF;
+                } else {
+                        /* Turn on. */
+                        ha->beacon_color_state = QLA_LED_GRN_ON;
+                        *pflags = GPIO_LED_GREEN_ON_AMBER_OFF;
+                }
+        }
+}
+void
+qla2x00_beacon_blink(struct scsi_qla_host *ha)
+{
+        uint16_t gpio_enable;
+        uint16_t gpio_data;
+        uint16_t led_color = 0;
+        unsigned long flags;
+        struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
+        if (ha->pio_address)
+                reg = (struct device_reg_2xxx __iomem *)ha->pio_address;
+        spin_lock_irqsave(&ha->hardware_lock, flags);
+        /* Save the Original GPIOE. */
+        if (ha->pio_address) {
+                gpio_enable = RD_REG_WORD_PIO(&reg->gpioe);
+                gpio_data = RD_REG_WORD_PIO(&reg->gpiod);
+        } else {
+                gpio_enable = RD_REG_WORD(&reg->gpioe);
+                gpio_data = RD_REG_WORD(&reg->gpiod);
+        }
+        /* Set the modified gpio_enable values */
+        gpio_enable |= GPIO_LED_MASK;
+        if (ha->pio_address) {
+                WRT_REG_WORD_PIO(&reg->gpioe, gpio_enable);
+        } else {
+                WRT_REG_WORD(&reg->gpioe, gpio_enable);
+                RD_REG_WORD(&reg->gpioe);
+        }
+        qla2x00_flip_colors(ha, &led_color);
+        /* Clear out any previously set LED color. */
+        gpio_data &= ~GPIO_LED_MASK;
+        /* Set the new input LED color to GPIOD. */
+        gpio_data |= led_color;
+        /* Set the modified gpio_data values */
+        if (ha->pio_address) {
+                WRT_REG_WORD_PIO(&reg->gpiod, gpio_data);
+        } else {
+                WRT_REG_WORD(&reg->gpiod, gpio_data);
+                RD_REG_WORD(&reg->gpiod);
+        }
+        spin_unlock_irqrestore(&ha->hardware_lock, flags);
+}
+int
+qla2x00_beacon_on(struct scsi_qla_host *ha)
+{
+        uint16_t gpio_enable;
+        uint16_t gpio_data;
+        unsigned long flags;
+        struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
+        ha->fw_options[1] &= ~FO1_SET_EMPHASIS_SWING;
+        ha->fw_options[1] |= FO1_DISABLE_GPIO6_7;
+        if (qla2x00_set_fw_options(ha, ha->fw_options) != QLA_SUCCESS) {
+                qla_printk(KERN_WARNING, ha,
+                    "Unable to update fw options (beacon on).\n");
+                return QLA_FUNCTION_FAILED;
+        }
+        if (ha->pio_address)
+                reg = (struct device_reg_2xxx __iomem *)ha->pio_address;
+        /* Turn off LEDs. */
+        spin_lock_irqsave(&ha->hardware_lock, flags);
+        if (ha->pio_address) {
+                gpio_enable = RD_REG_WORD_PIO(&reg->gpioe);
+                gpio_data = RD_REG_WORD_PIO(&reg->gpiod);
+        } else {
+                gpio_enable = RD_REG_WORD(&reg->gpioe);
+                gpio_data = RD_REG_WORD(&reg->gpiod);
+        }
+        gpio_enable |= GPIO_LED_MASK;
+        /* Set the modified gpio_enable values. */
+        if (ha->pio_address) {
+                WRT_REG_WORD_PIO(&reg->gpioe, gpio_enable);
+        } else {
+                WRT_REG_WORD(&reg->gpioe, gpio_enable);
+                RD_REG_WORD(&reg->gpioe);
+        }
+        /* Clear out previously set LED colour. */
+        gpio_data &= ~GPIO_LED_MASK;
+        if (ha->pio_address) {
+                WRT_REG_WORD_PIO(&reg->gpiod, gpio_data);
+        } else {
+                WRT_REG_WORD(&reg->gpiod, gpio_data);
+                RD_REG_WORD(&reg->gpiod);
+        }
+        spin_unlock_irqrestore(&ha->hardware_lock, flags);
+        /*
+         * Let the per HBA timer kick off the blinking process based on
+         * the following flags. No need to do anything else now.
+         */
+        ha->beacon_blink_led = 1;
+        ha->beacon_color_state = 0;
+        return QLA_SUCCESS;
+}
+int
+qla2x00_beacon_off(struct scsi_qla_host *ha)
+{
+        int rval = QLA_SUCCESS;
+        ha->beacon_blink_led = 0;
+        /* Set the on flag so when it gets flipped it will be off. */
+        if (IS_QLA2322(ha))
+                ha->beacon_color_state = QLA_LED_ALL_ON;
+        else
+                ha->beacon_color_state = QLA_LED_GRN_ON;
+        ha->isp_ops.beacon_blink(ha);   /* This turns green LED off */
+        ha->fw_options[1] &= ~FO1_SET_EMPHASIS_SWING;
+        ha->fw_options[1] &= ~FO1_DISABLE_GPIO6_7;
+        rval = qla2x00_set_fw_options(ha, ha->fw_options);
+        if (rval != QLA_SUCCESS)
+                qla_printk(KERN_WARNING, ha,
+                    "Unable to update fw options (beacon off).\n");
+        return rval;
+}
+static inline void
+qla24xx_flip_colors(scsi_qla_host_t *ha, uint16_t *pflags)
+{
+        /* Flip all colors. */
+        if (ha->beacon_color_state == QLA_LED_ALL_ON) {
+                /* Turn off. */
+                ha->beacon_color_state = 0;
+                *pflags = 0;
+        } else {
+                /* Turn on. */
+                ha->beacon_color_state = QLA_LED_ALL_ON;
+                *pflags = GPDX_LED_YELLOW_ON | GPDX_LED_AMBER_ON;
+        }
+}
+void
+qla24xx_beacon_blink(struct scsi_qla_host *ha)
+{
+        uint16_t led_color = 0;
+        uint32_t gpio_data;
+        unsigned long flags;
+        struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
+        /* Save the Original GPIOD. */
+        spin_lock_irqsave(&ha->hardware_lock, flags);
+        gpio_data = RD_REG_DWORD(&reg->gpiod);
+        /* Enable the gpio_data reg for update. */
+        gpio_data |= GPDX_LED_UPDATE_MASK;
+        WRT_REG_DWORD(&reg->gpiod, gpio_data);
+        gpio_data = RD_REG_DWORD(&reg->gpiod);
+        /* Set the color bits. */
+        qla24xx_flip_colors(ha, &led_color);
+        /* Clear out any previously set LED color. */
+        gpio_data &= ~GPDX_LED_COLOR_MASK;
+        /* Set the new input LED color to GPIOD. */
+        gpio_data |= led_color;
+        /* Set the modified gpio_data values. */
+        WRT_REG_DWORD(&reg->gpiod, gpio_data);
+        gpio_data = RD_REG_DWORD(&reg->gpiod);
+        spin_unlock_irqrestore(&ha->hardware_lock, flags);
+}
+int
+qla24xx_beacon_on(struct scsi_qla_host *ha)
+{
+        uint32_t gpio_data;
+        unsigned long flags;
+        struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
+        if (ha->beacon_blink_led == 0) {
+                /* Enable firmware for update */
+                ha->fw_options[1] |= ADD_FO1_DISABLE_GPIO_LED_CTRL;
+                if (qla2x00_set_fw_options(ha, ha->fw_options) != QLA_SUCCESS)
+                        return QLA_FUNCTION_FAILED;
+                if (qla2x00_get_fw_options(ha, ha->fw_options) !=
+                    QLA_SUCCESS) {
+                        qla_printk(KERN_WARNING, ha,
+                            "Unable to update fw options (beacon on).\n");
+                        return QLA_FUNCTION_FAILED;
+                }
+                spin_lock_irqsave(&ha->hardware_lock, flags);
+                gpio_data = RD_REG_DWORD(&reg->gpiod);
+                /* Enable the gpio_data reg for update. */
+                gpio_data |= GPDX_LED_UPDATE_MASK;
+                WRT_REG_DWORD(&reg->gpiod, gpio_data);
+                RD_REG_DWORD(&reg->gpiod);
+                spin_unlock_irqrestore(&ha->hardware_lock, flags);
+        }
+        /* So all colors blink together. */
+        ha->beacon_color_state = 0;
+        /* Let the per HBA timer kick off the blinking process. */
+        ha->beacon_blink_led = 1;
+        return QLA_SUCCESS;
+}
+int
+qla24xx_beacon_off(struct scsi_qla_host *ha)
+{
+        uint32_t gpio_data;
+        unsigned long flags;
+        struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
+        ha->beacon_blink_led = 0;
+        ha->beacon_color_state = QLA_LED_ALL_ON;
+        ha->isp_ops.beacon_blink(ha);   /* Will flip to all off. */
+        /* Give control back to firmware. */
+        spin_lock_irqsave(&ha->hardware_lock, flags);
+        gpio_data = RD_REG_DWORD(&reg->gpiod);
+        /* Disable the gpio_data reg for update. */
+        gpio_data &= ~GPDX_LED_UPDATE_MASK;
+        WRT_REG_DWORD(&reg->gpiod, gpio_data);
+        RD_REG_DWORD(&reg->gpiod);
+        spin_unlock_irqrestore(&ha->hardware_lock, flags);
+        ha->fw_options[1] &= ~ADD_FO1_DISABLE_GPIO_LED_CTRL;
+        if (qla2x00_set_fw_options(ha, ha->fw_options) != QLA_SUCCESS) {
+                qla_printk(KERN_WARNING, ha,
+                    "Unable to update fw options (beacon off).\n");
+                return QLA_FUNCTION_FAILED;
+        }
+        if (qla2x00_get_fw_options(ha, ha->fw_options) != QLA_SUCCESS) {
+                qla_printk(KERN_WARNING, ha,
+                    "Unable to get fw options (beacon off).\n");
+                return QLA_FUNCTION_FAILED;
+        }
+        return QLA_SUCCESS;
+}
+/*
+ * Flash support routines
+ */
+/**
+ * qla2x00_flash_enable() - Setup flash for reading and writing.
+ * @ha: HA context
+ */
+static void
+qla2x00_flash_enable(scsi_qla_host_t *ha)
+{
+        uint16_t data;
+        struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
+        data = RD_REG_WORD(&reg->ctrl_status);
+        data |= CSR_FLASH_ENABLE;
+        WRT_REG_WORD(&reg->ctrl_status, data);
+        RD_REG_WORD(&reg->ctrl_status);         /* PCI Posting. */
+}
+/**
+ * qla2x00_flash_disable() - Disable flash and allow RISC to run.
+ * @ha: HA context
+ */
+static void
+qla2x00_flash_disable(scsi_qla_host_t *ha)
+{
+        uint16_t data;
+        struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
+        data = RD_REG_WORD(&reg->ctrl_status);
+        data &= ~(CSR_FLASH_ENABLE);
+        WRT_REG_WORD(&reg->ctrl_status, data);
+        RD_REG_WORD(&reg->ctrl_status);         /* PCI Posting. */
+}
+/**
+ * qla2x00_read_flash_byte() - Reads a byte from flash
+ * @ha: HA context
+ * @addr: Address in flash to read
+ *
+ * A word is read from the chip, but, only the lower byte is valid.
+ *
+ * Returns the byte read from flash @addr.
+ */
+static uint8_t
+qla2x00_read_flash_byte(scsi_qla_host_t *ha, uint32_t addr)
+{
+        uint16_t data;
+        uint16_t bank_select;
+        struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
+        bank_select = RD_REG_WORD(&reg->ctrl_status);
+        if (IS_QLA2322(ha) || IS_QLA6322(ha)) {
+                /* Specify 64K address range: */
+                /*  clear out Module Select and Flash Address bits [19:16]. */
+                bank_select &= ~0xf8;
+                bank_select |= addr >> 12 & 0xf0;
+                bank_select |= CSR_FLASH_64K_BANK;
+                WRT_REG_WORD(&reg->ctrl_status, bank_select);
+                RD_REG_WORD(&reg->ctrl_status); /* PCI Posting. */
+                WRT_REG_WORD(&reg->flash_address, (uint16_t)addr);
+                data = RD_REG_WORD(&reg->flash_data);
+                return (uint8_t)data;
+        }
+        /* Setup bit 16 of flash address. */
+        if ((addr & BIT_16) && ((bank_select & CSR_FLASH_64K_BANK) == 0)) {
+                bank_select |= CSR_FLASH_64K_BANK;
+                WRT_REG_WORD(&reg->ctrl_status, bank_select);
+                RD_REG_WORD(&reg->ctrl_status); /* PCI Posting. */
+        } else if (((addr & BIT_16) == 0) &&
+            (bank_select & CSR_FLASH_64K_BANK)) {
+                bank_select &= ~(CSR_FLASH_64K_BANK);
+                WRT_REG_WORD(&reg->ctrl_status, bank_select);
+                RD_REG_WORD(&reg->ctrl_status); /* PCI Posting. */
+        }
+        /* Always perform IO mapped accesses to the FLASH registers. */
+        if (ha->pio_address) {
+                uint16_t data2;
+                reg = (struct device_reg_2xxx __iomem *)ha->pio_address;
+                WRT_REG_WORD_PIO(&reg->flash_address, (uint16_t)addr);
+                do {
+                        data = RD_REG_WORD_PIO(&reg->flash_data);
+                        barrier();
+                        cpu_relax();
+                        data2 = RD_REG_WORD_PIO(&reg->flash_data);
+                } while (data != data2);
+        } else {
+                WRT_REG_WORD(&reg->flash_address, (uint16_t)addr);
+                data = qla2x00_debounce_register(&reg->flash_data);
+        }
+        return (uint8_t)data;
+}
+/**
+ * qla2x00_write_flash_byte() - Write a byte to flash
+ * @ha: HA context
+ * @addr: Address in flash to write
+ * @data: Data to write
+ */
+static void
+qla2x00_write_flash_byte(scsi_qla_host_t *ha, uint32_t addr, uint8_t data)
+{
+        uint16_t bank_select;
+        struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
+        bank_select = RD_REG_WORD(&reg->ctrl_status);
+        if (IS_QLA2322(ha) || IS_QLA6322(ha)) {
+                /* Specify 64K address range: */
+                /*  clear out Module Select and Flash Address bits [19:16]. */
+                bank_select &= ~0xf8;
+                bank_select |= addr >> 12 & 0xf0;
+                bank_select |= CSR_FLASH_64K_BANK;
+                WRT_REG_WORD(&reg->ctrl_status, bank_select);
+                RD_REG_WORD(&reg->ctrl_status); /* PCI Posting. */
+                WRT_REG_WORD(&reg->flash_address, (uint16_t)addr);
+                RD_REG_WORD(&reg->ctrl_status);         /* PCI Posting. */
+                WRT_REG_WORD(&reg->flash_data, (uint16_t)data);
+                RD_REG_WORD(&reg->ctrl_status);         /* PCI Posting. */
+                return;
+        }
+        /* Setup bit 16 of flash address. */
+        if ((addr & BIT_16) && ((bank_select & CSR_FLASH_64K_BANK) == 0)) {
+                bank_select |= CSR_FLASH_64K_BANK;
+                WRT_REG_WORD(&reg->ctrl_status, bank_select);
+                RD_REG_WORD(&reg->ctrl_status); /* PCI Posting. */
+        } else if (((addr & BIT_16) == 0) &&
+            (bank_select & CSR_FLASH_64K_BANK)) {
+                bank_select &= ~(CSR_FLASH_64K_BANK);
+                WRT_REG_WORD(&reg->ctrl_status, bank_select);
+                RD_REG_WORD(&reg->ctrl_status); /* PCI Posting. */
+        }
+        /* Always perform IO mapped accesses to the FLASH registers. */
+        if (ha->pio_address) {
+                reg = (struct device_reg_2xxx __iomem *)ha->pio_address;
+                WRT_REG_WORD_PIO(&reg->flash_address, (uint16_t)addr);
+                WRT_REG_WORD_PIO(&reg->flash_data, (uint16_t)data);
+        } else {
+                WRT_REG_WORD(&reg->flash_address, (uint16_t)addr);
+                RD_REG_WORD(&reg->ctrl_status);         /* PCI Posting. */
+                WRT_REG_WORD(&reg->flash_data, (uint16_t)data);
+                RD_REG_WORD(&reg->ctrl_status);         /* PCI Posting. */
+        }
+}
+/**
+ * qla2x00_poll_flash() - Polls flash for completion.
+ * @ha: HA context
+ * @addr: Address in flash to poll
+ * @poll_data: Data to be polled
+ * @man_id: Flash manufacturer ID
+ * @flash_id: Flash ID
+ *
+ * This function polls the device until bit 7 of what is read matches data
+ * bit 7 or until data bit 5 becomes a 1.  If that hapens, the flash ROM timed
+ * out (a fatal error).  The flash book recommeds reading bit 7 again after
+ * reading bit 5 as a 1.
+ *
+ * Returns 0 on success, else non-zero.
+ */
+static int
+qla2x00_poll_flash(scsi_qla_host_t *ha, uint32_t addr, uint8_t poll_data,
+    uint8_t man_id, uint8_t flash_id)
+{
+        int status;
+        uint8_t flash_data;
+        uint32_t cnt;
+        status = 1;
+        /* Wait for 30 seconds for command to finish. */
+        poll_data &= BIT_7;
+        for (cnt = 3000000; cnt; cnt--) {
+                flash_data = qla2x00_read_flash_byte(ha, addr);
+                if ((flash_data & BIT_7) == poll_data) {
+                        status = 0;
+                        break;
+                }
+                if (man_id != 0x40 && man_id != 0xda) {
+                        if ((flash_data & BIT_5) && cnt > 2)
+                                cnt = 2;
+                }
+                udelay(10);
+                barrier();
+        }
+        return status;
+}
+#define IS_OEM_001(ha) \
+        ((ha)->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2322 && \
+         (ha)->pdev->subsystem_vendor == 0x1028 && \
+         (ha)->pdev->subsystem_device == 0x0170)
+/**
+ * qla2x00_program_flash_address() - Programs a flash address
+ * @ha: HA context
+ * @addr: Address in flash to program
+ * @data: Data to be written in flash
+ * @man_id: Flash manufacturer ID
+ * @flash_id: Flash ID
+ *
+ * Returns 0 on success, else non-zero.
+ */
+static int
+qla2x00_program_flash_address(scsi_qla_host_t *ha, uint32_t addr, uint8_t data,
+    uint8_t man_id, uint8_t flash_id)
+{
+        /* Write Program Command Sequence. */
+        if (IS_OEM_001(ha)) {
+                qla2x00_write_flash_byte(ha, 0xaaa, 0xaa);
+                qla2x00_write_flash_byte(ha, 0x555, 0x55);
+                qla2x00_write_flash_byte(ha, 0xaaa, 0xa0);
+                qla2x00_write_flash_byte(ha, addr, data);
+        } else {
+                if (man_id == 0xda && flash_id == 0xc1) {
+                        qla2x00_write_flash_byte(ha, addr, data);
+                        if (addr & 0x7e)
+                                return 0;
+                } else {
+                        qla2x00_write_flash_byte(ha, 0x5555, 0xaa);
+                        qla2x00_write_flash_byte(ha, 0x2aaa, 0x55);
+                        qla2x00_write_flash_byte(ha, 0x5555, 0xa0);
+                        qla2x00_write_flash_byte(ha, addr, data);
+                }
+        }
+        udelay(150);
+        /* Wait for write to complete. */
+        return qla2x00_poll_flash(ha, addr, data, man_id, flash_id);
+}
+/**
+ * qla2x00_erase_flash() - Erase the flash.
+ * @ha: HA context
+ * @man_id: Flash manufacturer ID
+ * @flash_id: Flash ID
+ *
+ * Returns 0 on success, else non-zero.
+ */
+static int
+qla2x00_erase_flash(scsi_qla_host_t *ha, uint8_t man_id, uint8_t flash_id)
+{
+        /* Individual Sector Erase Command Sequence */
+        if (IS_OEM_001(ha)) {
+                qla2x00_write_flash_byte(ha, 0xaaa, 0xaa);
+                qla2x00_write_flash_byte(ha, 0x555, 0x55);
+                qla2x00_write_flash_byte(ha, 0xaaa, 0x80);
+                qla2x00_write_flash_byte(ha, 0xaaa, 0xaa);
+                qla2x00_write_flash_byte(ha, 0x555, 0x55);
+                qla2x00_write_flash_byte(ha, 0xaaa, 0x10);
+        } else {
+                qla2x00_write_flash_byte(ha, 0x5555, 0xaa);
+                qla2x00_write_flash_byte(ha, 0x2aaa, 0x55);
+                qla2x00_write_flash_byte(ha, 0x5555, 0x80);
+                qla2x00_write_flash_byte(ha, 0x5555, 0xaa);
+                qla2x00_write_flash_byte(ha, 0x2aaa, 0x55);
+                qla2x00_write_flash_byte(ha, 0x5555, 0x10);
+        }
+        udelay(150);
+        /* Wait for erase to complete. */
+        return qla2x00_poll_flash(ha, 0x00, 0x80, man_id, flash_id);
+}
+/**
+ * qla2x00_erase_flash_sector() - Erase a flash sector.
+ * @ha: HA context
+ * @addr: Flash sector to erase
+ * @sec_mask: Sector address mask
+ * @man_id: Flash manufacturer ID
+ * @flash_id: Flash ID
+ *
+ * Returns 0 on success, else non-zero.
+ */
+static int
+qla2x00_erase_flash_sector(scsi_qla_host_t *ha, uint32_t addr,
+    uint32_t sec_mask, uint8_t man_id, uint8_t flash_id)
+{
+        /* Individual Sector Erase Command Sequence */
+        qla2x00_write_flash_byte(ha, 0x5555, 0xaa);
+        qla2x00_write_flash_byte(ha, 0x2aaa, 0x55);
+        qla2x00_write_flash_byte(ha, 0x5555, 0x80);
+        qla2x00_write_flash_byte(ha, 0x5555, 0xaa);
+        qla2x00_write_flash_byte(ha, 0x2aaa, 0x55);
+        if (man_id == 0x1f && flash_id == 0x13)
+                qla2x00_write_flash_byte(ha, addr & sec_mask, 0x10);
+        else
+                qla2x00_write_flash_byte(ha, addr & sec_mask, 0x30);
+        udelay(150);
+        /* Wait for erase to complete. */
+        return qla2x00_poll_flash(ha, addr, 0x80, man_id, flash_id);
+}
+/**
+ * qla2x00_get_flash_manufacturer() - Read manufacturer ID from flash chip.
+ * @man_id: Flash manufacturer ID
+ * @flash_id: Flash ID
+ */
+static void
+qla2x00_get_flash_manufacturer(scsi_qla_host_t *ha, uint8_t *man_id,
+    uint8_t *flash_id)
+{
+        qla2x00_write_flash_byte(ha, 0x5555, 0xaa);
+        qla2x00_write_flash_byte(ha, 0x2aaa, 0x55);
+        qla2x00_write_flash_byte(ha, 0x5555, 0x90);
+        *man_id = qla2x00_read_flash_byte(ha, 0x0000);
+        *flash_id = qla2x00_read_flash_byte(ha, 0x0001);
+        qla2x00_write_flash_byte(ha, 0x5555, 0xaa);
+        qla2x00_write_flash_byte(ha, 0x2aaa, 0x55);
+        qla2x00_write_flash_byte(ha, 0x5555, 0xf0);
+}
+static inline void
+qla2x00_suspend_hba(struct scsi_qla_host *ha)
+{
+        int cnt;
+        unsigned long flags;
+        struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
+        /* Suspend HBA. */
+        scsi_block_requests(ha->host);
+        ha->isp_ops.disable_intrs(ha);
+        set_bit(MBX_UPDATE_FLASH_ACTIVE, &ha->mbx_cmd_flags);
+        /* Pause RISC. */
+        spin_lock_irqsave(&ha->hardware_lock, flags);
+        WRT_REG_WORD(&reg->hccr, HCCR_PAUSE_RISC);
+        RD_REG_WORD(&reg->hccr);
+        if (IS_QLA2100(ha) || IS_QLA2200(ha) || IS_QLA2300(ha)) {
+                for (cnt = 0; cnt < 30000; cnt++) {
+                        if ((RD_REG_WORD(&reg->hccr) & HCCR_RISC_PAUSE) != 0)
+                                break;
+                        udelay(100);
+                }
+        } else {
+                udelay(10);
+        }
+        spin_unlock_irqrestore(&ha->hardware_lock, flags);
+}
+static inline void
+qla2x00_resume_hba(struct scsi_qla_host *ha)
+{
+        /* Resume HBA. */
+        clear_bit(MBX_UPDATE_FLASH_ACTIVE, &ha->mbx_cmd_flags);
+        set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
+        up(ha->dpc_wait);
+        qla2x00_wait_for_hba_online(ha);
+        scsi_unblock_requests(ha->host);
+}
+uint8_t *
+qla2x00_read_optrom_data(struct scsi_qla_host *ha, uint8_t *buf,
+    uint32_t offset, uint32_t length)
+{
+        unsigned long flags;
+        uint32_t addr, midpoint;
+        uint8_t *data;
+        struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
+        /* Suspend HBA. */
+        qla2x00_suspend_hba(ha);
+        /* Go with read. */
+        spin_lock_irqsave(&ha->hardware_lock, flags);
+        midpoint = ha->optrom_size / 2;
+        qla2x00_flash_enable(ha);
+        WRT_REG_WORD(&reg->nvram, 0);
+        RD_REG_WORD(&reg->nvram);               /* PCI Posting. */
+        for (addr = offset, data = buf; addr < length; addr++, data++) {
+                if (addr == midpoint) {
+                        WRT_REG_WORD(&reg->nvram, NVR_SELECT);
+                        RD_REG_WORD(&reg->nvram);       /* PCI Posting. */
+                }
+                *data = qla2x00_read_flash_byte(ha, addr);
+        }
+        qla2x00_flash_disable(ha);
+        spin_unlock_irqrestore(&ha->hardware_lock, flags);
+        /* Resume HBA. */
+        qla2x00_resume_hba(ha);
+        return buf;
+}
+int
+qla2x00_write_optrom_data(struct scsi_qla_host *ha, uint8_t *buf,
+    uint32_t offset, uint32_t length)
+{
+        int rval;
+        unsigned long flags;
+        uint8_t man_id, flash_id, sec_number, data;
+        uint16_t wd;
+        uint32_t addr, liter, sec_mask, rest_addr;
+        struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
+        /* Suspend HBA. */
+        qla2x00_suspend_hba(ha);
+        rval = QLA_SUCCESS;
+        sec_number = 0;
+        /* Reset ISP chip. */
+        spin_lock_irqsave(&ha->hardware_lock, flags);
+        WRT_REG_WORD(&reg->ctrl_status, CSR_ISP_SOFT_RESET);
+        pci_read_config_word(ha->pdev, PCI_COMMAND, &wd);
+        /* Go with write. */
+        qla2x00_flash_enable(ha);
+        do {    /* Loop once to provide quick error exit */
+                /* Structure of flash memory based on manufacturer */
+                if (IS_OEM_001(ha)) {
+                        /* OEM variant with special flash part. */
+                        man_id = flash_id = 0;
+                        rest_addr = 0xffff;
+                        sec_mask   = 0x10000;
+                        goto update_flash;
+                }
+                qla2x00_get_flash_manufacturer(ha, &man_id, &flash_id);
+                switch (man_id) {
+                case 0x20: /* ST flash. */
+                        if (flash_id == 0xd2 || flash_id == 0xe3) {
+                                /*
+                                 * ST m29w008at part - 64kb sector size with
+                                 * 32kb,8kb,8kb,16kb sectors at memory address
+                                 * 0xf0000.
+                                 */
+                                rest_addr = 0xffff;
+                                sec_mask = 0x10000;
+                                break;   
+                        }
+                        /*
+                         * ST m29w010b part - 16kb sector size
+                         * Default to 16kb sectors
+                         */
+                        rest_addr = 0x3fff;
+                        sec_mask = 0x1c000;
+                        break;
+                case 0x40: /* Mostel flash. */
+                        /* Mostel v29c51001 part - 512 byte sector size. */
+                        rest_addr = 0x1ff;
+                        sec_mask = 0x1fe00;
+                        break;
+                case 0xbf: /* SST flash. */
+                        /* SST39sf10 part - 4kb sector size. */
+                        rest_addr = 0xfff;
+                        sec_mask = 0x1f000;
+                        break;
+                case 0xda: /* Winbond flash. */
+                        /* Winbond W29EE011 part - 256 byte sector size. */
+                        rest_addr = 0x7f;
+                        sec_mask = 0x1ff80;
+                        break;
+                case 0xc2: /* Macronix flash. */
+                        /* 64k sector size. */
+                        if (flash_id == 0x38 || flash_id == 0x4f) {
+                                rest_addr = 0xffff;
+                                sec_mask = 0x10000;
+                                break;
+                        }
+                        /* Fall through... */
+                case 0x1f: /* Atmel flash. */
+                        /* 512k sector size. */
+                        if (flash_id == 0x13) {
+                                rest_addr = 0x7fffffff;
+                                sec_mask =   0x80000000;
+                                break;
+                        }
+                        /* Fall through... */
+                case 0x01: /* AMD flash. */
+                        if (flash_id == 0x38 || flash_id == 0x40 ||
+                            flash_id == 0x4f) {
+                                /* Am29LV081 part - 64kb sector size. */
+                                /* Am29LV002BT part - 64kb sector size. */
+                                rest_addr = 0xffff;
+                                sec_mask = 0x10000;
+                                break;
+                        } else if (flash_id == 0x3e) {
+                                /*
+                                 * Am29LV008b part - 64kb sector size with
+                                 * 32kb,8kb,8kb,16kb sector at memory address
+                                 * h0xf0000.
+                                 */
+                                rest_addr = 0xffff;
+                                sec_mask = 0x10000;
+                                break;
+                        } else if (flash_id == 0x20 || flash_id == 0x6e) {
+                                /*
+                                 * Am29LV010 part or AM29f010 - 16kb sector
+                                 * size.
+                                 */
+                                rest_addr = 0x3fff;
+                                sec_mask = 0x1c000;
+                                break;
+                        } else if (flash_id == 0x6d) {
+                                /* Am29LV001 part - 8kb sector size. */
+                                rest_addr = 0x1fff;
+                                sec_mask = 0x1e000;
+                                break;
+                        }
+                default:
+                        /* Default to 16 kb sector size. */
+                        rest_addr = 0x3fff;
+                        sec_mask = 0x1c000;
+                        break;
+                }
+update_flash:
+                if (IS_QLA2322(ha) || IS_QLA6322(ha)) {
+                        if (qla2x00_erase_flash(ha, man_id, flash_id)) {
+                                rval = QLA_FUNCTION_FAILED;
+                                break;
+                        }
+                }
+                for (addr = offset, liter = 0; liter < length; liter++,
+                    addr++) {
+                        data = buf[liter];
+                        /* Are we at the beginning of a sector? */
+                        if ((addr & rest_addr) == 0) {
+                                if (IS_QLA2322(ha) || IS_QLA6322(ha)) {
+                                        if (addr >= 0x10000UL) {
+                                                if (((addr >> 12) & 0xf0) &&
+                                                    ((man_id == 0x01 &&
+                                                        flash_id == 0x3e) ||
+                                                     (man_id == 0x20 &&
+                                                         flash_id == 0xd2))) {
+                                                        sec_number++;
+                                                        if (sec_number == 1) {
+                                                                rest_addr =
+                                                                    0x7fff;
+                                                                sec_mask =
+                                                                    0x18000;
+                                                        } else if (
+                                                            sec_number == 2 ||
+                                                            sec_number == 3) {
+                                                                rest_addr =
+                                                                    0x1fff;
+                                                                sec_mask =
+                                                                    0x1e000;
+                                                        } else if (
+                                                            sec_number == 4) {
+                                                                rest_addr =
+                                                                    0x3fff;
+                                                                sec_mask =
+                                                                    0x1c000;
+                                                        }
+                                                }
+                                        }
+                                } else if (addr == ha->optrom_size / 2) {
+                                        WRT_REG_WORD(&reg->nvram, NVR_SELECT);
+                                        RD_REG_WORD(&reg->nvram);
+                                }
+                                if (flash_id == 0xda && man_id == 0xc1) {
+                                        qla2x00_write_flash_byte(ha, 0x5555,
+                                            0xaa);
+                                        qla2x00_write_flash_byte(ha, 0x2aaa,
+                                            0x55);
+                                        qla2x00_write_flash_byte(ha, 0x5555,
+                                            0xa0);
+                                } else if (!IS_QLA2322(ha) && !IS_QLA6322(ha)) {
+                                        /* Then erase it */
+                                        if (qla2x00_erase_flash_sector(ha,
+                                            addr, sec_mask, man_id,
+                                            flash_id)) {
+                                                rval = QLA_FUNCTION_FAILED;
+                                                break;
+                                        }
+                                        if (man_id == 0x01 && flash_id == 0x6d)
+                                                sec_number++;
+                                }
+                        }
+                        if (man_id == 0x01 && flash_id == 0x6d) {
+                                if (sec_number == 1 &&
+                                    addr == (rest_addr - 1)) {
+                                        rest_addr = 0x0fff;
+                                        sec_mask   = 0x1f000;
+                                } else if (sec_number == 3 && (addr & 0x7ffe)) {
+                                        rest_addr = 0x3fff;
+                                        sec_mask   = 0x1c000;
+                                }
+                        }
+                        if (qla2x00_program_flash_address(ha, addr, data,
+                            man_id, flash_id)) {
+                                rval = QLA_FUNCTION_FAILED;
+                                break;
+                        }
+                }
+        } while (0);
+        qla2x00_flash_disable(ha);
+        spin_unlock_irqrestore(&ha->hardware_lock, flags);
+        /* Resume HBA. */
+        qla2x00_resume_hba(ha);
+        return rval;
+}
+uint8_t *
+qla24xx_read_optrom_data(struct scsi_qla_host *ha, uint8_t *buf,
+    uint32_t offset, uint32_t length)
+{
+        /* Suspend HBA. */
+        scsi_block_requests(ha->host);
+        ha->isp_ops.disable_intrs(ha);
+        set_bit(MBX_UPDATE_FLASH_ACTIVE, &ha->mbx_cmd_flags);
+        /* Go with read. */
+        qla24xx_read_flash_data(ha, (uint32_t *)buf, offset >> 2, length >> 2);
+        /* Resume HBA. */
+        clear_bit(MBX_UPDATE_FLASH_ACTIVE, &ha->mbx_cmd_flags);
+        ha->isp_ops.enable_intrs(ha);
+        scsi_unblock_requests(ha->host);
+        return buf;
+}
+int
+qla24xx_write_optrom_data(struct scsi_qla_host *ha, uint8_t *buf,
+    uint32_t offset, uint32_t length)
+{
+        int rval;
+        /* Suspend HBA. */
+        scsi_block_requests(ha->host);
+        ha->isp_ops.disable_intrs(ha);
+        set_bit(MBX_UPDATE_FLASH_ACTIVE, &ha->mbx_cmd_flags);
+        /* Go with write. */
+        rval = qla24xx_write_flash_data(ha, (uint32_t *)buf, offset >> 2,
+            length >> 2);
+        /* Resume HBA -- RISC reset needed. */
+        clear_bit(MBX_UPDATE_FLASH_ACTIVE, &ha->mbx_cmd_flags);
+        set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
+        up(ha->dpc_wait);
+        qla2x00_wait_for_hba_online(ha);
+        scsi_unblock_requests(ha->host);
+        return rval;
+}
diff --git a/drivers/scsi/sata_mv.c b/drivers/scsi/sata_mv.c
index cd54244058b5..2770005324b4 100644
--- a/drivers/scsi/sata_mv.c
+++ b/drivers/scsi/sata_mv.c
@@ -510,6 +510,12 @@ static const struct mv_hw_ops mv6xxx_ops = {
 };
 /*
+ * module options
+ */
+static int msi;       /* Use PCI msi; either zero (off, default) or non-zero */
+/*
 * Functions
 */
@@ -991,6 +997,7 @@ static void mv_qc_prep(struct ata_queued_cmd *qc)
        case ATA_CMD_READ_EXT:
        case ATA_CMD_WRITE:
        case ATA_CMD_WRITE_EXT:
+        case ATA_CMD_WRITE_FUA_EXT:
                mv_crqb_pack_cmd(cw++, tf->hob_nsect, ATA_REG_NSECT, 0);
                break;
 #ifdef LIBATA_NCQ               /* FIXME: remove this line when NCQ added */
@@ -2191,7 +2198,7 @@ static int mv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
        }
        /* Enable interrupts */
-        if (pci_enable_msi(pdev) == 0) {
+        if (msi && pci_enable_msi(pdev) == 0) {
                hpriv->hp_flags |= MV_HP_FLAG_MSI;
        } else {
                pci_intx(pdev, 1);
@@ -2246,5 +2253,8 @@ MODULE_LICENSE("GPL");
 MODULE_DEVICE_TABLE(pci, mv_pci_tbl);
 MODULE_VERSION(DRV_VERSION);
+module_param(msi, int, 0444);
+MODULE_PARM_DESC(msi, "Enable use of PCI MSI (0=off, 1=on)");
 module_init(mv_init);
 module_exit(mv_exit);
diff --git a/drivers/scsi/sata_qstor.c b/drivers/scsi/sata_qstor.c
index de05e2883f9c..80480f0fb2b8 100644
--- a/drivers/scsi/sata_qstor.c
+++ b/drivers/scsi/sata_qstor.c
@@ -277,7 +277,7 @@ static unsigned int qs_fill_sg(struct ata_queued_cmd *qc)
        u8 *prd = pp->pkt + QS_CPB_BYTES;
        assert(qc->__sg != NULL);
-        assert(qc->n_elem > 0);
+        assert(qc->n_elem > 0 || qc->pad_len > 0);
        nelem = 0;
        ata_for_each_sg(sg, qc) {
diff --git a/drivers/scsi/sata_sil.c b/drivers/scsi/sata_sil.c
index b017f85e6d6a..9face3c6aa21 100644
--- a/drivers/scsi/sata_sil.c
+++ b/drivers/scsi/sata_sil.c
@@ -49,11 +49,13 @@
 #define DRV_VERSION     "0.9"
 enum {
+        SIL_FLAG_RERR_ON_DMA_ACT = (1 << 29),
        SIL_FLAG_MOD15WRITE     = (1 << 30),
        sil_3112                = 0,
        sil_3112_m15w           = 1,
-        sil_3114                = 2,
+        sil_3512                = 2,
+        sil_3114                = 3,
        SIL_FIFO_R0             = 0x40,
        SIL_FIFO_W0             = 0x41,
@@ -90,7 +92,7 @@ static void sil_post_set_mode (struct ata_port *ap);
 static const struct pci_device_id sil_pci_tbl[] = {
        { 0x1095, 0x3112, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112_m15w },
        { 0x1095, 0x0240, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112_m15w },
-        { 0x1095, 0x3512, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112 },
+        { 0x1095, 0x3512, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3512 },
        { 0x1095, 0x3114, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3114 },
        { 0x1002, 0x436e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112_m15w },
        { 0x1002, 0x4379, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112_m15w },
@@ -185,7 +187,8 @@ static const struct ata_port_info sil_port_info[] = {
                .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                .udma_mask      = 0x3f,                 /* udma0-5 */
                .port_ops       = &sil_ops,
-        }, /* sil_3112_15w - keep it sync'd w/ sil_3112 */
+        },
+        /* sil_3112_15w - keep it sync'd w/ sil_3112 */
        {
                .sht            = &sil_sht,
                .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
@@ -195,11 +198,24 @@ static const struct ata_port_info sil_port_info[] = {
                .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                .udma_mask      = 0x3f,                 /* udma0-5 */
                .port_ops       = &sil_ops,
-        }, /* sil_3114 */
+        },
+        /* sil_3512 */
        {
                .sht            = &sil_sht,
                .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_SRST | ATA_FLAG_MMIO,
+                                  ATA_FLAG_SRST | ATA_FLAG_MMIO |
+                                  SIL_FLAG_RERR_ON_DMA_ACT,
+                .pio_mask       = 0x1f,                 /* pio0-4 */
+                .mwdma_mask     = 0x07,                 /* mwdma0-2 */
+                .udma_mask      = 0x3f,                 /* udma0-5 */
+                .port_ops       = &sil_ops,
+        },
+        /* sil_3114 */
+        {
+                .sht            = &sil_sht,
+                .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
+                                  ATA_FLAG_SRST | ATA_FLAG_MMIO |
+                                  SIL_FLAG_RERR_ON_DMA_ACT,
                .pio_mask       = 0x1f,                 /* pio0-4 */
                .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                .udma_mask      = 0x3f,                 /* udma0-5 */
@@ -216,12 +232,13 @@ static const struct {
        unsigned long scr;      /* SATA control register block */
        unsigned long sien;     /* SATA Interrupt Enable register */
        unsigned long xfer_mode;/* data transfer mode register */
+        unsigned long sfis_cfg; /* SATA FIS reception config register */
 } sil_port[] = {
        /* port 0 ... */
-        { 0x80, 0x8A, 0x00, 0x100, 0x148, 0xb4 },
+        { 0x80, 0x8A, 0x00, 0x100, 0x148, 0xb4, 0x14c },
-        { 0xC0, 0xCA, 0x08, 0x180, 0x1c8, 0xf4 },
+        { 0xC0, 0xCA, 0x08, 0x180, 0x1c8, 0xf4, 0x1cc },
-        { 0x280, 0x28A, 0x200, 0x300, 0x348, 0x2b4 },
+        { 0x280, 0x28A, 0x200, 0x300, 0x348, 0x2b4, 0x34c },
-        { 0x2C0, 0x2CA, 0x208, 0x380, 0x3c8, 0x2f4 },
+        { 0x2C0, 0x2CA, 0x208, 0x380, 0x3c8, 0x2f4, 0x3cc },
        /* ... port 3 */
 };
@@ -231,6 +248,10 @@ MODULE_LICENSE("GPL");
 MODULE_DEVICE_TABLE(pci, sil_pci_tbl);
 MODULE_VERSION(DRV_VERSION);
+static int slow_down = 0;
+module_param(slow_down, int, 0444);
+MODULE_PARM_DESC(slow_down, "Sledgehammer used to work around random problems, by limiting commands to 15 sectors (0=off, 1=on)");
 static unsigned char sil_get_device_cache_line(struct pci_dev *pdev)
 {
@@ -354,8 +375,10 @@ static void sil_dev_config(struct ata_port *ap, struct ata_device *dev)
                }
        /* limit requests to 15 sectors */
-        if ((ap->flags & SIL_FLAG_MOD15WRITE) && (quirks & SIL_QUIRK_MOD15WRITE)) {
+        if (slow_down ||
-                printk(KERN_INFO "ata%u(%u): applying Seagate errata fix\n",
+            ((ap->flags & SIL_FLAG_MOD15WRITE) &&
+             (quirks & SIL_QUIRK_MOD15WRITE))) {
+                printk(KERN_INFO "ata%u(%u): applying Seagate errata fix (mod15write workaround)\n",
                       ap->id, dev->devno);
                ap->host->max_sectors = 15;
                ap->host->hostt->max_sectors = 15;
@@ -465,6 +488,23 @@ static int sil_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                dev_printk(KERN_WARNING, &pdev->dev,
                         "cache line size not set.  Driver may not function\n");
+        /* Apply R_ERR on DMA activate FIS errata workaround */
+        if (probe_ent->host_flags & SIL_FLAG_RERR_ON_DMA_ACT) {
+                int cnt;
+                for (i = 0, cnt = 0; i < probe_ent->n_ports; i++) {
+                        tmp = readl(mmio_base + sil_port[i].sfis_cfg);
+                        if ((tmp & 0x3) != 0x01)
+                                continue;
+                        if (!cnt)
+                                dev_printk(KERN_INFO, &pdev->dev,
+                                           "Applying R_ERR on DMA activate "
+                                           "FIS errata fix\n");
+                        writel(tmp & ~0x3, mmio_base + sil_port[i].sfis_cfg);
+                        cnt++;
+                }
+        }
        if (ent->driver_data == sil_3114) {
                irq_mask = SIL_MASK_4PORT;
diff --git a/drivers/scsi/sata_vsc.c b/drivers/scsi/sata_vsc.c
index 2e2c3b7acb0c..e484e8db6810 100644
--- a/drivers/scsi/sata_vsc.c
+++ b/drivers/scsi/sata_vsc.c
@@ -81,6 +81,19 @@
 /* Port stride */
 #define VSC_SATA_PORT_OFFSET            0x200
+/* Error interrupt status bit offsets */
+#define VSC_SATA_INT_ERROR_E_OFFSET     2
+#define VSC_SATA_INT_ERROR_P_OFFSET     4
+#define VSC_SATA_INT_ERROR_T_OFFSET     5
+#define VSC_SATA_INT_ERROR_M_OFFSET     1
+#define is_vsc_sata_int_err(port_idx, int_status) \
+         (int_status & ((1 << (VSC_SATA_INT_ERROR_E_OFFSET + (8 * port_idx))) | \
+                        (1 << (VSC_SATA_INT_ERROR_P_OFFSET + (8 * port_idx))) | \
+                        (1 << (VSC_SATA_INT_ERROR_T_OFFSET + (8 * port_idx))) | \
+                        (1 << (VSC_SATA_INT_ERROR_M_OFFSET + (8 * port_idx)))   \
+                       )\
+         )
 static u32 vsc_sata_scr_read (struct ata_port *ap, unsigned int sc_reg)
 {
@@ -201,13 +214,28 @@ static irqreturn_t vsc_sata_interrupt (int irq, void *dev_instance,
                        struct ata_port *ap;
                        ap = host_set->ports[i];
+                        if (is_vsc_sata_int_err(i, int_status)) {
+                                u32 err_status;
+                                printk(KERN_DEBUG "%s: ignoring interrupt(s)\n", __FUNCTION__);
+                                err_status = ap ? vsc_sata_scr_read(ap, SCR_ERROR) : 0;
+                                vsc_sata_scr_write(ap, SCR_ERROR, err_status);
+                                handled++;
+                        }
                        if (ap && !(ap->flags &
                                    (ATA_FLAG_PORT_DISABLED|ATA_FLAG_NOINTR))) {
                                struct ata_queued_cmd *qc;
                                qc = ata_qc_from_tag(ap, ap->active_tag);
-                                if (qc && (!(qc->tf.ctl & ATA_NIEN)))
+                                if (qc && (!(qc->tf.ctl & ATA_NIEN))) {
                                        handled += ata_host_intr(ap, qc);
+                                } else {
+                                        printk(KERN_DEBUG "%s: ignoring interrupt(s)\n", __FUNCTION__);
+                                        ata_chk_status(ap);
+                                        handled++;
+                                }
                        }
                }
        }
diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
index 245ca99a641e..c551bb84dbfb 100644
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
@@ -1245,7 +1245,7 @@ static int __init init_scsi(void)
        if (error)
                goto cleanup_sysctl;
-        for (i = 0; i < NR_CPUS; i++)
+        for_each_cpu(i)
                INIT_LIST_HEAD(&per_cpu(scsi_done_q, i));
        devfs_mk_dir("scsi");
diff --git a/drivers/scsi/scsi_devinfo.c b/drivers/scsi/scsi_devinfo.c
index f01ec0a7c506..84c3937ae8fb 100644
--- a/drivers/scsi/scsi_devinfo.c
+++ b/drivers/scsi/scsi_devinfo.c
@@ -126,6 +126,7 @@ static struct {
        {"ADAPTEC", "Adaptec 5400S", NULL, BLIST_FORCELUN},
        {"AFT PRO", "-IX CF", "0.0>", BLIST_FORCELUN},
        {"BELKIN", "USB 2 HS-CF", "1.95",  BLIST_FORCELUN | BLIST_INQUIRY_36},
+        {"BROWNIE", "1600U3P", NULL, BLIST_NOREPORTLUN},
        {"CANON", "IPUBJD", NULL, BLIST_SPARSELUN},
        {"CBOX3", "USB Storage-SMC", "300A", BLIST_FORCELUN | BLIST_INQUIRY_36},
        {"CMD", "CRA-7280", NULL, BLIST_SPARSELUN},     /* CMD RAID Controller */
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index a2333d2c7af0..ff82ccfbb106 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -1308,7 +1308,7 @@ int scsi_decide_disposition(struct scsi_cmnd *scmd)
         * the request was not marked fast fail.  Note that above,
         * even if the request is marked fast fail, we still requeue
         * for queue congestion conditions (QUEUE_FULL or BUSY) */
-        if ((++scmd->retries) < scmd->allowed 
+        if ((++scmd->retries) <= scmd->allowed
            && !blk_noretry_request(scmd->request)) {
                return NEEDS_RETRY;
        } else {
@@ -1350,7 +1350,7 @@ static void scsi_eh_lock_door(struct scsi_device *sdev)
        cmnd[4] = SCSI_REMOVAL_PREVENT;
        cmnd[5] = 0;
-        scsi_execute_async(sdev, cmnd, DMA_NONE, NULL, 0, 0, 10 * HZ,
+        scsi_execute_async(sdev, cmnd, 6, DMA_NONE, NULL, 0, 0, 10 * HZ,
                           5, NULL, NULL, GFP_KERNEL);
 }
@@ -1433,7 +1433,7 @@ static void scsi_eh_flush_done_q(struct list_head *done_q)
                list_del_init(&scmd->eh_entry);
                if (scsi_device_online(scmd->device) &&
                    !blk_noretry_request(scmd->request) &&
-                    (++scmd->retries < scmd->allowed)) {
+                    (++scmd->retries <= scmd->allowed)) {
                        SCSI_LOG_ERROR_RECOVERY(3, printk("%s: flush"
                                                          " retry cmd: %p\n",
                                                          current->comm,
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 3574ba935af8..701a328f7beb 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -16,6 +16,7 @@
 #include <linux/init.h>
 #include <linux/pci.h>
 #include <linux/delay.h>
+#include <linux/hardirq.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_dbg.h>
@@ -436,6 +437,7 @@ free_bios:
 * scsi_execute_async - insert request
 * @sdev:       scsi device
 * @cmd:        scsi command
+ * @cmd_len:    length of scsi cdb
 * @data_direction: data direction
 * @buffer:     data buffer (this can be a kernel buffer or scatterlist)
 * @bufflen:    len of buffer
@@ -445,7 +447,7 @@ free_bios:
 * @flags:      or into request flags
 **/
 int scsi_execute_async(struct scsi_device *sdev, const unsigned char *cmd,
-                       int data_direction, void *buffer, unsigned bufflen,
+                       int cmd_len, int data_direction, void *buffer, unsigned bufflen,
                       int use_sg, int timeout, int retries, void *privdata,
                       void (*done)(void *, char *, int, int), gfp_t gfp)
 {
@@ -472,7 +474,7 @@ int scsi_execute_async(struct scsi_device *sdev, const unsigned char *cmd,
        if (err)
                goto free_req;
-        req->cmd_len = COMMAND_SIZE(cmd[0]);
+        req->cmd_len = cmd_len;
        memcpy(req->cmd, cmd, req->cmd_len);
        req->sense = sioc->sense;
        req->sense_len = 0;
@@ -1496,7 +1498,7 @@ static void scsi_kill_request(struct request *req, request_queue_t *q)
 static void scsi_softirq_done(struct request *rq)
 {
        struct scsi_cmnd *cmd = rq->completion_data;
-        unsigned long wait_for = cmd->allowed * cmd->timeout_per_command;
+        unsigned long wait_for = (cmd->allowed + 1) * cmd->timeout_per_command;
        int disposition;
        INIT_LIST_HEAD(&cmd->eh_entry);
@@ -2247,3 +2249,61 @@ scsi_target_unblock(struct device *dev)
                device_for_each_child(dev, NULL, target_unblock);
 }
 EXPORT_SYMBOL_GPL(scsi_target_unblock);
+struct work_queue_work {
+        struct work_struct      work;
+        void                    (*fn)(void *);
+        void                    *data;
+};
+static void execute_in_process_context_work(void *data)
+{
+        void (*fn)(void *data);
+        struct work_queue_work *wqw = data;
+        fn = wqw->fn;
+        data = wqw->data;
+        kfree(wqw);
+        fn(data);
+}
+/**
+ * scsi_execute_in_process_context - reliably execute the routine with user context
+ * @fn:         the function to execute
+ * @data:       data to pass to the function
+ *
+ * Executes the function immediately if process context is available,
+ * otherwise schedules the function for delayed execution.
+ *
+ * Returns:     0 - function was executed
+ *              1 - function was scheduled for execution
+ *              <0 - error
+ */
+int scsi_execute_in_process_context(void (*fn)(void *data), void *data)
+{
+        struct work_queue_work *wqw;
+        if (!in_interrupt()) {
+                fn(data);
+                return 0;
+        }
+        wqw = kmalloc(sizeof(struct work_queue_work), GFP_ATOMIC);
+        if (unlikely(!wqw)) {
+                printk(KERN_ERR "Failed to allocate memory\n");
+                WARN_ON(1);
+                return -ENOMEM;
+        }
+        INIT_WORK(&wqw->work, execute_in_process_context_work, wqw);
+        wqw->fn = fn;
+        wqw->data = data;
+        schedule_work(&wqw->work);
+        return 1;
+}
+EXPORT_SYMBOL_GPL(scsi_execute_in_process_context);
diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index 752fb5da3de4..f9ecc3dea7df 100644
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -387,19 +387,12 @@ static struct scsi_target *scsi_alloc_target(struct device *parent,
        return found_target;
 }
-struct work_queue_wrapper {
+static void scsi_target_reap_usercontext(void *data)
-        struct work_struct      work;
+{
-        struct scsi_target      *starget;
+        struct scsi_target *starget = data;
-};
-static void scsi_target_reap_work(void *data) {
-        struct work_queue_wrapper *wqw = (struct work_queue_wrapper *)data;
-        struct scsi_target *starget = wqw->starget;
        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
        unsigned long flags;
-        kfree(wqw);
        spin_lock_irqsave(shost->host_lock, flags);
        if (--starget->reap_ref == 0 && list_empty(&starget->devices)) {
@@ -428,18 +421,7 @@ static void scsi_target_reap_work(void *data) {
 */
 void scsi_target_reap(struct scsi_target *starget)
 {
-        struct work_queue_wrapper *wqw = 
+        scsi_execute_in_process_context(scsi_target_reap_usercontext, starget);
-                kzalloc(sizeof(struct work_queue_wrapper), GFP_ATOMIC);
-        if (!wqw) {
-                starget_printk(KERN_ERR, starget,
-                               "Failed to allocate memory in scsi_reap_target()\n");
-                return;
-        }
-        INIT_WORK(&wqw->work, scsi_target_reap_work, wqw);
-        wqw->starget = starget;
-        schedule_work(&wqw->work);
 }
 /**
@@ -770,8 +752,20 @@ static int scsi_add_lun(struct scsi_device *sdev, char *inq_result, int *bflags)
        transport_configure_device(&sdev->sdev_gendev);
-        if (sdev->host->hostt->slave_configure)
+        if (sdev->host->hostt->slave_configure) {
-                sdev->host->hostt->slave_configure(sdev);
+                int ret = sdev->host->hostt->slave_configure(sdev);
+                if (ret) {
+                        /*
+                         * if LLDD reports slave not present, don't clutter
+                         * console with alloc failure messages
+                         */
+                        if (ret != -ENXIO) {
+                                sdev_printk(KERN_ERR, sdev,
+                                        "failed to configure device\n");
+                        }
+                        return SCSI_SCAN_NO_RESPONSE;
+                }
+        }
        /*
         * Ok, the device is now all set up, we can
diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c
index a77b32deaf8f..902a5def8e62 100644
--- a/drivers/scsi/scsi_sysfs.c
+++ b/drivers/scsi/scsi_sysfs.c
@@ -217,8 +217,9 @@ static void scsi_device_cls_release(struct class_device *class_dev)
        put_device(&sdev->sdev_gendev);
 }
-static void scsi_device_dev_release(struct device *dev)
+static void scsi_device_dev_release_usercontext(void *data)
 {
+        struct device *dev = data;
        struct scsi_device *sdev;
        struct device *parent;
        struct scsi_target *starget;
@@ -237,6 +238,7 @@ static void scsi_device_dev_release(struct device *dev)
        if (sdev->request_queue) {
                sdev->request_queue->queuedata = NULL;
+                /* user context needed to free queue */
                scsi_free_queue(sdev->request_queue);
                /* temporary expedient, try to catch use of queue lock
                 * after free of sdev */
@@ -252,6 +254,11 @@ static void scsi_device_dev_release(struct device *dev)
                put_device(parent);
 }
+static void scsi_device_dev_release(struct device *dev)
+{
+        scsi_execute_in_process_context(scsi_device_dev_release_usercontext,    dev);
+}
 static struct class sdev_class = {
        .name           = "scsi_device",
        .release        = scsi_device_cls_release,
diff --git a/drivers/scsi/scsi_transport_fc.c b/drivers/scsi/scsi_transport_fc.c
index f2c9acf11bd0..13ea64119b73 100644
--- a/drivers/scsi/scsi_transport_fc.c
+++ b/drivers/scsi/scsi_transport_fc.c
@@ -223,7 +223,7 @@ static void fc_rport_terminate(struct fc_rport  *rport);
 */
 #define FC_STARGET_NUM_ATTRS    3
 #define FC_RPORT_NUM_ATTRS      9
-#define FC_HOST_NUM_ATTRS       16
+#define FC_HOST_NUM_ATTRS       17
 struct fc_internal {
        struct scsi_transport_template t;
@@ -1498,8 +1498,7 @@ fc_remote_port_add(struct Scsi_Host *shost, int channel,
        }
        /* Search the bindings array */
-        if (likely((ids->roles & FC_RPORT_ROLE_FCP_TARGET) &&
+        if (fc_host_tgtid_bind_type(shost) != FC_TGTID_BIND_NONE) {
-                (fc_host_tgtid_bind_type(shost) != FC_TGTID_BIND_NONE))) {
                /* search for a matching consistent binding */
diff --git a/drivers/scsi/scsi_transport_iscsi.c b/drivers/scsi/scsi_transport_iscsi.c
index 59a1c9d9d3bd..71e54a64adca 100644
--- a/drivers/scsi/scsi_transport_iscsi.c
+++ b/drivers/scsi/scsi_transport_iscsi.c
@@ -39,10 +39,6 @@ struct iscsi_internal {
        struct iscsi_transport *iscsi_transport;
        struct list_head list;
        /*
-         * List of sessions for this transport
-         */
-        struct list_head sessions;
-        /*
         * based on transport capabilities, at register time we set these
         * bits to tell the transport class it wants attributes displayed
         * in sysfs or that it can support different iSCSI Data-Path
@@ -164,9 +160,43 @@ static struct mempool_zone *z_reply;
 #define Z_MAX_ERROR     16
 #define Z_HIWAT_ERROR   12
+static LIST_HEAD(sesslist);
+static DEFINE_SPINLOCK(sesslock);
 static LIST_HEAD(connlist);
 static DEFINE_SPINLOCK(connlock);
+static struct iscsi_cls_session *iscsi_session_lookup(uint64_t handle)
+{
+        unsigned long flags;
+        struct iscsi_cls_session *sess;
+        spin_lock_irqsave(&sesslock, flags);
+        list_for_each_entry(sess, &sesslist, sess_list) {
+                if (sess == iscsi_ptr(handle)) {
+                        spin_unlock_irqrestore(&sesslock, flags);
+                        return sess;
+                }
+        }
+        spin_unlock_irqrestore(&sesslock, flags);
+        return NULL;
+}
+static struct iscsi_cls_conn *iscsi_conn_lookup(uint64_t handle)
+{
+        unsigned long flags;
+        struct iscsi_cls_conn *conn;
+        spin_lock_irqsave(&connlock, flags);
+        list_for_each_entry(conn, &connlist, conn_list) {
+                if (conn == iscsi_ptr(handle)) {
+                        spin_unlock_irqrestore(&connlock, flags);
+                        return conn;
+                }
+        }
+        spin_unlock_irqrestore(&connlock, flags);
+        return NULL;
+}
 /*
 * The following functions can be used by LLDs that allocate
 * their own scsi_hosts or by software iscsi LLDs
@@ -365,6 +395,7 @@ iscsi_transport_create_session(struct scsi_transport_template *scsit,
 {
        struct iscsi_cls_session *session;
        struct Scsi_Host *shost;
+        unsigned long flags;
        shost = scsi_host_alloc(transport->host_template,
                                hostdata_privsize(transport));
@@ -389,6 +420,9 @@ iscsi_transport_create_session(struct scsi_transport_template *scsit,
                goto remove_host;
        *(unsigned long*)shost->hostdata = (unsigned long)session;
+        spin_lock_irqsave(&sesslock, flags);
+        list_add(&session->sess_list, &sesslist);
+        spin_unlock_irqrestore(&sesslock, flags);
        return shost;
 remove_host:
@@ -410,9 +444,13 @@ EXPORT_SYMBOL_GPL(iscsi_transport_create_session);
 int iscsi_transport_destroy_session(struct Scsi_Host *shost)
 {
        struct iscsi_cls_session *session;
+        unsigned long flags;
        scsi_remove_host(shost);
        session = hostdata_session(shost->hostdata);
+        spin_lock_irqsave(&sesslock, flags);
+        list_del(&session->sess_list);
+        spin_unlock_irqrestore(&sesslock, flags);
        iscsi_destroy_session(session);
        /* ref from host alloc */
        scsi_host_put(shost);
@@ -424,22 +462,6 @@ EXPORT_SYMBOL_GPL(iscsi_transport_destroy_session);
 /*
 * iscsi interface functions
 */
-static struct iscsi_cls_conn*
-iscsi_if_find_conn(uint64_t key)
-{
-        unsigned long flags;
-        struct iscsi_cls_conn *conn;
-        spin_lock_irqsave(&connlock, flags);
-        list_for_each_entry(conn, &connlist, conn_list)
-                if (conn->connh == key) {
-                        spin_unlock_irqrestore(&connlock, flags);
-                        return conn;
-                }
-        spin_unlock_irqrestore(&connlock, flags);
-        return NULL;
-}
 static struct iscsi_internal *
 iscsi_if_transport_lookup(struct iscsi_transport *tt)
 {
@@ -463,7 +485,7 @@ static inline struct list_head *skb_to_lh(struct sk_buff *skb)
 }
 static void*
-mempool_zone_alloc_skb(unsigned int gfp_mask, void *pool_data)
+mempool_zone_alloc_skb(gfp_t gfp_mask, void *pool_data)
 {
        struct mempool_zone *zone = pool_data;
@@ -504,6 +526,12 @@ mempool_zone_init(unsigned max, unsigned size, unsigned hiwat)
        if (!zp)
                return NULL;
+        zp->size = size;
+        zp->hiwat = hiwat;
+        INIT_LIST_HEAD(&zp->freequeue);
+        spin_lock_init(&zp->freelock);
+        atomic_set(&zp->allocated, 0);
        zp->pool = mempool_create(max, mempool_zone_alloc_skb,
                                  mempool_zone_free_skb, zp);
        if (!zp->pool) {
@@ -511,13 +539,6 @@ mempool_zone_init(unsigned max, unsigned size, unsigned hiwat)
                return NULL;
        }
-        zp->size = size;
-        zp->hiwat = hiwat;
-        INIT_LIST_HEAD(&zp->freequeue);
-        spin_lock_init(&zp->freelock);
-        atomic_set(&zp->allocated, 0);
        return zp;
 }
@@ -559,25 +580,21 @@ iscsi_unicast_skb(struct mempool_zone *zone, struct sk_buff *skb)
        return 0;
 }
-int iscsi_recv_pdu(iscsi_connh_t connh, struct iscsi_hdr *hdr,
+int iscsi_recv_pdu(struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr,
                   char *data, uint32_t data_size)
 {
        struct nlmsghdr *nlh;
        struct sk_buff *skb;
        struct iscsi_uevent *ev;
-        struct iscsi_cls_conn *conn;
        char *pdu;
        int len = NLMSG_SPACE(sizeof(*ev) + sizeof(struct iscsi_hdr) +
                              data_size);
-        conn = iscsi_if_find_conn(connh);
-        BUG_ON(!conn);
        mempool_zone_complete(conn->z_pdu);
        skb = mempool_zone_get_skb(conn->z_pdu);
        if (!skb) {
-                iscsi_conn_error(connh, ISCSI_ERR_CONN_FAILED);
+                iscsi_conn_error(conn, ISCSI_ERR_CONN_FAILED);
                dev_printk(KERN_ERR, &conn->dev, "iscsi: can not deliver "
                           "control PDU: OOM\n");
                return -ENOMEM;
@@ -590,7 +607,7 @@ int iscsi_recv_pdu(iscsi_connh_t connh, struct iscsi_hdr *hdr,
        ev->type = ISCSI_KEVENT_RECV_PDU;
        if (atomic_read(&conn->z_pdu->allocated) >= conn->z_pdu->hiwat)
                ev->iferror = -ENOMEM;
-        ev->r.recv_req.conn_handle = connh;
+        ev->r.recv_req.conn_handle = iscsi_handle(conn);
        pdu = (char*)ev + sizeof(*ev);
        memcpy(pdu, hdr, sizeof(struct iscsi_hdr));
        memcpy(pdu + sizeof(struct iscsi_hdr), data, data_size);
@@ -599,17 +616,13 @@ int iscsi_recv_pdu(iscsi_connh_t connh, struct iscsi_hdr *hdr,
 }
 EXPORT_SYMBOL_GPL(iscsi_recv_pdu);
-void iscsi_conn_error(iscsi_connh_t connh, enum iscsi_err error)
+void iscsi_conn_error(struct iscsi_cls_conn *conn, enum iscsi_err error)
 {
        struct nlmsghdr *nlh;
        struct sk_buff  *skb;
        struct iscsi_uevent *ev;
-        struct iscsi_cls_conn *conn;
        int len = NLMSG_SPACE(sizeof(*ev));
-        conn = iscsi_if_find_conn(connh);
-        BUG_ON(!conn);
        mempool_zone_complete(conn->z_error);
        skb = mempool_zone_get_skb(conn->z_error);
@@ -626,7 +639,7 @@ void iscsi_conn_error(iscsi_connh_t connh, enum iscsi_err error)
        if (atomic_read(&conn->z_error->allocated) >= conn->z_error->hiwat)
                ev->iferror = -ENOMEM;
        ev->r.connerror.error = error;
-        ev->r.connerror.conn_handle = connh;
+        ev->r.connerror.conn_handle = iscsi_handle(conn);
        iscsi_unicast_skb(conn->z_error, skb);
@@ -662,8 +675,7 @@ iscsi_if_send_reply(int pid, int seq, int type, int done, int multi,
 }
 static int
-iscsi_if_get_stats(struct iscsi_transport *transport, struct sk_buff *skb,
+iscsi_if_get_stats(struct iscsi_transport *transport, struct nlmsghdr *nlh)
-                   struct nlmsghdr *nlh)
 {
        struct iscsi_uevent *ev = NLMSG_DATA(nlh);
        struct iscsi_stats *stats;
@@ -677,7 +689,7 @@ iscsi_if_get_stats(struct iscsi_transport *transport, struct sk_buff *skb,
                              ISCSI_STATS_CUSTOM_MAX);
        int err = 0;
-        conn = iscsi_if_find_conn(ev->u.get_stats.conn_handle);
+        conn = iscsi_conn_lookup(ev->u.get_stats.conn_handle);
        if (!conn)
                return -EEXIST;
@@ -707,14 +719,14 @@ iscsi_if_get_stats(struct iscsi_transport *transport, struct sk_buff *skb,
                        ((char*)evstat + sizeof(*evstat));
                memset(stats, 0, sizeof(*stats));
-                transport->get_stats(ev->u.get_stats.conn_handle, stats);
+                transport->get_stats(conn, stats);
                actual_size = NLMSG_SPACE(sizeof(struct iscsi_uevent) +
                                          sizeof(struct iscsi_stats) +
                                          sizeof(struct iscsi_stats_custom) *
                                          stats->custom_length);
                actual_size -= sizeof(*nlhstat);
                actual_size = NLMSG_LENGTH(actual_size);
-                skb_trim(skb, NLMSG_ALIGN(actual_size));
+                skb_trim(skbstat, NLMSG_ALIGN(actual_size));
                nlhstat->nlmsg_len = actual_size;
                err = iscsi_unicast_skb(conn->z_pdu, skbstat);
@@ -727,58 +739,34 @@ static int
 iscsi_if_create_session(struct iscsi_internal *priv, struct iscsi_uevent *ev)
 {
        struct iscsi_transport *transport = priv->iscsi_transport;
-        struct Scsi_Host *shost;
+        struct iscsi_cls_session *session;
+        uint32_t sid;
-        if (!transport->create_session)
-                return -EINVAL;
-        shost = transport->create_session(&priv->t,
+        session = transport->create_session(&priv->t,
-                                          ev->u.c_session.initial_cmdsn);
+                                            ev->u.c_session.initial_cmdsn,
-        if (!shost)
+                                            &sid);
+        if (!session)
                return -ENOMEM;
-        ev->r.c_session_ret.session_handle = iscsi_handle(iscsi_hostdata(shost->hostdata));
+        ev->r.c_session_ret.session_handle = iscsi_handle(session);
-        ev->r.c_session_ret.sid = shost->host_no;
+        ev->r.c_session_ret.sid = sid;
        return 0;
 }
 static int
-iscsi_if_destroy_session(struct iscsi_internal *priv, struct iscsi_uevent *ev)
+iscsi_if_create_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
 {
-        struct iscsi_transport *transport = priv->iscsi_transport;
-        struct Scsi_Host *shost;
-        if (!transport->destroy_session)
-                return -EINVAL;
-        shost = scsi_host_lookup(ev->u.d_session.sid);
-        if (shost == ERR_PTR(-ENXIO))
-                return -EEXIST;
-        if (transport->destroy_session)
-                transport->destroy_session(shost);
-        /* ref from host lookup */
-        scsi_host_put(shost);
-        return 0;
-}
-static int
-iscsi_if_create_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev){
-        struct Scsi_Host *shost;
        struct iscsi_cls_conn *conn;
+        struct iscsi_cls_session *session;
        unsigned long flags;
-        if (!transport->create_conn)
+        session = iscsi_session_lookup(ev->u.c_conn.session_handle);
+        if (!session)
                return -EINVAL;
-        shost = scsi_host_lookup(ev->u.c_conn.sid);
+        conn = transport->create_conn(session, ev->u.c_conn.cid);
-        if (shost == ERR_PTR(-ENXIO))
-                return -EEXIST;
-        conn = transport->create_conn(shost, ev->u.c_conn.cid);
        if (!conn)
-                goto release_ref;
+                return -ENOMEM;
        conn->z_pdu = mempool_zone_init(Z_MAX_PDU,
                        NLMSG_SPACE(sizeof(struct iscsi_uevent) +
@@ -800,14 +788,13 @@ iscsi_if_create_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
                goto free_pdu_pool;
        }
-        ev->r.handle = conn->connh = iscsi_handle(conn->dd_data);
+        ev->r.handle = iscsi_handle(conn);
        spin_lock_irqsave(&connlock, flags);
        list_add(&conn->conn_list, &connlist);
        conn->active = 1;
        spin_unlock_irqrestore(&connlock, flags);
-        scsi_host_put(shost);
        return 0;
 free_pdu_pool:
@@ -815,8 +802,6 @@ free_pdu_pool:
 destroy_conn:
        if (transport->destroy_conn)
                transport->destroy_conn(conn->dd_data);
-release_ref:
-        scsi_host_put(shost);
        return -ENOMEM;
 }
@@ -827,13 +812,9 @@ iscsi_if_destroy_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev
        struct iscsi_cls_conn *conn;
        struct mempool_zone *z_error, *z_pdu;
-        conn = iscsi_if_find_conn(ev->u.d_conn.conn_handle);
+        conn = iscsi_conn_lookup(ev->u.d_conn.conn_handle);
        if (!conn)
-                return -EEXIST;
-        if (!transport->destroy_conn)
                return -EINVAL;
        spin_lock_irqsave(&connlock, flags);
        conn->active = 0;
        list_del(&conn->conn_list);
@@ -858,23 +839,27 @@ iscsi_if_recv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
        struct iscsi_uevent *ev = NLMSG_DATA(nlh);
        struct iscsi_transport *transport = NULL;
        struct iscsi_internal *priv;
+        struct iscsi_cls_session *session;
-        if (NETLINK_CREDS(skb)->uid)
+        struct iscsi_cls_conn *conn;
-                return -EPERM;
        priv = iscsi_if_transport_lookup(iscsi_ptr(ev->transport_handle));
        if (!priv)
                return -EINVAL;
        transport = priv->iscsi_transport;
-        daemon_pid = NETLINK_CREDS(skb)->pid;
+        if (!try_module_get(transport->owner))
+                return -EINVAL;
        switch (nlh->nlmsg_type) {
        case ISCSI_UEVENT_CREATE_SESSION:
                err = iscsi_if_create_session(priv, ev);
                break;
        case ISCSI_UEVENT_DESTROY_SESSION:
-                err = iscsi_if_destroy_session(priv, ev);
+                session = iscsi_session_lookup(ev->u.d_session.session_handle);
+                if (session)
+                        transport->destroy_session(session);
+                else
+                        err = -EINVAL;
                break;
        case ISCSI_UEVENT_CREATE_CONN:
                err = iscsi_if_create_conn(transport, ev);
@@ -883,56 +868,64 @@ iscsi_if_recv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
                err = iscsi_if_destroy_conn(transport, ev);
                break;
        case ISCSI_UEVENT_BIND_CONN:
-                if (!iscsi_if_find_conn(ev->u.b_conn.conn_handle))
+                session = iscsi_session_lookup(ev->u.b_conn.session_handle);
-                        return -EEXIST;
+                conn = iscsi_conn_lookup(ev->u.b_conn.conn_handle);
-                ev->r.retcode = transport->bind_conn(
-                        ev->u.b_conn.session_handle,
+                if (session && conn)
-                        ev->u.b_conn.conn_handle,
+                        ev->r.retcode = transport->bind_conn(session, conn,
-                        ev->u.b_conn.transport_fd,
+                                        ev->u.b_conn.transport_fd,
-                        ev->u.b_conn.is_leading);
+                                        ev->u.b_conn.is_leading);
+                else
+                        err = -EINVAL;
                break;
        case ISCSI_UEVENT_SET_PARAM:
-                if (!iscsi_if_find_conn(ev->u.set_param.conn_handle))
+                conn = iscsi_conn_lookup(ev->u.set_param.conn_handle);
-                        return -EEXIST;
+                if (conn)
-                ev->r.retcode = transport->set_param(
+                        ev->r.retcode = transport->set_param(conn,
-                        ev->u.set_param.conn_handle,
+                                ev->u.set_param.param, ev->u.set_param.value);
-                        ev->u.set_param.param, ev->u.set_param.value);
+                else
+                        err = -EINVAL;
                break;
        case ISCSI_UEVENT_START_CONN:
-                if (!iscsi_if_find_conn(ev->u.start_conn.conn_handle))
+                conn = iscsi_conn_lookup(ev->u.start_conn.conn_handle);
-                        return -EEXIST;
+                if (conn)
-                ev->r.retcode = transport->start_conn(
+                        ev->r.retcode = transport->start_conn(conn);
-                        ev->u.start_conn.conn_handle);
+                else
+                        err = -EINVAL;
                break;
        case ISCSI_UEVENT_STOP_CONN:
-                if (!iscsi_if_find_conn(ev->u.stop_conn.conn_handle))
+                conn = iscsi_conn_lookup(ev->u.stop_conn.conn_handle);
-                        return -EEXIST;
+                if (conn)
-                transport->stop_conn(ev->u.stop_conn.conn_handle,
+                        transport->stop_conn(conn, ev->u.stop_conn.flag);
-                        ev->u.stop_conn.flag);
+                else
+                        err = -EINVAL;
                break;
        case ISCSI_UEVENT_SEND_PDU:
-                if (!iscsi_if_find_conn(ev->u.send_pdu.conn_handle))
+                conn = iscsi_conn_lookup(ev->u.send_pdu.conn_handle);
-                        return -EEXIST;
+                if (conn)
-                ev->r.retcode = transport->send_pdu(
+                        ev->r.retcode = transport->send_pdu(conn,
-                       ev->u.send_pdu.conn_handle,
+                                (struct iscsi_hdr*)((char*)ev + sizeof(*ev)),
-                       (struct iscsi_hdr*)((char*)ev + sizeof(*ev)),
+                                (char*)ev + sizeof(*ev) + ev->u.send_pdu.hdr_size,
-                       (char*)ev + sizeof(*ev) + ev->u.send_pdu.hdr_size,
+                                ev->u.send_pdu.data_size);
-                        ev->u.send_pdu.data_size);
+                else
+                        err = -EINVAL;
                break;
        case ISCSI_UEVENT_GET_STATS:
-                err = iscsi_if_get_stats(transport, skb, nlh);
+                err = iscsi_if_get_stats(transport, nlh);
                break;
        default:
                err = -EINVAL;
                break;
        }
+        module_put(transport->owner);
        return err;
 }
 /* Get message from skb (based on rtnetlink_rcv_skb).  Each message is
 * processed by iscsi_if_recv_msg.  Malformed skbs with wrong length are
- * discarded silently.  */
+ * or invalid creds discarded silently.  */
 static void
 iscsi_if_rx(struct sock *sk, int len)
 {
@@ -940,6 +933,12 @@ iscsi_if_rx(struct sock *sk, int len)
        mutex_lock(&rx_queue_mutex);
        while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
+                if (NETLINK_CREDS(skb)->uid) {
+                        skb_pull(skb, skb->len);
+                        goto free_skb;
+                }
+                daemon_pid = NETLINK_CREDS(skb)->pid;
                while (skb->len >= NLMSG_SPACE(0)) {
                        int err;
                        uint32_t rlen;
@@ -951,10 +950,12 @@ iscsi_if_rx(struct sock *sk, int len)
                            skb->len < nlh->nlmsg_len) {
                                break;
                        }
                        ev = NLMSG_DATA(nlh);
                        rlen = NLMSG_ALIGN(nlh->nlmsg_len);
                        if (rlen > skb->len)
                                rlen = skb->len;
                        err = iscsi_if_recv_msg(skb, nlh);
                        if (err) {
                                ev->type = ISCSI_KEVENT_IF_ERROR;
@@ -978,6 +979,7 @@ iscsi_if_rx(struct sock *sk, int len)
                        } while (err < 0 && err != -ECONNREFUSED);
                        skb_pull(skb, rlen);
                }
+free_skb:
                kfree_skb(skb);
        }
        mutex_unlock(&rx_queue_mutex);
@@ -997,7 +999,7 @@ show_conn_int_param_##param(struct class_device *cdev, char *buf)	\
        struct iscsi_cls_conn *conn = iscsi_cdev_to_conn(cdev);         \
        struct iscsi_transport *t = conn->transport;                    \
                                                                        \
-        t->get_conn_param(conn->dd_data, param, &value);                \
+        t->get_conn_param(conn, param, &value);                         \
        return snprintf(buf, 20, format"\n", value);                    \
 }
@@ -1024,10 +1026,9 @@ show_session_int_param_##param(struct class_device *cdev, char *buf)	\
 {                                                                       \
        uint32_t value = 0;                                             \
        struct iscsi_cls_session *session = iscsi_cdev_to_session(cdev);        \
-        struct Scsi_Host *shost = iscsi_session_to_shost(session);      \
        struct iscsi_transport *t = session->transport;                 \
                                                                        \
-        t->get_session_param(shost, param, &value);                     \
+        t->get_session_param(session, param, &value);                   \
        return snprintf(buf, 20, format"\n", value);                    \
 }
@@ -1121,7 +1122,6 @@ iscsi_register_transport(struct iscsi_transport *tt)
                return NULL;
        memset(priv, 0, sizeof(*priv));
        INIT_LIST_HEAD(&priv->list);
-        INIT_LIST_HEAD(&priv->sessions);
        priv->iscsi_transport = tt;
        priv->cdev.class = &iscsi_transport_class;
diff --git a/drivers/scsi/scsi_transport_sas.c b/drivers/scsi/scsi_transport_sas.c
index a3e0b7bc2d7b..210dab5879fa 100644
--- a/drivers/scsi/scsi_transport_sas.c
+++ b/drivers/scsi/scsi_transport_sas.c
@@ -377,7 +377,7 @@ static void sas_phy_release(struct device *dev)
 /**
 * sas_phy_alloc  --  allocates and initialize a SAS PHY structure
 * @parent:     Parent device
- * @number:     Port number
+ * @number:     Phy index
 *
 * Allocates an SAS PHY structure.  It will be added in the device tree
 * below the device specified by @parent, which has to be either a Scsi_Host
@@ -595,8 +595,8 @@ struct sas_rphy *sas_rphy_alloc(struct sas_phy *parent)
        device_initialize(&rphy->dev);
        rphy->dev.parent = get_device(&parent->dev);
        rphy->dev.release = sas_rphy_release;
-        sprintf(rphy->dev.bus_id, "rphy-%d:%d",
+        sprintf(rphy->dev.bus_id, "rphy-%d:%d-%d",
-                shost->host_no, parent->number);
+                shost->host_no, parent->port_identifier, parent->number);
        transport_setup_device(&rphy->dev);
        return rphy;
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 930db398d107..9d9872347f56 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -89,6 +89,11 @@
 #define SD_MAX_RETRIES          5
 #define SD_PASSTHROUGH_RETRIES  1
+/*
+ * Size of the initial data buffer for mode and read capacity data
+ */
+#define SD_BUF_SIZE             512
 static void scsi_disk_release(struct kref *kref);
 struct scsi_disk {
@@ -1239,7 +1244,7 @@ sd_do_mode_sense(struct scsi_device *sdp, int dbd, int modepage,
 /*
 * read write protect setting, if possible - called only in sd_revalidate_disk()
- * called with buffer of length 512
+ * called with buffer of length SD_BUF_SIZE
 */
 static void
 sd_read_write_protect_flag(struct scsi_disk *sdkp, char *diskname,
@@ -1297,7 +1302,7 @@ sd_read_write_protect_flag(struct scsi_disk *sdkp, char *diskname,
 /*
 * sd_read_cache_type - called only from sd_revalidate_disk()
- * called with buffer of length 512
+ * called with buffer of length SD_BUF_SIZE
 */
 static void
 sd_read_cache_type(struct scsi_disk *sdkp, char *diskname,
@@ -1342,6 +1347,8 @@ sd_read_cache_type(struct scsi_disk *sdkp, char *diskname,
        /* Take headers and block descriptors into account */
        len += data.header_length + data.block_descriptor_length;
+        if (len > SD_BUF_SIZE)
+                goto bad_sense;
        /* Get the data */
        res = sd_do_mode_sense(sdp, dbd, modepage, buffer, len, &data, &sshdr);
@@ -1354,6 +1361,12 @@ sd_read_cache_type(struct scsi_disk *sdkp, char *diskname,
                int ct = 0;
                int offset = data.header_length + data.block_descriptor_length;
+                if (offset >= SD_BUF_SIZE - 2) {
+                        printk(KERN_ERR "%s: malformed MODE SENSE response",
+                                diskname);
+                        goto defaults;
+                }
                if ((buffer[offset] & 0x3f) != modepage) {
                        printk(KERN_ERR "%s: got wrong page\n", diskname);
                        goto defaults;
@@ -1398,6 +1411,7 @@ defaults:
               diskname);
        sdkp->WCE = 0;
        sdkp->RCD = 0;
+        sdkp->DPOFUA = 0;
 }
 /**
@@ -1421,7 +1435,7 @@ static int sd_revalidate_disk(struct gendisk *disk)
        if (!scsi_device_online(sdp))
                goto out;
-        buffer = kmalloc(512, GFP_KERNEL | __GFP_DMA);
+        buffer = kmalloc(SD_BUF_SIZE, GFP_KERNEL | __GFP_DMA);
        if (!buffer) {
                printk(KERN_WARNING "(sd_revalidate_disk:) Memory allocation "
                       "failure.\n");
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 78aad9582bcf..5a0a19322d01 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -741,7 +741,7 @@ sg_common_write(Sg_fd * sfp, Sg_request * srp,
        hp->duration = jiffies_to_msecs(jiffies);
 /* Now send everything of to mid-level. The next time we hear about this
   packet is when sg_cmd_done() is called (i.e. a callback). */
-        if (scsi_execute_async(sdp->device, cmnd, data_dir, srp->data.buffer,
+        if (scsi_execute_async(sdp->device, cmnd, hp->cmd_len, data_dir, srp->data.buffer,
                                hp->dxfer_len, srp->data.k_use_sg, timeout,
                                SG_DEFAULT_RETRIES, srp, sg_cmd_done,
                                GFP_ATOMIC)) {
@@ -1679,7 +1679,7 @@ static int
 sg_build_sgat(Sg_scatter_hold * schp, const Sg_fd * sfp, int tablesize)
 {
        int sg_bufflen = tablesize * sizeof(struct scatterlist);
-        unsigned int gfp_flags = GFP_ATOMIC | __GFP_NOWARN;
+        gfp_t gfp_flags = GFP_ATOMIC | __GFP_NOWARN;
        /*
         * TODO: test without low_dma, we should not need it since
@@ -2162,7 +2162,7 @@ sg_link_reserve(Sg_fd * sfp, Sg_request * srp, int size)
        srp->res_used = 1;
        SCSI_LOG_TIMEOUT(4, printk("sg_link_reserve: size=%d\n", size));
-        rem = size = (size + 1) & (~1); /* round to even for aha1542 */
+        rem = size;
        for (k = 0; k < rsv_schp->k_use_sg; ++k, ++sg) {
                num = sg->length;
diff --git a/drivers/scsi/sr_ioctl.c b/drivers/scsi/sr_ioctl.c
index 5d02ff4db6cc..b65462f76484 100644
--- a/drivers/scsi/sr_ioctl.c
+++ b/drivers/scsi/sr_ioctl.c
@@ -192,7 +192,7 @@ int sr_do_ioctl(Scsi_CD *cd, struct packet_command *cgc)
        SDev = cd->device;
        if (!sense) {
-                sense = kmalloc(sizeof(*sense), GFP_KERNEL);
+                sense = kmalloc(SCSI_SENSE_BUFFERSIZE, GFP_KERNEL);
                if (!sense) {
                        err = -ENOMEM;
                        goto out;
diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index 13b1d3aac265..7f96f33c1bb1 100644
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -508,7 +508,7 @@ st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd
        STp->buffer->cmdstat.have_sense = 0;
        STp->buffer->syscall_result = 0;
-        if (scsi_execute_async(STp->device, cmd, direction,
+        if (scsi_execute_async(STp->device, cmd, COMMAND_SIZE(cmd[0]), direction,
                        &((STp->buffer)->sg[0]), bytes, (STp->buffer)->sg_segs,
                               timeout, retries, SRpnt, st_sleep_done, GFP_KERNEL)) {
                /* could not allocate the buffer or request was too large */
diff --git a/drivers/scsi/sym53c8xx_2/sym_hipd.c b/drivers/scsi/sym53c8xx_2/sym_hipd.c
index 8260f040d39c..2627000ca653 100644
--- a/drivers/scsi/sym53c8xx_2/sym_hipd.c
+++ b/drivers/scsi/sym53c8xx_2/sym_hipd.c
@@ -919,6 +919,8 @@ static int sym_prepare_setting(struct Scsi_Host *shost, struct sym_hcb *np, stru
                tp->usrflags |= (SYM_DISC_ENABLED | SYM_TAGS_ENABLED);
                tp->usrtags = SYM_SETUP_MAX_TAG;
+                tp->usr_width = np->maxwide;
+                tp->usr_period = 9;
                sym_nvram_setup_target(tp, i, nvram);
@@ -3588,7 +3590,7 @@ static int sym_evaluate_dp(struct sym_hcb *np, struct sym_ccb *cp, u32 scr, int
        if (pm) {
                dp_scr  = scr_to_cpu(pm->ret);
-                dp_ofs -= scr_to_cpu(pm->sg.size);
+                dp_ofs -= scr_to_cpu(pm->sg.size) & 0x00ffffff;
        }
        /*