[SCSI] BusLogic: Fix style issues

Fix CamelCase and extra long lines in the buslogic driver.

Signed-off-by: Khalid Aziz <khalid.aziz@oracle.com>
Signed-off-by: James Bottomley <JBottomley@Parallels.com>

3 files changed, 3105 insertions, 2865 deletions

diff --git a/drivers/scsi/BusLogic.c b/drivers/scsi/BusLogic.c
index 344d87599cd2..6ec36d83af6c 100644
--- a/drivers/scsi/BusLogic.c
+++ b/drivers/scsi/BusLogic.c
@@ -26,8 +26,8 @@
 
 */
 
-#define BusLogic_DriverVersion          "2.1.16"
-#define BusLogic_DriverDate             "18 July 2002"
+#define blogic_drvr_version             "2.1.16"
+#define blogic_drvr_date                "18 July 2002"
 
 #include <linux/module.h>
 #include <linux/init.h>
@@ -60,24 +60,24 @@
 #define FAILURE (-1)
 #endif
 
-static struct scsi_host_template Bus_Logic_template;
+static struct scsi_host_template blogic_template;
 
 /*
-  BusLogic_DriverOptionsCount is a count of the number of BusLogic Driver
+  blogic_drvr_options_count is a count of the number of BusLogic Driver
   Options specifications provided via the Linux Kernel Command Line or via
   the Loadable Kernel Module Installation Facility.
 */
 
-static int BusLogic_DriverOptionsCount;
+static int blogic_drvr_options_count;
 
 
 /*
-  BusLogic_DriverOptions is an array of Driver Options structures representing
+  blogic_drvr_options is an array of Driver Options structures representing
   BusLogic Driver Options specifications provided via the Linux Kernel Command
   Line or via the Loadable Kernel Module Installation Facility.
 */
 
-static struct BusLogic_DriverOptions BusLogic_DriverOptions[BusLogic_MaxHostAdapters];
+static struct blogic_drvr_options blogic_drvr_options[BLOGIC_MAX_ADAPTERS];
 
 
 /*
@@ -92,241 +92,251 @@ module_param(BusLogic, charp, 0);
 
 
 /*
-  BusLogic_ProbeOptions is a set of Probe Options to be applied across
+  blogic_probe_options is a set of Probe Options to be applied across
   all BusLogic Host Adapters.
 */
 
-static struct BusLogic_ProbeOptions BusLogic_ProbeOptions;
+static struct blogic_probe_options blogic_probe_options;
 
 
 /*
-  BusLogic_GlobalOptions is a set of Global Options to be applied across
+  blogic_global_options is a set of Global Options to be applied across
   all BusLogic Host Adapters.
 */
 
-static struct BusLogic_GlobalOptions BusLogic_GlobalOptions;
+static struct blogic_global_options blogic_global_options;
 
-static LIST_HEAD(BusLogic_host_list);
+static LIST_HEAD(blogic_host_list);
 
 /*
-  BusLogic_ProbeInfoCount is the number of entries in BusLogic_ProbeInfoList.
+  blogic_probeinfo_count is the number of entries in blogic_probeinfo_list.
 */
 
-static int BusLogic_ProbeInfoCount;
+static int blogic_probeinfo_count;
 
 
 /*
-  BusLogic_ProbeInfoList is the list of I/O Addresses and Bus Probe Information
+  blogic_probeinfo_list is the list of I/O Addresses and Bus Probe Information
   to be checked for potential BusLogic Host Adapters.  It is initialized by
   interrogating the PCI Configuration Space on PCI machines as well as from the
   list of standard BusLogic I/O Addresses.
 */
 
-static struct BusLogic_ProbeInfo *BusLogic_ProbeInfoList;
+static struct blogic_probeinfo *blogic_probeinfo_list;
 
 
 /*
-  BusLogic_CommandFailureReason holds a string identifying the reason why a
-  call to BusLogic_Command failed.  It is only non-NULL when BusLogic_Command
+  blogic_cmd_failure_reason holds a string identifying the reason why a
+  call to blogic_cmd failed.  It is only non-NULL when blogic_cmd
   returns a failure code.
 */
 
-static char *BusLogic_CommandFailureReason;
+static char *blogic_cmd_failure_reason;
 
 /*
-  BusLogic_AnnounceDriver announces the Driver Version and Date, Author's
+  blogic_announce_drvr announces the Driver Version and Date, Author's
   Name, Copyright Notice, and Electronic Mail Address.
 */
 
-static void BusLogic_AnnounceDriver(struct BusLogic_HostAdapter *HostAdapter)
+static void blogic_announce_drvr(struct blogic_adapter *adapter)
 {
-        BusLogic_Announce("***** BusLogic SCSI Driver Version " BusLogic_DriverVersion " of " BusLogic_DriverDate " *****\n", HostAdapter);
-        BusLogic_Announce("Copyright 1995-1998 by Leonard N. Zubkoff " "<lnz@dandelion.com>\n", HostAdapter);
+        blogic_announce("***** BusLogic SCSI Driver Version " blogic_drvr_version " of " blogic_drvr_date " *****\n", adapter);
+        blogic_announce("Copyright 1995-1998 by Leonard N. Zubkoff " "<lnz@dandelion.com>\n", adapter);
 }
 
 
 /*
-  BusLogic_DriverInfo returns the Host Adapter Name to identify this SCSI
+  blogic_drvr_info returns the Host Adapter Name to identify this SCSI
   Driver and Host Adapter.
 */
 
-static const char *BusLogic_DriverInfo(struct Scsi_Host *Host)
+static const char *blogic_drvr_info(struct Scsi_Host *host)
 {
-        struct BusLogic_HostAdapter *HostAdapter = (struct BusLogic_HostAdapter *) Host->hostdata;
-        return HostAdapter->FullModelName;
+        struct blogic_adapter *adapter =
+                                (struct blogic_adapter *) host->hostdata;
+        return adapter->full_model;
 }
 
 /*
-  BusLogic_InitializeCCBs initializes a group of Command Control Blocks (CCBs)
-  for Host Adapter from the BlockSize bytes located at BlockPointer.  The newly
+  blogic_init_ccbs initializes a group of Command Control Blocks (CCBs)
+  for Host Adapter from the blk_size bytes located at blk_pointer.  The newly
   created CCBs are added to Host Adapter's free list.
 */
 
-static void BusLogic_InitializeCCBs(struct BusLogic_HostAdapter *HostAdapter, void *BlockPointer, int BlockSize, dma_addr_t BlockPointerHandle)
+static void blogic_init_ccbs(struct blogic_adapter *adapter, void *blk_pointer,
+                                int blk_size, dma_addr_t blkp)
 {
-        struct BusLogic_CCB *CCB = (struct BusLogic_CCB *) BlockPointer;
+        struct blogic_ccb *ccb = (struct blogic_ccb *) blk_pointer;
         unsigned int offset = 0;
-        memset(BlockPointer, 0, BlockSize);
-        CCB->AllocationGroupHead = BlockPointerHandle;
-        CCB->AllocationGroupSize = BlockSize;
-        while ((BlockSize -= sizeof(struct BusLogic_CCB)) >= 0) {
-                CCB->Status = BusLogic_CCB_Free;
-                CCB->HostAdapter = HostAdapter;
-                CCB->DMA_Handle = (u32) BlockPointerHandle + offset;
-                if (BusLogic_FlashPointHostAdapterP(HostAdapter)) {
-                        CCB->CallbackFunction = BusLogic_QueueCompletedCCB;
-                        CCB->BaseAddress = HostAdapter->FlashPointInfo.BaseAddress;
+        memset(blk_pointer, 0, blk_size);
+        ccb->allocgrp_head = blkp;
+        ccb->allocgrp_size = blk_size;
+        while ((blk_size -= sizeof(struct blogic_ccb)) >= 0) {
+                ccb->status = BLOGIC_CCB_FREE;
+                ccb->adapter = adapter;
+                ccb->dma_handle = (u32) blkp + offset;
+                if (blogic_flashpoint_type(adapter)) {
+                        ccb->callback = blogic_qcompleted_ccb;
+                        ccb->base_addr = adapter->fpinfo.base_addr;
                 }
-                CCB->Next = HostAdapter->Free_CCBs;
-                CCB->NextAll = HostAdapter->All_CCBs;
-                HostAdapter->Free_CCBs = CCB;
-                HostAdapter->All_CCBs = CCB;
-                HostAdapter->AllocatedCCBs++;
-                CCB++;
-                offset += sizeof(struct BusLogic_CCB);
+                ccb->next = adapter->free_ccbs;
+                ccb->next_all = adapter->all_ccbs;
+                adapter->free_ccbs = ccb;
+                adapter->all_ccbs = ccb;
+                adapter->alloc_ccbs++;
+                ccb++;
+                offset += sizeof(struct blogic_ccb);
         }
 }
 
 
 /*
-  BusLogic_CreateInitialCCBs allocates the initial CCBs for Host Adapter.
+  blogic_create_initccbs allocates the initial CCBs for Host Adapter.
 */
 
-static bool __init BusLogic_CreateInitialCCBs(struct BusLogic_HostAdapter *HostAdapter)
+static bool __init blogic_create_initccbs(struct blogic_adapter *adapter)
 {
-        int BlockSize = BusLogic_CCB_AllocationGroupSize * sizeof(struct BusLogic_CCB);
-        void *BlockPointer;
-        dma_addr_t BlockPointerHandle;
-        while (HostAdapter->AllocatedCCBs < HostAdapter->InitialCCBs) {
-                BlockPointer = pci_alloc_consistent(HostAdapter->PCI_Device, BlockSize, &BlockPointerHandle);
-                if (BlockPointer == NULL) {
-                        BusLogic_Error("UNABLE TO ALLOCATE CCB GROUP - DETACHING\n", HostAdapter);
+        int blk_size = BLOGIC_CCB_GRP_ALLOCSIZE * sizeof(struct blogic_ccb);
+        void *blk_pointer;
+        dma_addr_t blkp;
+
+        while (adapter->alloc_ccbs < adapter->initccbs) {
+                blk_pointer = pci_alloc_consistent(adapter->pci_device,
+                                                        blk_size, &blkp);
+                if (blk_pointer == NULL) {
+                        blogic_err("UNABLE TO ALLOCATE CCB GROUP - DETACHING\n",
+                                        adapter);
                         return false;
                 }
-                BusLogic_InitializeCCBs(HostAdapter, BlockPointer, BlockSize, BlockPointerHandle);
+                blogic_init_ccbs(adapter, blk_pointer, blk_size, blkp);
         }
         return true;
 }
 
 
 /*
-  BusLogic_DestroyCCBs deallocates the CCBs for Host Adapter.
+  blogic_destroy_ccbs deallocates the CCBs for Host Adapter.
 */
 
-static void BusLogic_DestroyCCBs(struct BusLogic_HostAdapter *HostAdapter)
+static void blogic_destroy_ccbs(struct blogic_adapter *adapter)
 {
-        struct BusLogic_CCB *NextCCB = HostAdapter->All_CCBs, *CCB, *Last_CCB = NULL;
-        HostAdapter->All_CCBs = NULL;
-        HostAdapter->Free_CCBs = NULL;
-        while ((CCB = NextCCB) != NULL) {
-                NextCCB = CCB->NextAll;
-                if (CCB->AllocationGroupHead) {
-                        if (Last_CCB)
-                                pci_free_consistent(HostAdapter->PCI_Device, Last_CCB->AllocationGroupSize, Last_CCB, Last_CCB->AllocationGroupHead);
-                        Last_CCB = CCB;
+        struct blogic_ccb *next_ccb = adapter->all_ccbs, *ccb, *lastccb = NULL;
+        adapter->all_ccbs = NULL;
+        adapter->free_ccbs = NULL;
+        while ((ccb = next_ccb) != NULL) {
+                next_ccb = ccb->next_all;
+                if (ccb->allocgrp_head) {
+                        if (lastccb)
+                                pci_free_consistent(adapter->pci_device,
+                                                lastccb->allocgrp_size, lastccb,
+                                                lastccb->allocgrp_head);
+                        lastccb = ccb;
                 }
         }
-        if (Last_CCB)
-                pci_free_consistent(HostAdapter->PCI_Device, Last_CCB->AllocationGroupSize, Last_CCB, Last_CCB->AllocationGroupHead);
+        if (lastccb)
+                pci_free_consistent(adapter->pci_device, lastccb->allocgrp_size,
+                                        lastccb, lastccb->allocgrp_head);
 }
 
 
 /*
-  BusLogic_CreateAdditionalCCBs allocates Additional CCBs for Host Adapter.  If
+  blogic_create_addlccbs allocates Additional CCBs for Host Adapter.  If
   allocation fails and there are no remaining CCBs available, the Driver Queue
   Depth is decreased to a known safe value to avoid potential deadlocks when
   multiple host adapters share the same IRQ Channel.
 */
 
-static void BusLogic_CreateAdditionalCCBs(struct BusLogic_HostAdapter *HostAdapter, int AdditionalCCBs, bool SuccessMessageP)
+static void blogic_create_addlccbs(struct blogic_adapter *adapter,
+                                        int addl_ccbs, bool print_success)
 {
-        int BlockSize = BusLogic_CCB_AllocationGroupSize * sizeof(struct BusLogic_CCB);
-        int PreviouslyAllocated = HostAdapter->AllocatedCCBs;
-        void *BlockPointer;
-        dma_addr_t BlockPointerHandle;
-        if (AdditionalCCBs <= 0)
+        int blk_size = BLOGIC_CCB_GRP_ALLOCSIZE * sizeof(struct blogic_ccb);
+        int prev_alloc = adapter->alloc_ccbs;
+        void *blk_pointer;
+        dma_addr_t blkp;
+        if (addl_ccbs <= 0)
                 return;
-        while (HostAdapter->AllocatedCCBs - PreviouslyAllocated < AdditionalCCBs) {
-                BlockPointer = pci_alloc_consistent(HostAdapter->PCI_Device, BlockSize, &BlockPointerHandle);
-                if (BlockPointer == NULL)
+        while (adapter->alloc_ccbs - prev_alloc < addl_ccbs) {
+                blk_pointer = pci_alloc_consistent(adapter->pci_device,
+                                                        blk_size, &blkp);
+                if (blk_pointer == NULL)
                         break;
-                BusLogic_InitializeCCBs(HostAdapter, BlockPointer, BlockSize, BlockPointerHandle);
+                blogic_init_ccbs(adapter, blk_pointer, blk_size, blkp);
         }
-        if (HostAdapter->AllocatedCCBs > PreviouslyAllocated) {
-                if (SuccessMessageP)
-                        BusLogic_Notice("Allocated %d additional CCBs (total now %d)\n", HostAdapter, HostAdapter->AllocatedCCBs - PreviouslyAllocated, HostAdapter->AllocatedCCBs);
+        if (adapter->alloc_ccbs > prev_alloc) {
+                if (print_success)
+                        blogic_notice("Allocated %d additional CCBs (total now %d)\n", adapter, adapter->alloc_ccbs - prev_alloc, adapter->alloc_ccbs);
                 return;
         }
-        BusLogic_Notice("Failed to allocate additional CCBs\n", HostAdapter);
-        if (HostAdapter->DriverQueueDepth > HostAdapter->AllocatedCCBs - HostAdapter->TargetDeviceCount) {
-                HostAdapter->DriverQueueDepth = HostAdapter->AllocatedCCBs - HostAdapter->TargetDeviceCount;
-                HostAdapter->SCSI_Host->can_queue = HostAdapter->DriverQueueDepth;
+        blogic_notice("Failed to allocate additional CCBs\n", adapter);
+        if (adapter->drvr_qdepth > adapter->alloc_ccbs - adapter->tgt_count) {
+                adapter->drvr_qdepth = adapter->alloc_ccbs - adapter->tgt_count;
+                adapter->scsi_host->can_queue = adapter->drvr_qdepth;
         }
 }
 
 /*
-  BusLogic_AllocateCCB allocates a CCB from Host Adapter's free list,
+  blogic_alloc_ccb allocates a CCB from Host Adapter's free list,
   allocating more memory from the Kernel if necessary.  The Host Adapter's
   Lock should already have been acquired by the caller.
 */
 
-static struct BusLogic_CCB *BusLogic_AllocateCCB(struct BusLogic_HostAdapter
-                                                 *HostAdapter)
+static struct blogic_ccb *blogic_alloc_ccb(struct blogic_adapter *adapter)
 {
-        static unsigned long SerialNumber = 0;
-        struct BusLogic_CCB *CCB;
-        CCB = HostAdapter->Free_CCBs;
-        if (CCB != NULL) {
-                CCB->SerialNumber = ++SerialNumber;
-                HostAdapter->Free_CCBs = CCB->Next;
-                CCB->Next = NULL;
-                if (HostAdapter->Free_CCBs == NULL)
-                        BusLogic_CreateAdditionalCCBs(HostAdapter, HostAdapter->IncrementalCCBs, true);
-                return CCB;
-        }
-        BusLogic_CreateAdditionalCCBs(HostAdapter, HostAdapter->IncrementalCCBs, true);
-        CCB = HostAdapter->Free_CCBs;
-        if (CCB == NULL)
+        static unsigned long serial;
+        struct blogic_ccb *ccb;
+        ccb = adapter->free_ccbs;
+        if (ccb != NULL) {
+                ccb->serial = ++serial;
+                adapter->free_ccbs = ccb->next;
+                ccb->next = NULL;
+                if (adapter->free_ccbs == NULL)
+                        blogic_create_addlccbs(adapter, adapter->inc_ccbs,
+                                                true);
+                return ccb;
+        }
+        blogic_create_addlccbs(adapter, adapter->inc_ccbs, true);
+        ccb = adapter->free_ccbs;
+        if (ccb == NULL)
                 return NULL;
-        CCB->SerialNumber = ++SerialNumber;
-        HostAdapter->Free_CCBs = CCB->Next;
-        CCB->Next = NULL;
-        return CCB;
+        ccb->serial = ++serial;
+        adapter->free_ccbs = ccb->next;
+        ccb->next = NULL;
+        return ccb;
 }
 
 
 /*
-  BusLogic_DeallocateCCB deallocates a CCB, returning it to the Host Adapter's
+  blogic_dealloc_ccb deallocates a CCB, returning it to the Host Adapter's
   free list.  The Host Adapter's Lock should already have been acquired by the
   caller.
 */
 
-static void BusLogic_DeallocateCCB(struct BusLogic_CCB *CCB)
+static void blogic_dealloc_ccb(struct blogic_ccb *ccb)
 {
-        struct BusLogic_HostAdapter *HostAdapter = CCB->HostAdapter;
+        struct blogic_adapter *adapter = ccb->adapter;
 
-        scsi_dma_unmap(CCB->Command);
-        pci_unmap_single(HostAdapter->PCI_Device, CCB->SenseDataPointer,
-                         CCB->SenseDataLength, PCI_DMA_FROMDEVICE);
+        scsi_dma_unmap(ccb->command);
+        pci_unmap_single(adapter->pci_device, ccb->sensedata,
+                         ccb->sense_datalen, PCI_DMA_FROMDEVICE);
 
-        CCB->Command = NULL;
-        CCB->Status = BusLogic_CCB_Free;
-        CCB->Next = HostAdapter->Free_CCBs;
-        HostAdapter->Free_CCBs = CCB;
+        ccb->command = NULL;
+        ccb->status = BLOGIC_CCB_FREE;
+        ccb->next = adapter->free_ccbs;
+        adapter->free_ccbs = ccb;
 }
 
 
 /*
-  BusLogic_Command sends the command OperationCode to HostAdapter, optionally
-  providing ParameterLength bytes of ParameterData and receiving at most
-  ReplyLength bytes of ReplyData; any excess reply data is received but
+  blogic_cmd sends the command opcode to adapter, optionally
+  providing paramlen bytes of param and receiving at most
+  replylen bytes of reply; any excess reply data is received but
   discarded.
 
   On success, this function returns the number of reply bytes read from
   the Host Adapter (including any discarded data); on failure, it returns
   -1 if the command was invalid, or -2 if a timeout occurred.
 
-  BusLogic_Command is called exclusively during host adapter detection and
+  blogic_cmd is called exclusively during host adapter detection and
   initialization, so performance and latency are not critical, and exclusive
   access to the Host Adapter hardware is assumed.  Once the host adapter and
   driver are initialized, the only Host Adapter command that is issued is the
@@ -334,255 +344,274 @@ static void BusLogic_DeallocateCCB(struct BusLogic_CCB *CCB)
   waiting for the Host Adapter Ready bit to be set in the Status Register.
 */
 
-static int BusLogic_Command(struct BusLogic_HostAdapter *HostAdapter, enum BusLogic_OperationCode OperationCode, void *ParameterData, int ParameterLength, void *ReplyData, int ReplyLength)
+static int blogic_cmd(struct blogic_adapter *adapter, enum blogic_opcode opcode,
+                        void *param, int paramlen, void *reply, int replylen)
 {
-        unsigned char *ParameterPointer = (unsigned char *) ParameterData;
-        unsigned char *ReplyPointer = (unsigned char *) ReplyData;
-        union BusLogic_StatusRegister StatusRegister;
-        union BusLogic_InterruptRegister InterruptRegister;
-        unsigned long ProcessorFlags = 0;
-        int ReplyBytes = 0, Result;
-        long TimeoutCounter;
+        unsigned char *param_p = (unsigned char *) param;
+        unsigned char *reply_p = (unsigned char *) reply;
+        union blogic_stat_reg statusreg;
+        union blogic_int_reg intreg;
+        unsigned long processor_flag = 0;
+        int reply_b = 0, result;
+        long timeout;
         /*
            Clear out the Reply Data if provided.
          */
-        if (ReplyLength > 0)
-                memset(ReplyData, 0, ReplyLength);
+        if (replylen > 0)
+                memset(reply, 0, replylen);
         /*
-           If the IRQ Channel has not yet been acquired, then interrupts must be
-           disabled while issuing host adapter commands since a Command Complete
-           interrupt could occur if the IRQ Channel was previously enabled by another
-           BusLogic Host Adapter or another driver sharing the same IRQ Channel.
+           If the IRQ Channel has not yet been acquired, then interrupts
+           must be disabled while issuing host adapter commands since a
+           Command Complete interrupt could occur if the IRQ Channel was
+           previously enabled by another BusLogic Host Adapter or another
+           driver sharing the same IRQ Channel.
          */
-        if (!HostAdapter->IRQ_ChannelAcquired)
-                local_irq_save(ProcessorFlags);
+        if (!adapter->irq_acquired)
+                local_irq_save(processor_flag);
         /*
-           Wait for the Host Adapter Ready bit to be set and the Command/Parameter
-           Register Busy bit to be reset in the Status Register.
+           Wait for the Host Adapter Ready bit to be set and the
+           Command/Parameter Register Busy bit to be reset in the Status
+           Register.
          */
-        TimeoutCounter = 10000;
-        while (--TimeoutCounter >= 0) {
-                StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
-                if (StatusRegister.sr.HostAdapterReady && !StatusRegister.sr.CommandParameterRegisterBusy)
+        timeout = 10000;
+        while (--timeout >= 0) {
+                statusreg.all = blogic_rdstatus(adapter);
+                if (statusreg.sr.adapter_ready && !statusreg.sr.cmd_param_busy)
                         break;
                 udelay(100);
         }
-        if (TimeoutCounter < 0) {
-                BusLogic_CommandFailureReason = "Timeout waiting for Host Adapter Ready";
-                Result = -2;
-                goto Done;
+        if (timeout < 0) {
+                blogic_cmd_failure_reason =
+                                "Timeout waiting for Host Adapter Ready";
+                result = -2;
+                goto done;
         }
         /*
-           Write the OperationCode to the Command/Parameter Register.
+           Write the opcode to the Command/Parameter Register.
          */
-        HostAdapter->HostAdapterCommandCompleted = false;
-        BusLogic_WriteCommandParameterRegister(HostAdapter, OperationCode);
+        adapter->adapter_cmd_complete = false;
+        blogic_setcmdparam(adapter, opcode);
         /*
            Write any additional Parameter Bytes.
          */
-        TimeoutCounter = 10000;
-        while (ParameterLength > 0 && --TimeoutCounter >= 0) {
+        timeout = 10000;
+        while (paramlen > 0 && --timeout >= 0) {
                 /*
-                   Wait 100 microseconds to give the Host Adapter enough time to determine
-                   whether the last value written to the Command/Parameter Register was
-                   valid or not.  If the Command Complete bit is set in the Interrupt
-                   Register, then the Command Invalid bit in the Status Register will be
-                   reset if the Operation Code or Parameter was valid and the command
-                   has completed, or set if the Operation Code or Parameter was invalid.
-                   If the Data In Register Ready bit is set in the Status Register, then
-                   the Operation Code was valid, and data is waiting to be read back
-                   from the Host Adapter.  Otherwise, wait for the Command/Parameter
-                   Register Busy bit in the Status Register to be reset.
+                   Wait 100 microseconds to give the Host Adapter enough
+                   time to determine whether the last value written to the
+                   Command/Parameter Register was valid or not. If the
+                   Command Complete bit is set in the Interrupt Register,
+                   then the Command Invalid bit in the Status Register will
+                   be reset if the Operation Code or Parameter was valid
+                   and the command has completed, or set if the Operation
+                   Code or Parameter was invalid. If the Data In Register
+                   Ready bit is set in the Status Register, then the
+                   Operation Code was valid, and data is waiting to be read
+                   back from the Host Adapter. Otherwise, wait for the
+                   Command/Parameter Register Busy bit in the Status
+                   Register to be reset.
                  */
                 udelay(100);
-                InterruptRegister.All = BusLogic_ReadInterruptRegister(HostAdapter);
-                StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
-                if (InterruptRegister.ir.CommandComplete)
+                intreg.all = blogic_rdint(adapter);
+                statusreg.all = blogic_rdstatus(adapter);
+                if (intreg.ir.cmd_complete)
                         break;
-                if (HostAdapter->HostAdapterCommandCompleted)
+                if (adapter->adapter_cmd_complete)
                         break;
-                if (StatusRegister.sr.DataInRegisterReady)
+                if (statusreg.sr.datain_ready)
                         break;
-                if (StatusRegister.sr.CommandParameterRegisterBusy)
+                if (statusreg.sr.cmd_param_busy)
                         continue;
-                BusLogic_WriteCommandParameterRegister(HostAdapter, *ParameterPointer++);
-                ParameterLength--;
-        }
-        if (TimeoutCounter < 0) {
-                BusLogic_CommandFailureReason = "Timeout waiting for Parameter Acceptance";
-                Result = -2;
-                goto Done;
-        }
-        /*
-           The Modify I/O Address command does not cause a Command Complete Interrupt.
-         */
-        if (OperationCode == BusLogic_ModifyIOAddress) {
-                StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
-                if (StatusRegister.sr.CommandInvalid) {
-                        BusLogic_CommandFailureReason = "Modify I/O Address Invalid";
-                        Result = -1;
-                        goto Done;
+                blogic_setcmdparam(adapter, *param_p++);
+                paramlen--;
+        }
+        if (timeout < 0) {
+                blogic_cmd_failure_reason =
+                                "Timeout waiting for Parameter Acceptance";
+                result = -2;
+                goto done;
+        }
+        /*
+           The Modify I/O Address command does not cause a Command Complete
+           Interrupt.
+         */
+        if (opcode == BLOGIC_MOD_IOADDR) {
+                statusreg.all = blogic_rdstatus(adapter);
+                if (statusreg.sr.cmd_invalid) {
+                        blogic_cmd_failure_reason =
+                                        "Modify I/O Address Invalid";
+                        result = -1;
+                        goto done;
                 }
-                if (BusLogic_GlobalOptions.TraceConfiguration)
-                        BusLogic_Notice("BusLogic_Command(%02X) Status = %02X: " "(Modify I/O Address)\n", HostAdapter, OperationCode, StatusRegister.All);
-                Result = 0;
-                goto Done;
+                if (blogic_global_options.trace_config)
+                        blogic_notice("blogic_cmd(%02X) Status = %02X: " "(Modify I/O Address)\n", adapter, opcode, statusreg.all);
+                result = 0;
+                goto done;
         }
         /*
            Select an appropriate timeout value for awaiting command completion.
          */
-        switch (OperationCode) {
-        case BusLogic_InquireInstalledDevicesID0to7:
-        case BusLogic_InquireInstalledDevicesID8to15:
-        case BusLogic_InquireTargetDevices:
+        switch (opcode) {
+        case BLOGIC_INQ_DEV0TO7:
+        case BLOGIC_INQ_DEV8TO15:
+        case BLOGIC_INQ_DEV:
                 /* Approximately 60 seconds. */
-                TimeoutCounter = 60 * 10000;
+                timeout = 60 * 10000;
                 break;
         default:
                 /* Approximately 1 second. */
-                TimeoutCounter = 10000;
+                timeout = 10000;
                 break;
         }
         /*
-           Receive any Reply Bytes, waiting for either the Command Complete bit to
-           be set in the Interrupt Register, or for the Interrupt Handler to set the
-           Host Adapter Command Completed bit in the Host Adapter structure.
+           Receive any Reply Bytes, waiting for either the Command
+           Complete bit to be set in the Interrupt Register, or for the
+           Interrupt Handler to set the Host Adapter Command Completed
+           bit in the Host Adapter structure.
          */
-        while (--TimeoutCounter >= 0) {
-                InterruptRegister.All = BusLogic_ReadInterruptRegister(HostAdapter);
-                StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
-                if (InterruptRegister.ir.CommandComplete)
+        while (--timeout >= 0) {
+                intreg.all = blogic_rdint(adapter);
+                statusreg.all = blogic_rdstatus(adapter);
+                if (intreg.ir.cmd_complete)
                         break;
-                if (HostAdapter->HostAdapterCommandCompleted)
+                if (adapter->adapter_cmd_complete)
                         break;
-                if (StatusRegister.sr.DataInRegisterReady) {
-                        if (++ReplyBytes <= ReplyLength)
-                                *ReplyPointer++ = BusLogic_ReadDataInRegister(HostAdapter);
+                if (statusreg.sr.datain_ready) {
+                        if (++reply_b <= replylen)
+                                *reply_p++ = blogic_rddatain(adapter);
                         else
-                                BusLogic_ReadDataInRegister(HostAdapter);
+                                blogic_rddatain(adapter);
                 }
-                if (OperationCode == BusLogic_FetchHostAdapterLocalRAM && StatusRegister.sr.HostAdapterReady)
+                if (opcode == BLOGIC_FETCH_LOCALRAM &&
+                                statusreg.sr.adapter_ready)
                         break;
                 udelay(100);
         }
-        if (TimeoutCounter < 0) {
-                BusLogic_CommandFailureReason = "Timeout waiting for Command Complete";
-                Result = -2;
-                goto Done;
+        if (timeout < 0) {
+                blogic_cmd_failure_reason =
+                                        "Timeout waiting for Command Complete";
+                result = -2;
+                goto done;
         }
         /*
            Clear any pending Command Complete Interrupt.
          */
-        BusLogic_InterruptReset(HostAdapter);
+        blogic_intreset(adapter);
         /*
            Provide tracing information if requested.
          */
-        if (BusLogic_GlobalOptions.TraceConfiguration) {
+        if (blogic_global_options.trace_config) {
                 int i;
-                BusLogic_Notice("BusLogic_Command(%02X) Status = %02X: %2d ==> %2d:", HostAdapter, OperationCode, StatusRegister.All, ReplyLength, ReplyBytes);
-                if (ReplyLength > ReplyBytes)
-                        ReplyLength = ReplyBytes;
-                for (i = 0; i < ReplyLength; i++)
-                        BusLogic_Notice(" %02X", HostAdapter, ((unsigned char *) ReplyData)[i]);
-                BusLogic_Notice("\n", HostAdapter);
+                blogic_notice("blogic_cmd(%02X) Status = %02X: %2d ==> %2d:",
+                                adapter, opcode, statusreg.all, replylen,
+                                reply_b);
+                if (replylen > reply_b)
+                        replylen = reply_b;
+                for (i = 0; i < replylen; i++)
+                        blogic_notice(" %02X", adapter,
+                                        ((unsigned char *) reply)[i]);
+                blogic_notice("\n", adapter);
         }
         /*
            Process Command Invalid conditions.
          */
-        if (StatusRegister.sr.CommandInvalid) {
+        if (statusreg.sr.cmd_invalid) {
                 /*
-                   Some early BusLogic Host Adapters may not recover properly from
-                   a Command Invalid condition, so if this appears to be the case,
-                   a Soft Reset is issued to the Host Adapter.  Potentially invalid
-                   commands are never attempted after Mailbox Initialization is
-                   performed, so there should be no Host Adapter state lost by a
+                   Some early BusLogic Host Adapters may not recover
+                   properly from a Command Invalid condition, so if this
+                   appears to be the case, a Soft Reset is issued to the
+                   Host Adapter.  Potentially invalid commands are never
+                   attempted after Mailbox Initialization is performed,
+                   so there should be no Host Adapter state lost by a
                    Soft Reset in response to a Command Invalid condition.
                  */
                 udelay(1000);
-                StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
-                if (StatusRegister.sr.CommandInvalid ||
-                    StatusRegister.sr.Reserved ||
-                    StatusRegister.sr.DataInRegisterReady ||
-                    StatusRegister.sr.CommandParameterRegisterBusy || !StatusRegister.sr.HostAdapterReady || !StatusRegister.sr.InitializationRequired || StatusRegister.sr.DiagnosticActive || StatusRegister.sr.DiagnosticFailure) {
-                        BusLogic_SoftReset(HostAdapter);
+                statusreg.all = blogic_rdstatus(adapter);
+                if (statusreg.sr.cmd_invalid || statusreg.sr.rsvd ||
+                                statusreg.sr.datain_ready ||
+                                statusreg.sr.cmd_param_busy ||
+                                !statusreg.sr.adapter_ready ||
+                                !statusreg.sr.init_reqd ||
+                                statusreg.sr.diag_active ||
+                                statusreg.sr.diag_failed) {
+                        blogic_softreset(adapter);
                         udelay(1000);
                 }
-                BusLogic_CommandFailureReason = "Command Invalid";
-                Result = -1;
-                goto Done;
+                blogic_cmd_failure_reason = "Command Invalid";
+                result = -1;
+                goto done;
         }
         /*
            Handle Excess Parameters Supplied conditions.
          */
-        if (ParameterLength > 0) {
-                BusLogic_CommandFailureReason = "Excess Parameters Supplied";
-                Result = -1;
-                goto Done;
+        if (paramlen > 0) {
+                blogic_cmd_failure_reason = "Excess Parameters Supplied";
+                result = -1;
+                goto done;
         }
         /*
            Indicate the command completed successfully.
          */
-        BusLogic_CommandFailureReason = NULL;
-        Result = ReplyBytes;
+        blogic_cmd_failure_reason = NULL;
+        result = reply_b;
         /*
            Restore the interrupt status if necessary and return.
          */
-      Done:
-        if (!HostAdapter->IRQ_ChannelAcquired)
-                local_irq_restore(ProcessorFlags);
-        return Result;
+done:
+        if (!adapter->irq_acquired)
+                local_irq_restore(processor_flag);
+        return result;
 }
 
 
 /*
-  BusLogic_AppendProbeAddressISA appends a single ISA I/O Address to the list
+  blogic_add_probeaddr_isa appends a single ISA I/O Address to the list
   of I/O Address and Bus Probe Information to be checked for potential BusLogic
   Host Adapters.
 */
 
-static void __init BusLogic_AppendProbeAddressISA(unsigned long IO_Address)
+static void __init blogic_add_probeaddr_isa(unsigned long io_addr)
 {
-        struct BusLogic_ProbeInfo *ProbeInfo;
-        if (BusLogic_ProbeInfoCount >= BusLogic_MaxHostAdapters)
+        struct blogic_probeinfo *probeinfo;
+        if (blogic_probeinfo_count >= BLOGIC_MAX_ADAPTERS)
                 return;
-        ProbeInfo = &BusLogic_ProbeInfoList[BusLogic_ProbeInfoCount++];
-        ProbeInfo->HostAdapterType = BusLogic_MultiMaster;
-        ProbeInfo->HostAdapterBusType = BusLogic_ISA_Bus;
-        ProbeInfo->IO_Address = IO_Address;
-        ProbeInfo->PCI_Device = NULL;
+        probeinfo = &blogic_probeinfo_list[blogic_probeinfo_count++];
+        probeinfo->adapter_type = BLOGIC_MULTIMASTER;
+        probeinfo->adapter_bus_type = BLOGIC_ISA_BUS;
+        probeinfo->io_addr = io_addr;
+        probeinfo->pci_device = NULL;
 }
 
 
 /*
-  BusLogic_InitializeProbeInfoListISA initializes the list of I/O Address and
+  blogic_init_probeinfo_isa initializes the list of I/O Address and
   Bus Probe Information to be checked for potential BusLogic SCSI Host Adapters
   only from the list of standard BusLogic MultiMaster ISA I/O Addresses.
 */
 
-static void __init BusLogic_InitializeProbeInfoListISA(struct BusLogic_HostAdapter
-                                                       *PrototypeHostAdapter)
+static void __init blogic_init_probeinfo_isa(struct blogic_adapter *adapter)
 {
         /*
-           If BusLogic Driver Options specifications requested that ISA Bus Probes
-           be inhibited, do not proceed further.
+           If BusLogic Driver Options specifications requested that ISA
+           Bus Probes be inhibited, do not proceed further.
          */
-        if (BusLogic_ProbeOptions.NoProbeISA)
+        if (blogic_probe_options.noprobe_isa)
                 return;
         /*
            Append the list of standard BusLogic MultiMaster ISA I/O Addresses.
          */
-        if (!BusLogic_ProbeOptions.LimitedProbeISA || BusLogic_ProbeOptions.Probe330)
-                BusLogic_AppendProbeAddressISA(0x330);
-        if (!BusLogic_ProbeOptions.LimitedProbeISA || BusLogic_ProbeOptions.Probe334)
-                BusLogic_AppendProbeAddressISA(0x334);
-        if (!BusLogic_ProbeOptions.LimitedProbeISA || BusLogic_ProbeOptions.Probe230)
-                BusLogic_AppendProbeAddressISA(0x230);
-        if (!BusLogic_ProbeOptions.LimitedProbeISA || BusLogic_ProbeOptions.Probe234)
-                BusLogic_AppendProbeAddressISA(0x234);
-        if (!BusLogic_ProbeOptions.LimitedProbeISA || BusLogic_ProbeOptions.Probe130)
-                BusLogic_AppendProbeAddressISA(0x130);
-        if (!BusLogic_ProbeOptions.LimitedProbeISA || BusLogic_ProbeOptions.Probe134)
-                BusLogic_AppendProbeAddressISA(0x134);
+        if (!blogic_probe_options.limited_isa || blogic_probe_options.probe330)
+                blogic_add_probeaddr_isa(0x330);
+        if (!blogic_probe_options.limited_isa || blogic_probe_options.probe334)
+                blogic_add_probeaddr_isa(0x334);
+        if (!blogic_probe_options.limited_isa || blogic_probe_options.probe230)
+                blogic_add_probeaddr_isa(0x230);
+        if (!blogic_probe_options.limited_isa || blogic_probe_options.probe234)
+                blogic_add_probeaddr_isa(0x234);
+        if (!blogic_probe_options.limited_isa || blogic_probe_options.probe130)
+                blogic_add_probeaddr_isa(0x130);
+        if (!blogic_probe_options.limited_isa || blogic_probe_options.probe134)
+                blogic_add_probeaddr_isa(0x134);
 }
 
 
@@ -590,25 +619,35 @@ static void __init BusLogic_InitializeProbeInfoListISA(struct BusLogic_HostAdapt
 
 
 /*
-  BusLogic_SortProbeInfo sorts a section of BusLogic_ProbeInfoList in order
+  blogic_sort_probeinfo sorts a section of blogic_probeinfo_list in order
   of increasing PCI Bus and Device Number.
 */
 
-static void __init BusLogic_SortProbeInfo(struct BusLogic_ProbeInfo *ProbeInfoList, int ProbeInfoCount)
+static void __init blogic_sort_probeinfo(struct blogic_probeinfo
+                                        *probeinfo_list, int probeinfo_cnt)
 {
-        int LastInterchange = ProbeInfoCount - 1, Bound, j;
-        while (LastInterchange > 0) {
-                Bound = LastInterchange;
-                LastInterchange = 0;
-                for (j = 0; j < Bound; j++) {
-                        struct BusLogic_ProbeInfo *ProbeInfo1 = &ProbeInfoList[j];
-                        struct BusLogic_ProbeInfo *ProbeInfo2 = &ProbeInfoList[j + 1];
-                        if (ProbeInfo1->Bus > ProbeInfo2->Bus || (ProbeInfo1->Bus == ProbeInfo2->Bus && (ProbeInfo1->Device > ProbeInfo2->Device))) {
-                                struct BusLogic_ProbeInfo TempProbeInfo;
-                                memcpy(&TempProbeInfo, ProbeInfo1, sizeof(struct BusLogic_ProbeInfo));
-                                memcpy(ProbeInfo1, ProbeInfo2, sizeof(struct BusLogic_ProbeInfo));
-                                memcpy(ProbeInfo2, &TempProbeInfo, sizeof(struct BusLogic_ProbeInfo));
-                                LastInterchange = j;
+        int last_exchange = probeinfo_cnt - 1, bound, j;
+
+        while (last_exchange > 0) {
+                bound = last_exchange;
+                last_exchange = 0;
+                for (j = 0; j < bound; j++) {
+                        struct blogic_probeinfo *probeinfo1 =
+                                                        &probeinfo_list[j];
+                        struct blogic_probeinfo *probeinfo2 =
+                                                        &probeinfo_list[j + 1];
+                        if (probeinfo1->bus > probeinfo2->bus ||
+                                (probeinfo1->bus == probeinfo2->bus &&
+                                (probeinfo1->dev > probeinfo2->dev))) {
+                                struct blogic_probeinfo tmp_probeinfo;
+
+                                memcpy(&tmp_probeinfo, probeinfo1,
+                                        sizeof(struct blogic_probeinfo));
+                                memcpy(probeinfo1, probeinfo2,
+                                        sizeof(struct blogic_probeinfo));
+                                memcpy(probeinfo2, &tmp_probeinfo,
+                                        sizeof(struct blogic_probeinfo));
+                                last_exchange = j;
                         }
                 }
         }
@@ -616,84 +655,88 @@ static void __init BusLogic_SortProbeInfo(struct BusLogic_ProbeInfo *ProbeInfoLi
 
 
 /*
-  BusLogic_InitializeMultiMasterProbeInfo initializes the list of I/O Address
+  blogic_init_mm_probeinfo initializes the list of I/O Address
   and Bus Probe Information to be checked for potential BusLogic MultiMaster
   SCSI Host Adapters by interrogating the PCI Configuration Space on PCI
   machines as well as from the list of standard BusLogic MultiMaster ISA
   I/O Addresses.  It returns the number of PCI MultiMaster Host Adapters found.
 */
 
-static int __init BusLogic_InitializeMultiMasterProbeInfo(struct BusLogic_HostAdapter
-                                                          *PrototypeHostAdapter)
+static int __init blogic_init_mm_probeinfo(struct blogic_adapter *adapter)
 {
-        struct BusLogic_ProbeInfo *PrimaryProbeInfo = &BusLogic_ProbeInfoList[BusLogic_ProbeInfoCount];
-        int NonPrimaryPCIMultiMasterIndex = BusLogic_ProbeInfoCount + 1;
-        int NonPrimaryPCIMultiMasterCount = 0, PCIMultiMasterCount = 0;
-        bool ForceBusDeviceScanningOrder = false;
-        bool ForceBusDeviceScanningOrderChecked = false;
-        bool StandardAddressSeen[6];
-        struct pci_dev *PCI_Device = NULL;
+        struct blogic_probeinfo *pr_probeinfo =
+                &blogic_probeinfo_list[blogic_probeinfo_count];
+        int nonpr_mmindex = blogic_probeinfo_count + 1;
+        int nonpr_mmcount = 0, mmcount = 0;
+        bool force_scan_order = false;
+        bool force_scan_order_checked = false;
+        bool addr_seen[6];
+        struct pci_dev *pci_device = NULL;
         int i;
-        if (BusLogic_ProbeInfoCount >= BusLogic_MaxHostAdapters)
+        if (blogic_probeinfo_count >= BLOGIC_MAX_ADAPTERS)
                 return 0;
-        BusLogic_ProbeInfoCount++;
+        blogic_probeinfo_count++;
         for (i = 0; i < 6; i++)
-                StandardAddressSeen[i] = false;
-        /*
-           Iterate over the MultiMaster PCI Host Adapters.  For each enumerated host
-           adapter, determine whether its ISA Compatible I/O Port is enabled and if
-           so, whether it is assigned the Primary I/O Address.  A host adapter that is
-           assigned the Primary I/O Address will always be the preferred boot device.
-           The MultiMaster BIOS will first recognize a host adapter at the Primary I/O
-           Address, then any other PCI host adapters, and finally any host adapters
-           located at the remaining standard ISA I/O Addresses.  When a PCI host
-           adapter is found with its ISA Compatible I/O Port enabled, a command is
-           issued to disable the ISA Compatible I/O Port, and it is noted that the
+                addr_seen[i] = false;
+        /*
+           Iterate over the MultiMaster PCI Host Adapters.  For each
+           enumerated host adapter, determine whether its ISA Compatible
+           I/O Port is enabled and if so, whether it is assigned the
+           Primary I/O Address.  A host adapter that is assigned the
+           Primary I/O Address will always be the preferred boot device.
+           The MultiMaster BIOS will first recognize a host adapter at
+           the Primary I/O Address, then any other PCI host adapters,
+           and finally any host adapters located at the remaining
+           standard ISA I/O Addresses.  When a PCI host adapter is found
+           with its ISA Compatible I/O Port enabled, a command is issued
+           to disable the ISA Compatible I/O Port, and it is noted that the
            particular standard ISA I/O Address need not be probed.
          */
-        PrimaryProbeInfo->IO_Address = 0;
-        while ((PCI_Device = pci_get_device(PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER, PCI_Device)) != NULL) {
-                struct BusLogic_HostAdapter *HostAdapter = PrototypeHostAdapter;
-                struct BusLogic_PCIHostAdapterInformation PCIHostAdapterInformation;
-                enum BusLogic_ISACompatibleIOPort ModifyIOAddressRequest;
-                unsigned char Bus;
-                unsigned char Device;
-                unsigned int IRQ_Channel;
-                unsigned long BaseAddress0;
-                unsigned long BaseAddress1;
-                unsigned long IO_Address;
-                unsigned long PCI_Address;
-
-                if (pci_enable_device(PCI_Device))
+        pr_probeinfo->io_addr = 0;
+        while ((pci_device = pci_get_device(PCI_VENDOR_ID_BUSLOGIC,
+                                        PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER,
+                                        pci_device)) != NULL) {
+                struct blogic_adapter *adapter = adapter;
+                struct blogic_adapter_info adapter_info;
+                enum blogic_isa_ioport mod_ioaddr_req;
+                unsigned char bus;
+                unsigned char device;
+                unsigned int irq_ch;
+                unsigned long base_addr0;
+                unsigned long base_addr1;
+                unsigned long io_addr;
+                unsigned long pci_addr;
+
+                if (pci_enable_device(pci_device))
                         continue;
 
-                if (pci_set_dma_mask(PCI_Device, DMA_BIT_MASK(32) ))
+                if (pci_set_dma_mask(pci_device, DMA_BIT_MASK(32)))
                         continue;
 
-                Bus = PCI_Device->bus->number;
-                Device = PCI_Device->devfn >> 3;
-                IRQ_Channel = PCI_Device->irq;
-                IO_Address = BaseAddress0 = pci_resource_start(PCI_Device, 0);
-                PCI_Address = BaseAddress1 = pci_resource_start(PCI_Device, 1);
+                bus = pci_device->bus->number;
+                device = pci_device->devfn >> 3;
+                irq_ch = pci_device->irq;
+                io_addr = base_addr0 = pci_resource_start(pci_device, 0);
+                pci_addr = base_addr1 = pci_resource_start(pci_device, 1);
 
-                if (pci_resource_flags(PCI_Device, 0) & IORESOURCE_MEM) {
-                        BusLogic_Error("BusLogic: Base Address0 0x%X not I/O for " "MultiMaster Host Adapter\n", NULL, BaseAddress0);
-                        BusLogic_Error("at PCI Bus %d Device %d I/O Address 0x%X\n", NULL, Bus, Device, IO_Address);
+                if (pci_resource_flags(pci_device, 0) & IORESOURCE_MEM) {
+                        blogic_err("BusLogic: Base Address0 0x%X not I/O for " "MultiMaster Host Adapter\n", NULL, base_addr0);
+                        blogic_err("at PCI Bus %d Device %d I/O Address 0x%X\n", NULL, bus, device, io_addr);
                         continue;
                 }
-                if (pci_resource_flags(PCI_Device, 1) & IORESOURCE_IO) {
-                        BusLogic_Error("BusLogic: Base Address1 0x%X not Memory for " "MultiMaster Host Adapter\n", NULL, BaseAddress1);
-                        BusLogic_Error("at PCI Bus %d Device %d PCI Address 0x%X\n", NULL, Bus, Device, PCI_Address);
+                if (pci_resource_flags(pci_device, 1) & IORESOURCE_IO) {
+                        blogic_err("BusLogic: Base Address1 0x%X not Memory for " "MultiMaster Host Adapter\n", NULL, base_addr1);
+                        blogic_err("at PCI Bus %d Device %d PCI Address 0x%X\n", NULL, bus, device, pci_addr);
                         continue;
                 }
-                if (IRQ_Channel == 0) {
-                        BusLogic_Error("BusLogic: IRQ Channel %d invalid for " "MultiMaster Host Adapter\n", NULL, IRQ_Channel);
-                        BusLogic_Error("at PCI Bus %d Device %d I/O Address 0x%X\n", NULL, Bus, Device, IO_Address);
+                if (irq_ch == 0) {
+                        blogic_err("BusLogic: IRQ Channel %d invalid for " "MultiMaster Host Adapter\n", NULL, irq_ch);
+                        blogic_err("at PCI Bus %d Device %d I/O Address 0x%X\n", NULL, bus, device, io_addr);
                         continue;
                 }
-                if (BusLogic_GlobalOptions.TraceProbe) {
-                        BusLogic_Notice("BusLogic: PCI MultiMaster Host Adapter " "detected at\n", NULL);
-                        BusLogic_Notice("BusLogic: PCI Bus %d Device %d I/O Address " "0x%X PCI Address 0x%X\n", NULL, Bus, Device, IO_Address, PCI_Address);
+                if (blogic_global_options.trace_probe) {
+                        blogic_notice("BusLogic: PCI MultiMaster Host Adapter " "detected at\n", NULL);
+                        blogic_notice("BusLogic: PCI Bus %d Device %d I/O Address " "0x%X PCI Address 0x%X\n", NULL, bus, device, io_addr, pci_addr);
                 }
                 /*
                    Issue the Inquire PCI Host Adapter Information command to determine
@@ -701,238 +744,258 @@ static int __init BusLogic_InitializeMultiMasterProbeInfo(struct BusLogic_HostAd
                    known and enabled, note that the particular Standard ISA I/O
                    Address should not be probed.
                  */
-                HostAdapter->IO_Address = IO_Address;
-                BusLogic_InterruptReset(HostAdapter);
-                if (BusLogic_Command(HostAdapter, BusLogic_InquirePCIHostAdapterInformation, NULL, 0, &PCIHostAdapterInformation, sizeof(PCIHostAdapterInformation))
-                    == sizeof(PCIHostAdapterInformation)) {
-                        if (PCIHostAdapterInformation.ISACompatibleIOPort < 6)
-                                StandardAddressSeen[PCIHostAdapterInformation.ISACompatibleIOPort] = true;
+                adapter->io_addr = io_addr;
+                blogic_intreset(adapter);
+                if (blogic_cmd(adapter, BLOGIC_INQ_PCI_INFO, NULL, 0,
+                                &adapter_info, sizeof(adapter_info)) ==
+                                sizeof(adapter_info)) {
+                        if (adapter_info.isa_port < 6)
+                                addr_seen[adapter_info.isa_port] = true;
                 } else
-                        PCIHostAdapterInformation.ISACompatibleIOPort = BusLogic_IO_Disable;
+                        adapter_info.isa_port = BLOGIC_IO_DISABLE;
                 /*
-                 * Issue the Modify I/O Address command to disable the ISA Compatible
-                 * I/O Port.  On PCI Host Adapters, the Modify I/O Address command
-                 * allows modification of the ISA compatible I/O Address that the Host
-                 * Adapter responds to; it does not affect the PCI compliant I/O Address
-                 * assigned at system initialization.
+                   Issue the Modify I/O Address command to disable the
+                   ISA Compatible I/O Port. On PCI Host Adapters, the
+                   Modify I/O Address command allows modification of the
+                   ISA compatible I/O Address that the Host Adapter
+                   responds to; it does not affect the PCI compliant
+                   I/O Address assigned at system initialization.
                  */
-                ModifyIOAddressRequest = BusLogic_IO_Disable;
-                BusLogic_Command(HostAdapter, BusLogic_ModifyIOAddress, &ModifyIOAddressRequest, sizeof(ModifyIOAddressRequest), NULL, 0);
+                mod_ioaddr_req = BLOGIC_IO_DISABLE;
+                blogic_cmd(adapter, BLOGIC_MOD_IOADDR, &mod_ioaddr_req,
+                                sizeof(mod_ioaddr_req), NULL, 0);
                 /*
-                   For the first MultiMaster Host Adapter enumerated, issue the Fetch
-                   Host Adapter Local RAM command to read byte 45 of the AutoSCSI area,
-                   for the setting of the "Use Bus And Device # For PCI Scanning Seq."
-                   option.  Issue the Inquire Board ID command since this option is
+                   For the first MultiMaster Host Adapter enumerated,
+                   issue the Fetch Host Adapter Local RAM command to read
+                   byte 45 of the AutoSCSI area, for the setting of the
+                   "Use Bus And Device # For PCI Scanning Seq." option.
+                   Issue the Inquire Board ID command since this option is
                    only valid for the BT-948/958/958D.
                  */
-                if (!ForceBusDeviceScanningOrderChecked) {
-                        struct BusLogic_FetchHostAdapterLocalRAMRequest FetchHostAdapterLocalRAMRequest;
-                        struct BusLogic_AutoSCSIByte45 AutoSCSIByte45;
-                        struct BusLogic_BoardID BoardID;
-                        FetchHostAdapterLocalRAMRequest.ByteOffset = BusLogic_AutoSCSI_BaseOffset + 45;
-                        FetchHostAdapterLocalRAMRequest.ByteCount = sizeof(AutoSCSIByte45);
-                        BusLogic_Command(HostAdapter, BusLogic_FetchHostAdapterLocalRAM, &FetchHostAdapterLocalRAMRequest, sizeof(FetchHostAdapterLocalRAMRequest), &AutoSCSIByte45, sizeof(AutoSCSIByte45));
-                        BusLogic_Command(HostAdapter, BusLogic_InquireBoardID, NULL, 0, &BoardID, sizeof(BoardID));
-                        if (BoardID.FirmwareVersion1stDigit == '5')
-                                ForceBusDeviceScanningOrder = AutoSCSIByte45.ForceBusDeviceScanningOrder;
-                        ForceBusDeviceScanningOrderChecked = true;
+                if (!force_scan_order_checked) {
+                        struct blogic_fetch_localram fetch_localram;
+                        struct blogic_autoscsi_byte45 autoscsi_byte45;
+                        struct blogic_board_id id;
+
+                        fetch_localram.offset = BLOGIC_AUTOSCSI_BASE + 45;
+                        fetch_localram.count = sizeof(autoscsi_byte45);
+                        blogic_cmd(adapter, BLOGIC_FETCH_LOCALRAM,
+                                        &fetch_localram, sizeof(fetch_localram),
+                                        &autoscsi_byte45,
+                                        sizeof(autoscsi_byte45));
+                        blogic_cmd(adapter, BLOGIC_GET_BOARD_ID, NULL, 0, &id,
+                                        sizeof(id));
+                        if (id.fw_ver_digit1 == '5')
+                                force_scan_order =
+                                        autoscsi_byte45.force_scan_order;
+                        force_scan_order_checked = true;
                 }
                 /*
-                   Determine whether this MultiMaster Host Adapter has its ISA
-                   Compatible I/O Port enabled and is assigned the Primary I/O Address.
-                   If it does, then it is the Primary MultiMaster Host Adapter and must
-                   be recognized first.  If it does not, then it is added to the list
-                   for probing after any Primary MultiMaster Host Adapter is probed.
+                   Determine whether this MultiMaster Host Adapter has its
+                   ISA Compatible I/O Port enabled and is assigned the
+                   Primary I/O Address. If it does, then it is the Primary
+                   MultiMaster Host Adapter and must be recognized first.
+                   If it does not, then it is added to the list for probing
+                   after any Primary MultiMaster Host Adapter is probed.
                  */
-                if (PCIHostAdapterInformation.ISACompatibleIOPort == BusLogic_IO_330) {
-                        PrimaryProbeInfo->HostAdapterType = BusLogic_MultiMaster;
-                        PrimaryProbeInfo->HostAdapterBusType = BusLogic_PCI_Bus;
-                        PrimaryProbeInfo->IO_Address = IO_Address;
-                        PrimaryProbeInfo->PCI_Address = PCI_Address;
-                        PrimaryProbeInfo->Bus = Bus;
-                        PrimaryProbeInfo->Device = Device;
-                        PrimaryProbeInfo->IRQ_Channel = IRQ_Channel;
-                        PrimaryProbeInfo->PCI_Device = pci_dev_get(PCI_Device);
-                        PCIMultiMasterCount++;
-                } else if (BusLogic_ProbeInfoCount < BusLogic_MaxHostAdapters) {
-                        struct BusLogic_ProbeInfo *ProbeInfo = &BusLogic_ProbeInfoList[BusLogic_ProbeInfoCount++];
-                        ProbeInfo->HostAdapterType = BusLogic_MultiMaster;
-                        ProbeInfo->HostAdapterBusType = BusLogic_PCI_Bus;
-                        ProbeInfo->IO_Address = IO_Address;
-                        ProbeInfo->PCI_Address = PCI_Address;
-                        ProbeInfo->Bus = Bus;
-                        ProbeInfo->Device = Device;
-                        ProbeInfo->IRQ_Channel = IRQ_Channel;
-                        ProbeInfo->PCI_Device = pci_dev_get(PCI_Device);
-                        NonPrimaryPCIMultiMasterCount++;
-                        PCIMultiMasterCount++;
+                if (adapter_info.isa_port == BLOGIC_IO_330) {
+                        pr_probeinfo->adapter_type = BLOGIC_MULTIMASTER;
+                        pr_probeinfo->adapter_bus_type = BLOGIC_PCI_BUS;
+                        pr_probeinfo->io_addr = io_addr;
+                        pr_probeinfo->pci_addr = pci_addr;
+                        pr_probeinfo->bus = bus;
+                        pr_probeinfo->dev = device;
+                        pr_probeinfo->irq_ch = irq_ch;
+                        pr_probeinfo->pci_device = pci_dev_get(pci_device);
+                        mmcount++;
+                } else if (blogic_probeinfo_count < BLOGIC_MAX_ADAPTERS) {
+                        struct blogic_probeinfo *probeinfo =
+                                &blogic_probeinfo_list[blogic_probeinfo_count++];
+                        probeinfo->adapter_type = BLOGIC_MULTIMASTER;
+                        probeinfo->adapter_bus_type = BLOGIC_PCI_BUS;
+                        probeinfo->io_addr = io_addr;
+                        probeinfo->pci_addr = pci_addr;
+                        probeinfo->bus = bus;
+                        probeinfo->dev = device;
+                        probeinfo->irq_ch = irq_ch;
+                        probeinfo->pci_device = pci_dev_get(pci_device);
+                        nonpr_mmcount++;
+                        mmcount++;
                 } else
-                        BusLogic_Warning("BusLogic: Too many Host Adapters " "detected\n", NULL);
-        }
-        /*
-           If the AutoSCSI "Use Bus And Device # For PCI Scanning Seq." option is ON
-           for the first enumerated MultiMaster Host Adapter, and if that host adapter
-           is a BT-948/958/958D, then the MultiMaster BIOS will recognize MultiMaster
-           Host Adapters in the order of increasing PCI Bus and Device Number.  In
-           that case, sort the probe information into the same order the BIOS uses.
-           If this option is OFF, then the MultiMaster BIOS will recognize MultiMaster
-           Host Adapters in the order they are enumerated by the PCI BIOS, and hence
-           no sorting is necessary.
-         */
-        if (ForceBusDeviceScanningOrder)
-                BusLogic_SortProbeInfo(&BusLogic_ProbeInfoList[NonPrimaryPCIMultiMasterIndex], NonPrimaryPCIMultiMasterCount);
-        /*
-           If no PCI MultiMaster Host Adapter is assigned the Primary I/O Address,
-           then the Primary I/O Address must be probed explicitly before any PCI
-           host adapters are probed.
-         */
-        if (!BusLogic_ProbeOptions.NoProbeISA)
-                if (PrimaryProbeInfo->IO_Address == 0 &&
-                                (!BusLogic_ProbeOptions.LimitedProbeISA ||
-                                 BusLogic_ProbeOptions.Probe330)) {
-                        PrimaryProbeInfo->HostAdapterType = BusLogic_MultiMaster;
-                        PrimaryProbeInfo->HostAdapterBusType = BusLogic_ISA_Bus;
-                        PrimaryProbeInfo->IO_Address = 0x330;
+                        blogic_warn("BusLogic: Too many Host Adapters " "detected\n", NULL);
+        }
+        /*
+           If the AutoSCSI "Use Bus And Device # For PCI Scanning Seq."
+           option is ON for the first enumerated MultiMaster Host Adapter,
+           and if that host adapter is a BT-948/958/958D, then the
+           MultiMaster BIOS will recognize MultiMaster Host Adapters in
+           the order of increasing PCI Bus and Device Number. In that case,
+           sort the probe information into the same order the BIOS uses.
+           If this option is OFF, then the MultiMaster BIOS will recognize
+           MultiMaster Host Adapters in the order they are enumerated by
+           the PCI BIOS, and hence no sorting is necessary.
+         */
+        if (force_scan_order)
+                blogic_sort_probeinfo(&blogic_probeinfo_list[nonpr_mmindex],
+                                        nonpr_mmcount);
+        /*
+           If no PCI MultiMaster Host Adapter is assigned the Primary
+           I/O Address, then the Primary I/O Address must be probed
+           explicitly before any PCI host adapters are probed.
+         */
+        if (!blogic_probe_options.noprobe_isa)
+                if (pr_probeinfo->io_addr == 0 &&
+                                (!blogic_probe_options.limited_isa ||
+                                 blogic_probe_options.probe330)) {
+                        pr_probeinfo->adapter_type = BLOGIC_MULTIMASTER;
+                        pr_probeinfo->adapter_bus_type = BLOGIC_ISA_BUS;
+                        pr_probeinfo->io_addr = 0x330;
                 }
         /*
            Append the list of standard BusLogic MultiMaster ISA I/O Addresses,
            omitting the Primary I/O Address which has already been handled.
          */
-        if (!BusLogic_ProbeOptions.NoProbeISA) {
-                if (!StandardAddressSeen[1] &&
-                                (!BusLogic_ProbeOptions.LimitedProbeISA ||
-                                 BusLogic_ProbeOptions.Probe334))
-                        BusLogic_AppendProbeAddressISA(0x334);
-                if (!StandardAddressSeen[2] &&
-                                (!BusLogic_ProbeOptions.LimitedProbeISA ||
-                                 BusLogic_ProbeOptions.Probe230))
-                        BusLogic_AppendProbeAddressISA(0x230);
-                if (!StandardAddressSeen[3] &&
-                                (!BusLogic_ProbeOptions.LimitedProbeISA ||
-                                 BusLogic_ProbeOptions.Probe234))
-                        BusLogic_AppendProbeAddressISA(0x234);
-                if (!StandardAddressSeen[4] &&
-                                (!BusLogic_ProbeOptions.LimitedProbeISA ||
-                                 BusLogic_ProbeOptions.Probe130))
-                        BusLogic_AppendProbeAddressISA(0x130);
-                if (!StandardAddressSeen[5] &&
-                                (!BusLogic_ProbeOptions.LimitedProbeISA ||
-                                 BusLogic_ProbeOptions.Probe134))
-                        BusLogic_AppendProbeAddressISA(0x134);
+        if (!blogic_probe_options.noprobe_isa) {
+                if (!addr_seen[1] &&
+                                (!blogic_probe_options.limited_isa ||
+                                 blogic_probe_options.probe334))
+                        blogic_add_probeaddr_isa(0x334);
+                if (!addr_seen[2] &&
+                                (!blogic_probe_options.limited_isa ||
+                                 blogic_probe_options.probe230))
+                        blogic_add_probeaddr_isa(0x230);
+                if (!addr_seen[3] &&
+                                (!blogic_probe_options.limited_isa ||
+                                 blogic_probe_options.probe234))
+                        blogic_add_probeaddr_isa(0x234);
+                if (!addr_seen[4] &&
+                                (!blogic_probe_options.limited_isa ||
+                                 blogic_probe_options.probe130))
+                        blogic_add_probeaddr_isa(0x130);
+                if (!addr_seen[5] &&
+                                (!blogic_probe_options.limited_isa ||
+                                 blogic_probe_options.probe134))
+                        blogic_add_probeaddr_isa(0x134);
         }
         /*
            Iterate over the older non-compliant MultiMaster PCI Host Adapters,
            noting the PCI bus location and assigned IRQ Channel.
          */
-        PCI_Device = NULL;
-        while ((PCI_Device = pci_get_device(PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER_NC, PCI_Device)) != NULL) {
-                unsigned char Bus;
-                unsigned char Device;
-                unsigned int IRQ_Channel;
-                unsigned long IO_Address;
+        pci_device = NULL;
+        while ((pci_device = pci_get_device(PCI_VENDOR_ID_BUSLOGIC,
+                                        PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER_NC,
+                                        pci_device)) != NULL) {
+                unsigned char bus;
+                unsigned char device;
+                unsigned int irq_ch;
+                unsigned long io_addr;
 
-                if (pci_enable_device(PCI_Device))
+                if (pci_enable_device(pci_device))
                         continue;
 
-                if (pci_set_dma_mask(PCI_Device, DMA_BIT_MASK(32)))
+                if (pci_set_dma_mask(pci_device, DMA_BIT_MASK(32)))
                         continue;
 
-                Bus = PCI_Device->bus->number;
-                Device = PCI_Device->devfn >> 3;
-                IRQ_Channel = PCI_Device->irq;
-                IO_Address = pci_resource_start(PCI_Device, 0);
+                bus = pci_device->bus->number;
+                device = pci_device->devfn >> 3;
+                irq_ch = pci_device->irq;
+                io_addr = pci_resource_start(pci_device, 0);
 
-                if (IO_Address == 0 || IRQ_Channel == 0)
+                if (io_addr == 0 || irq_ch == 0)
                         continue;
-                for (i = 0; i < BusLogic_ProbeInfoCount; i++) {
-                        struct BusLogic_ProbeInfo *ProbeInfo = &BusLogic_ProbeInfoList[i];
-                        if (ProbeInfo->IO_Address == IO_Address && ProbeInfo->HostAdapterType == BusLogic_MultiMaster) {
-                                ProbeInfo->HostAdapterBusType = BusLogic_PCI_Bus;
-                                ProbeInfo->PCI_Address = 0;
-                                ProbeInfo->Bus = Bus;
-                                ProbeInfo->Device = Device;
-                                ProbeInfo->IRQ_Channel = IRQ_Channel;
-                                ProbeInfo->PCI_Device = pci_dev_get(PCI_Device);
+                for (i = 0; i < blogic_probeinfo_count; i++) {
+                        struct blogic_probeinfo *probeinfo =
+                                                &blogic_probeinfo_list[i];
+                        if (probeinfo->io_addr == io_addr &&
+                                probeinfo->adapter_type == BLOGIC_MULTIMASTER) {
+                                probeinfo->adapter_bus_type = BLOGIC_PCI_BUS;
+                                probeinfo->pci_addr = 0;
+                                probeinfo->bus = bus;
+                                probeinfo->dev = device;
+                                probeinfo->irq_ch = irq_ch;
+                                probeinfo->pci_device = pci_dev_get(pci_device);
                                 break;
                         }
                 }
         }
-        return PCIMultiMasterCount;
+        return mmcount;
 }
 
 
 /*
-  BusLogic_InitializeFlashPointProbeInfo initializes the list of I/O Address
+  blogic_init_fp_probeinfo initializes the list of I/O Address
   and Bus Probe Information to be checked for potential BusLogic FlashPoint
   Host Adapters by interrogating the PCI Configuration Space.  It returns the
   number of FlashPoint Host Adapters found.
 */
 
-static int __init BusLogic_InitializeFlashPointProbeInfo(struct BusLogic_HostAdapter
-                                                         *PrototypeHostAdapter)
+static int __init blogic_init_fp_probeinfo(struct blogic_adapter *adapter)
 {
-        int FlashPointIndex = BusLogic_ProbeInfoCount, FlashPointCount = 0;
-        struct pci_dev *PCI_Device = NULL;
+        int fpindex = blogic_probeinfo_count, fpcount = 0;
+        struct pci_dev *pci_device = NULL;
         /*
            Interrogate PCI Configuration Space for any FlashPoint Host Adapters.
          */
-        while ((PCI_Device = pci_get_device(PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_FLASHPOINT, PCI_Device)) != NULL) {
-                unsigned char Bus;
-                unsigned char Device;
-                unsigned int IRQ_Channel;
-                unsigned long BaseAddress0;
-                unsigned long BaseAddress1;
-                unsigned long IO_Address;
-                unsigned long PCI_Address;
-
-                if (pci_enable_device(PCI_Device))
+        while ((pci_device = pci_get_device(PCI_VENDOR_ID_BUSLOGIC,
+                                        PCI_DEVICE_ID_BUSLOGIC_FLASHPOINT,
+                                        pci_device)) != NULL) {
+                unsigned char bus;
+                unsigned char device;
+                unsigned int irq_ch;
+                unsigned long base_addr0;
+                unsigned long base_addr1;
+                unsigned long io_addr;
+                unsigned long pci_addr;
+
+                if (pci_enable_device(pci_device))
                         continue;
 
-                if (pci_set_dma_mask(PCI_Device, DMA_BIT_MASK(32)))
+                if (pci_set_dma_mask(pci_device, DMA_BIT_MASK(32)))
                         continue;
 
-                Bus = PCI_Device->bus->number;
-                Device = PCI_Device->devfn >> 3;
-                IRQ_Channel = PCI_Device->irq;
-                IO_Address = BaseAddress0 = pci_resource_start(PCI_Device, 0);
-                PCI_Address = BaseAddress1 = pci_resource_start(PCI_Device, 1);
+                bus = pci_device->bus->number;
+                device = pci_device->devfn >> 3;
+                irq_ch = pci_device->irq;
+                io_addr = base_addr0 = pci_resource_start(pci_device, 0);
+                pci_addr = base_addr1 = pci_resource_start(pci_device, 1);
 #ifdef CONFIG_SCSI_FLASHPOINT
-                if (pci_resource_flags(PCI_Device, 0) & IORESOURCE_MEM) {
-                        BusLogic_Error("BusLogic: Base Address0 0x%X not I/O for " "FlashPoint Host Adapter\n", NULL, BaseAddress0);
-                        BusLogic_Error("at PCI Bus %d Device %d I/O Address 0x%X\n", NULL, Bus, Device, IO_Address);
+                if (pci_resource_flags(pci_device, 0) & IORESOURCE_MEM) {
+                        blogic_err("BusLogic: Base Address0 0x%X not I/O for " "FlashPoint Host Adapter\n", NULL, base_addr0);
+                        blogic_err("at PCI Bus %d Device %d I/O Address 0x%X\n", NULL, bus, device, io_addr);
                         continue;
                 }
-                if (pci_resource_flags(PCI_Device, 1) & IORESOURCE_IO) {
-                        BusLogic_Error("BusLogic: Base Address1 0x%X not Memory for " "FlashPoint Host Adapter\n", NULL, BaseAddress1);
-                        BusLogic_Error("at PCI Bus %d Device %d PCI Address 0x%X\n", NULL, Bus, Device, PCI_Address);
+                if (pci_resource_flags(pci_device, 1) & IORESOURCE_IO) {
+                        blogic_err("BusLogic: Base Address1 0x%X not Memory for " "FlashPoint Host Adapter\n", NULL, base_addr1);
+                        blogic_err("at PCI Bus %d Device %d PCI Address 0x%X\n", NULL, bus, device, pci_addr);
                         continue;
                 }
-                if (IRQ_Channel == 0) {
-                        BusLogic_Error("BusLogic: IRQ Channel %d invalid for " "FlashPoint Host Adapter\n", NULL, IRQ_Channel);
-                        BusLogic_Error("at PCI Bus %d Device %d I/O Address 0x%X\n", NULL, Bus, Device, IO_Address);
+                if (irq_ch == 0) {
+                        blogic_err("BusLogic: IRQ Channel %d invalid for " "FlashPoint Host Adapter\n", NULL, irq_ch);
+                        blogic_err("at PCI Bus %d Device %d I/O Address 0x%X\n", NULL, bus, device, io_addr);
                         continue;
                 }
-                if (BusLogic_GlobalOptions.TraceProbe) {
-                        BusLogic_Notice("BusLogic: FlashPoint Host Adapter " "detected at\n", NULL);
-                        BusLogic_Notice("BusLogic: PCI Bus %d Device %d I/O Address " "0x%X PCI Address 0x%X\n", NULL, Bus, Device, IO_Address, PCI_Address);
+                if (blogic_global_options.trace_probe) {
+                        blogic_notice("BusLogic: FlashPoint Host Adapter " "detected at\n", NULL);
+                        blogic_notice("BusLogic: PCI Bus %d Device %d I/O Address " "0x%X PCI Address 0x%X\n", NULL, bus, device, io_addr, pci_addr);
                 }
-                if (BusLogic_ProbeInfoCount < BusLogic_MaxHostAdapters) {
-                        struct BusLogic_ProbeInfo *ProbeInfo = &BusLogic_ProbeInfoList[BusLogic_ProbeInfoCount++];
-                        ProbeInfo->HostAdapterType = BusLogic_FlashPoint;
-                        ProbeInfo->HostAdapterBusType = BusLogic_PCI_Bus;
-                        ProbeInfo->IO_Address = IO_Address;
-                        ProbeInfo->PCI_Address = PCI_Address;
-                        ProbeInfo->Bus = Bus;
-                        ProbeInfo->Device = Device;
-                        ProbeInfo->IRQ_Channel = IRQ_Channel;
-                        ProbeInfo->PCI_Device = pci_dev_get(PCI_Device);
-                        FlashPointCount++;
+                if (blogic_probeinfo_count < BLOGIC_MAX_ADAPTERS) {
+                        struct blogic_probeinfo *probeinfo =
+                                &blogic_probeinfo_list[blogic_probeinfo_count++];
+                        probeinfo->adapter_type = BLOGIC_FLASHPOINT;
+                        probeinfo->adapter_bus_type = BLOGIC_PCI_BUS;
+                        probeinfo->io_addr = io_addr;
+                        probeinfo->pci_addr = pci_addr;
+                        probeinfo->bus = bus;
+                        probeinfo->dev = device;
+                        probeinfo->irq_ch = irq_ch;
+                        probeinfo->pci_device = pci_dev_get(pci_device);
+                        fpcount++;
                 } else
-                        BusLogic_Warning("BusLogic: Too many Host Adapters " "detected\n", NULL);
+                        blogic_warn("BusLogic: Too many Host Adapters " "detected\n", NULL);
 #else
-                BusLogic_Error("BusLogic: FlashPoint Host Adapter detected at " "PCI Bus %d Device %d\n", NULL, Bus, Device);
-                BusLogic_Error("BusLogic: I/O Address 0x%X PCI Address 0x%X, irq %d, " "but FlashPoint\n", NULL, IO_Address, PCI_Address, IRQ_Channel);
-                BusLogic_Error("BusLogic: support was omitted in this kernel " "configuration.\n", NULL);
+                blogic_err("BusLogic: FlashPoint Host Adapter detected at " "PCI Bus %d Device %d\n", NULL, bus, device);
+                blogic_err("BusLogic: I/O Address 0x%X PCI Address 0x%X, irq %d, " "but FlashPoint\n", NULL, io_addr, pci_addr, irq_ch);
+                blogic_err("BusLogic: support was omitted in this kernel " "configuration.\n", NULL);
 #endif
         }
         /*
@@ -940,13 +1003,13 @@ static int __init BusLogic_InitializeFlashPointProbeInfo(struct BusLogic_HostAda
            increasing PCI Bus and Device Number, so sort the probe information into
            the same order the BIOS uses.
          */
-        BusLogic_SortProbeInfo(&BusLogic_ProbeInfoList[FlashPointIndex], FlashPointCount);
-        return FlashPointCount;
+        blogic_sort_probeinfo(&blogic_probeinfo_list[fpindex], fpcount);
+        return fpcount;
 }
 
 
 /*
-  BusLogic_InitializeProbeInfoList initializes the list of I/O Address and Bus
+  blogic_init_probeinfo_list initializes the list of I/O Address and Bus
   Probe Information to be checked for potential BusLogic SCSI Host Adapters by
   interrogating the PCI Configuration Space on PCI machines as well as from the
   list of standard BusLogic MultiMaster ISA I/O Addresses.  By default, if both
@@ -958,104 +1021,125 @@ static int __init BusLogic_InitializeFlashPointProbeInfo(struct BusLogic_HostAda
   a particular probe order.
 */
 
-static void __init BusLogic_InitializeProbeInfoList(struct BusLogic_HostAdapter
-                                                    *PrototypeHostAdapter)
+static void __init blogic_init_probeinfo_list(struct blogic_adapter *adapter)
 {
         /*
-           If a PCI BIOS is present, interrogate it for MultiMaster and FlashPoint
-           Host Adapters; otherwise, default to the standard ISA MultiMaster probe.
-         */
-        if (!BusLogic_ProbeOptions.NoProbePCI) {
-                if (BusLogic_ProbeOptions.MultiMasterFirst) {
-                        BusLogic_InitializeMultiMasterProbeInfo(PrototypeHostAdapter);
-                        BusLogic_InitializeFlashPointProbeInfo(PrototypeHostAdapter);
-                } else if (BusLogic_ProbeOptions.FlashPointFirst) {
-                        BusLogic_InitializeFlashPointProbeInfo(PrototypeHostAdapter);
-                        BusLogic_InitializeMultiMasterProbeInfo(PrototypeHostAdapter);
+           If a PCI BIOS is present, interrogate it for MultiMaster and
+           FlashPoint Host Adapters; otherwise, default to the standard
+           ISA MultiMaster probe.
+         */
+        if (!blogic_probe_options.noprobe_pci) {
+                if (blogic_probe_options.multimaster_first) {
+                        blogic_init_mm_probeinfo(adapter);
+                        blogic_init_fp_probeinfo(adapter);
+                } else if (blogic_probe_options.flashpoint_first) {
+                        blogic_init_fp_probeinfo(adapter);
+                        blogic_init_mm_probeinfo(adapter);
                 } else {
-                        int FlashPointCount = BusLogic_InitializeFlashPointProbeInfo(PrototypeHostAdapter);
-                        int PCIMultiMasterCount = BusLogic_InitializeMultiMasterProbeInfo(PrototypeHostAdapter);
-                        if (FlashPointCount > 0 && PCIMultiMasterCount > 0) {
-                                struct BusLogic_ProbeInfo *ProbeInfo = &BusLogic_ProbeInfoList[FlashPointCount];
-                                struct BusLogic_HostAdapter *HostAdapter = PrototypeHostAdapter;
-                                struct BusLogic_FetchHostAdapterLocalRAMRequest FetchHostAdapterLocalRAMRequest;
-                                struct BusLogic_BIOSDriveMapByte Drive0MapByte;
-                                while (ProbeInfo->HostAdapterBusType != BusLogic_PCI_Bus)
-                                        ProbeInfo++;
-                                HostAdapter->IO_Address = ProbeInfo->IO_Address;
-                                FetchHostAdapterLocalRAMRequest.ByteOffset = BusLogic_BIOS_BaseOffset + BusLogic_BIOS_DriveMapOffset + 0;
-                                FetchHostAdapterLocalRAMRequest.ByteCount = sizeof(Drive0MapByte);
-                                BusLogic_Command(HostAdapter, BusLogic_FetchHostAdapterLocalRAM, &FetchHostAdapterLocalRAMRequest, sizeof(FetchHostAdapterLocalRAMRequest), &Drive0MapByte, sizeof(Drive0MapByte));
+                        int fpcount = blogic_init_fp_probeinfo(adapter);
+                        int mmcount = blogic_init_mm_probeinfo(adapter);
+                        if (fpcount > 0 && mmcount > 0) {
+                                struct blogic_probeinfo *probeinfo =
+                                        &blogic_probeinfo_list[fpcount];
+                                struct blogic_adapter *myadapter = adapter;
+                                struct blogic_fetch_localram fetch_localram;
+                                struct blogic_bios_drvmap d0_mapbyte;
+
+                                while (probeinfo->adapter_bus_type !=
+                                                BLOGIC_PCI_BUS)
+                                        probeinfo++;
+                                myadapter->io_addr = probeinfo->io_addr;
+                                fetch_localram.offset =
+                                        BLOGIC_BIOS_BASE + BLOGIC_BIOS_DRVMAP;
+                                fetch_localram.count = sizeof(d0_mapbyte);
+                                blogic_cmd(myadapter, BLOGIC_FETCH_LOCALRAM,
+                                                &fetch_localram,
+                                                sizeof(fetch_localram),
+                                                &d0_mapbyte,
+                                                sizeof(d0_mapbyte));
                                 /*
-                                   If the Map Byte for BIOS Drive 0 indicates that BIOS Drive 0
-                                   is controlled by this PCI MultiMaster Host Adapter, then
-                                   reverse the probe order so that MultiMaster Host Adapters are
-                                   probed before FlashPoint Host Adapters.
+                                   If the Map Byte for BIOS Drive 0 indicates
+                                   that BIOS Drive 0 is controlled by this
+                                   PCI MultiMaster Host Adapter, then reverse
+                                   the probe order so that MultiMaster Host
+                                   Adapters are probed before FlashPoint Host
+                                   Adapters.
                                  */
-                                if (Drive0MapByte.DiskGeometry != BusLogic_BIOS_Disk_Not_Installed) {
-                                        struct BusLogic_ProbeInfo SavedProbeInfo[BusLogic_MaxHostAdapters];
-                                        int MultiMasterCount = BusLogic_ProbeInfoCount - FlashPointCount;
-                                        memcpy(SavedProbeInfo, BusLogic_ProbeInfoList, BusLogic_ProbeInfoCount * sizeof(struct BusLogic_ProbeInfo));
-                                        memcpy(&BusLogic_ProbeInfoList[0], &SavedProbeInfo[FlashPointCount], MultiMasterCount * sizeof(struct BusLogic_ProbeInfo));
-                                        memcpy(&BusLogic_ProbeInfoList[MultiMasterCount], &SavedProbeInfo[0], FlashPointCount * sizeof(struct BusLogic_ProbeInfo));
+                                if (d0_mapbyte.diskgeom != BLOGIC_BIOS_NODISK) {
+                                        struct blogic_probeinfo saved_probeinfo[BLOGIC_MAX_ADAPTERS];
+                                        int mmcount = blogic_probeinfo_count - fpcount;
+
+                                        memcpy(saved_probeinfo,
+                                                blogic_probeinfo_list,
+                                                blogic_probeinfo_count * sizeof(struct blogic_probeinfo));
+                                        memcpy(&blogic_probeinfo_list[0],
+                                                &saved_probeinfo[fpcount],
+                                                mmcount * sizeof(struct blogic_probeinfo));
+                                        memcpy(&blogic_probeinfo_list[mmcount],
+                                                &saved_probeinfo[0],
+                                                fpcount * sizeof(struct blogic_probeinfo));
                                 }
                         }
                 }
-        } else
-                BusLogic_InitializeProbeInfoListISA(PrototypeHostAdapter);
+        } else {
+                blogic_init_probeinfo_isa(adapter);
+        }
 }
 
 
 #else
-#define BusLogic_InitializeProbeInfoList(adapter) \
-                BusLogic_InitializeProbeInfoListISA(adapter)
+#define blogic_init_probeinfo_list(adapter) \
+                blogic_init_probeinfo_isa(adapter)
 #endif                          /* CONFIG_PCI */
 
 
 /*
-  BusLogic_Failure prints a standardized error message, and then returns false.
+  blogic_failure prints a standardized error message, and then returns false.
 */
 
-static bool BusLogic_Failure(struct BusLogic_HostAdapter *HostAdapter, char *ErrorMessage)
+static bool blogic_failure(struct blogic_adapter *adapter, char *msg)
 {
-        BusLogic_AnnounceDriver(HostAdapter);
-        if (HostAdapter->HostAdapterBusType == BusLogic_PCI_Bus) {
-                BusLogic_Error("While configuring BusLogic PCI Host Adapter at\n", HostAdapter);
-                BusLogic_Error("Bus %d Device %d I/O Address 0x%X PCI Address 0x%X:\n", HostAdapter, HostAdapter->Bus, HostAdapter->Device, HostAdapter->IO_Address, HostAdapter->PCI_Address);
+        blogic_announce_drvr(adapter);
+        if (adapter->adapter_bus_type == BLOGIC_PCI_BUS) {
+                blogic_err("While configuring BusLogic PCI Host Adapter at\n",
+                                adapter);
+                blogic_err("Bus %d Device %d I/O Address 0x%X PCI Address 0x%X:\n", adapter, adapter->bus, adapter->dev, adapter->io_addr, adapter->pci_addr);
         } else
-                BusLogic_Error("While configuring BusLogic Host Adapter at " "I/O Address 0x%X:\n", HostAdapter, HostAdapter->IO_Address);
-        BusLogic_Error("%s FAILED - DETACHING\n", HostAdapter, ErrorMessage);
-        if (BusLogic_CommandFailureReason != NULL)
-                BusLogic_Error("ADDITIONAL FAILURE INFO - %s\n", HostAdapter, BusLogic_CommandFailureReason);
+                blogic_err("While configuring BusLogic Host Adapter at " "I/O Address 0x%X:\n", adapter, adapter->io_addr);
+        blogic_err("%s FAILED - DETACHING\n", adapter, msg);
+        if (blogic_cmd_failure_reason != NULL)
+                blogic_err("ADDITIONAL FAILURE INFO - %s\n", adapter,
+                                blogic_cmd_failure_reason);
         return false;
 }
 
 
 /*
-  BusLogic_ProbeHostAdapter probes for a BusLogic Host Adapter.
+  blogic_probe probes for a BusLogic Host Adapter.
 */
 
-static bool __init BusLogic_ProbeHostAdapter(struct BusLogic_HostAdapter *HostAdapter)
+static bool __init blogic_probe(struct blogic_adapter *adapter)
 {
-        union BusLogic_StatusRegister StatusRegister;
-        union BusLogic_InterruptRegister InterruptRegister;
-        union BusLogic_GeometryRegister GeometryRegister;
+        union blogic_stat_reg statusreg;
+        union blogic_int_reg intreg;
+        union blogic_geo_reg georeg;
         /*
            FlashPoint Host Adapters are Probed by the FlashPoint SCCB Manager.
          */
-        if (BusLogic_FlashPointHostAdapterP(HostAdapter)) {
-                struct FlashPoint_Info *FlashPointInfo = &HostAdapter->FlashPointInfo;
-                FlashPointInfo->BaseAddress = (u32) HostAdapter->IO_Address;
-                FlashPointInfo->IRQ_Channel = HostAdapter->IRQ_Channel;
-                FlashPointInfo->Present = false;
-                if (!(FlashPoint_ProbeHostAdapter(FlashPointInfo) == 0 && FlashPointInfo->Present)) {
-                        BusLogic_Error("BusLogic: FlashPoint Host Adapter detected at " "PCI Bus %d Device %d\n", HostAdapter, HostAdapter->Bus, HostAdapter->Device);
-                        BusLogic_Error("BusLogic: I/O Address 0x%X PCI Address 0x%X, " "but FlashPoint\n", HostAdapter, HostAdapter->IO_Address, HostAdapter->PCI_Address);
-                        BusLogic_Error("BusLogic: Probe Function failed to validate it.\n", HostAdapter);
+        if (blogic_flashpoint_type(adapter)) {
+                struct fpoint_info *fpinfo = &adapter->fpinfo;
+                fpinfo->base_addr = (u32) adapter->io_addr;
+                fpinfo->irq_ch = adapter->irq_ch;
+                fpinfo->present = false;
+                if (!(FlashPoint_ProbeHostAdapter(fpinfo) == 0 &&
+                                        fpinfo->present)) {
+                        blogic_err("BusLogic: FlashPoint Host Adapter detected at " "PCI Bus %d Device %d\n", adapter, adapter->bus, adapter->dev);
+                        blogic_err("BusLogic: I/O Address 0x%X PCI Address 0x%X, " "but FlashPoint\n", adapter, adapter->io_addr, adapter->pci_addr);
+                        blogic_err("BusLogic: Probe Function failed to validate it.\n", adapter);
                         return false;
                 }
-                if (BusLogic_GlobalOptions.TraceProbe)
-                        BusLogic_Notice("BusLogic_Probe(0x%X): FlashPoint Found\n", HostAdapter, HostAdapter->IO_Address);
+                if (blogic_global_options.trace_probe)
+                        blogic_notice("BusLogic_Probe(0x%X): FlashPoint Found\n", adapter, adapter->io_addr);
                 /*
                    Indicate the Host Adapter Probe completed successfully.
                  */
@@ -1068,28 +1152,32 @@ static bool __init BusLogic_ProbeHostAdapter(struct BusLogic_HostAdapter *HostAd
            case there is definitely no BusLogic Host Adapter at this base I/O Address.
            The test here is a subset of that used by the BusLogic Host Adapter BIOS.
          */
-        StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
-        InterruptRegister.All = BusLogic_ReadInterruptRegister(HostAdapter);
-        GeometryRegister.All = BusLogic_ReadGeometryRegister(HostAdapter);
-        if (BusLogic_GlobalOptions.TraceProbe)
-                BusLogic_Notice("BusLogic_Probe(0x%X): Status 0x%02X, Interrupt 0x%02X, " "Geometry 0x%02X\n", HostAdapter, HostAdapter->IO_Address, StatusRegister.All, InterruptRegister.All, GeometryRegister.All);
-        if (StatusRegister.All == 0 || StatusRegister.sr.DiagnosticActive || StatusRegister.sr.CommandParameterRegisterBusy || StatusRegister.sr.Reserved || StatusRegister.sr.CommandInvalid || InterruptRegister.ir.Reserved != 0)
+        statusreg.all = blogic_rdstatus(adapter);
+        intreg.all = blogic_rdint(adapter);
+        georeg.all = blogic_rdgeom(adapter);
+        if (blogic_global_options.trace_probe)
+                blogic_notice("BusLogic_Probe(0x%X): Status 0x%02X, Interrupt 0x%02X, " "Geometry 0x%02X\n", adapter, adapter->io_addr, statusreg.all, intreg.all, georeg.all);
+        if (statusreg.all == 0 || statusreg.sr.diag_active ||
+                        statusreg.sr.cmd_param_busy || statusreg.sr.rsvd ||
+                        statusreg.sr.cmd_invalid || intreg.ir.rsvd != 0)
                 return false;
         /*
-           Check the undocumented Geometry Register to test if there is an I/O port
-           that responded.  Adaptec Host Adapters do not implement the Geometry
-           Register, so this test helps serve to avoid incorrectly recognizing an
-           Adaptec 1542A or 1542B as a BusLogic.  Unfortunately, the Adaptec 1542C
-           series does respond to the Geometry Register I/O port, but it will be
-           rejected later when the Inquire Extended Setup Information command is
-           issued in BusLogic_CheckHostAdapter.  The AMI FastDisk Host Adapter is a
-           BusLogic clone that implements the same interface as earlier BusLogic
-           Host Adapters, including the undocumented commands, and is therefore
-           supported by this driver.  However, the AMI FastDisk always returns 0x00
-           upon reading the Geometry Register, so the extended translation option
-           should always be left disabled on the AMI FastDisk.
-         */
-        if (GeometryRegister.All == 0xFF)
+           Check the undocumented Geometry Register to test if there is
+           an I/O port that responded.  Adaptec Host Adapters do not
+           implement the Geometry Register, so this test helps serve to
+           avoid incorrectly recognizing an Adaptec 1542A or 1542B as a
+           BusLogic.  Unfortunately, the Adaptec 1542C series does respond
+           to the Geometry Register I/O port, but it will be rejected
+           later when the Inquire Extended Setup Information command is
+           issued in blogic_checkadapter.  The AMI FastDisk Host Adapter
+           is a BusLogic clone that implements the same interface as
+           earlier BusLogic Host Adapters, including the undocumented
+           commands, and is therefore supported by this driver. However,
+           the AMI FastDisk always returns 0x00 upon reading the Geometry
+           Register, so the extended translation option should always be
+           left disabled on the AMI FastDisk.
+         */
+        if (georeg.all == 0xFF)
                 return false;
         /*
            Indicate the Host Adapter Probe completed successfully.
@@ -1099,27 +1187,28 @@ static bool __init BusLogic_ProbeHostAdapter(struct BusLogic_HostAdapter *HostAd
 
 
 /*
-  BusLogic_HardwareResetHostAdapter issues a Hardware Reset to the Host Adapter
-  and waits for Host Adapter Diagnostics to complete.  If HardReset is true, a
+  blogic_hwreset issues a Hardware Reset to the Host Adapter
+  and waits for Host Adapter Diagnostics to complete.  If hard_reset is true, a
   Hard Reset is performed which also initiates a SCSI Bus Reset.  Otherwise, a
   Soft Reset is performed which only resets the Host Adapter without forcing a
   SCSI Bus Reset.
 */
 
-static bool BusLogic_HardwareResetHostAdapter(struct BusLogic_HostAdapter
-                                                 *HostAdapter, bool HardReset)
+static bool blogic_hwreset(struct blogic_adapter *adapter, bool hard_reset)
 {
-        union BusLogic_StatusRegister StatusRegister;
-        int TimeoutCounter;
+        union blogic_stat_reg statusreg;
+        int timeout;
         /*
-           FlashPoint Host Adapters are Hard Reset by the FlashPoint SCCB Manager.
+           FlashPoint Host Adapters are Hard Reset by the FlashPoint
+           SCCB Manager.
          */
-        if (BusLogic_FlashPointHostAdapterP(HostAdapter)) {
-                struct FlashPoint_Info *FlashPointInfo = &HostAdapter->FlashPointInfo;
-                FlashPointInfo->HostSoftReset = !HardReset;
-                FlashPointInfo->ReportDataUnderrun = true;
-                HostAdapter->CardHandle = FlashPoint_HardwareResetHostAdapter(FlashPointInfo);
-                if (HostAdapter->CardHandle == FlashPoint_BadCardHandle)
+        if (blogic_flashpoint_type(adapter)) {
+                struct fpoint_info *fpinfo = &adapter->fpinfo;
+                fpinfo->softreset = !hard_reset;
+                fpinfo->report_underrun = true;
+                adapter->cardhandle =
+                        FlashPoint_HardwareResetHostAdapter(fpinfo);
+                if (adapter->cardhandle == FPOINT_BADCARD_HANDLE)
                         return false;
                 /*
                    Indicate the Host Adapter Hard Reset completed successfully.
@@ -1127,26 +1216,27 @@ static bool BusLogic_HardwareResetHostAdapter(struct BusLogic_HostAdapter
                 return true;
         }
         /*
-           Issue a Hard Reset or Soft Reset Command to the Host Adapter.  The Host
-           Adapter should respond by setting Diagnostic Active in the Status Register.
+           Issue a Hard Reset or Soft Reset Command to the Host Adapter.
+           The Host Adapter should respond by setting Diagnostic Active in
+           the Status Register.
          */
-        if (HardReset)
-                BusLogic_HardReset(HostAdapter);
+        if (hard_reset)
+                blogic_hardreset(adapter);
         else
-                BusLogic_SoftReset(HostAdapter);
+                blogic_softreset(adapter);
         /*
            Wait until Diagnostic Active is set in the Status Register.
          */
-        TimeoutCounter = 5 * 10000;
-        while (--TimeoutCounter >= 0) {
-                StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
-                if (StatusRegister.sr.DiagnosticActive)
+        timeout = 5 * 10000;
+        while (--timeout >= 0) {
+                statusreg.all = blogic_rdstatus(adapter);
+                if (statusreg.sr.diag_active)
                         break;
                 udelay(100);
         }
-        if (BusLogic_GlobalOptions.TraceHardwareReset)
-                BusLogic_Notice("BusLogic_HardwareReset(0x%X): Diagnostic Active, " "Status 0x%02X\n", HostAdapter, HostAdapter->IO_Address, StatusRegister.All);
-        if (TimeoutCounter < 0)
+        if (blogic_global_options.trace_hw_reset)
+                blogic_notice("BusLogic_HardwareReset(0x%X): Diagnostic Active, " "Status 0x%02X\n", adapter, adapter->io_addr, statusreg.all);
+        if (timeout < 0)
                 return false;
         /*
            Wait 100 microseconds to allow completion of any initial diagnostic
@@ -1157,45 +1247,47 @@ static bool BusLogic_HardwareResetHostAdapter(struct BusLogic_HostAdapter
         /*
            Wait until Diagnostic Active is reset in the Status Register.
          */
-        TimeoutCounter = 10 * 10000;
-        while (--TimeoutCounter >= 0) {
-                StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
-                if (!StatusRegister.sr.DiagnosticActive)
+        timeout = 10 * 10000;
+        while (--timeout >= 0) {
+                statusreg.all = blogic_rdstatus(adapter);
+                if (!statusreg.sr.diag_active)
                         break;
                 udelay(100);
         }
-        if (BusLogic_GlobalOptions.TraceHardwareReset)
-                BusLogic_Notice("BusLogic_HardwareReset(0x%X): Diagnostic Completed, " "Status 0x%02X\n", HostAdapter, HostAdapter->IO_Address, StatusRegister.All);
-        if (TimeoutCounter < 0)
+        if (blogic_global_options.trace_hw_reset)
+                blogic_notice("BusLogic_HardwareReset(0x%X): Diagnostic Completed, " "Status 0x%02X\n", adapter, adapter->io_addr, statusreg.all);
+        if (timeout < 0)
                 return false;
         /*
-           Wait until at least one of the Diagnostic Failure, Host Adapter Ready,
-           or Data In Register Ready bits is set in the Status Register.
+           Wait until at least one of the Diagnostic Failure, Host Adapter
+           Ready, or Data In Register Ready bits is set in the Status Register.
          */
-        TimeoutCounter = 10000;
-        while (--TimeoutCounter >= 0) {
-                StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
-                if (StatusRegister.sr.DiagnosticFailure || StatusRegister.sr.HostAdapterReady || StatusRegister.sr.DataInRegisterReady)
+        timeout = 10000;
+        while (--timeout >= 0) {
+                statusreg.all = blogic_rdstatus(adapter);
+                if (statusreg.sr.diag_failed || statusreg.sr.adapter_ready ||
+                                statusreg.sr.datain_ready)
                         break;
                 udelay(100);
         }
-        if (BusLogic_GlobalOptions.TraceHardwareReset)
-                BusLogic_Notice("BusLogic_HardwareReset(0x%X): Host Adapter Ready, " "Status 0x%02X\n", HostAdapter, HostAdapter->IO_Address, StatusRegister.All);
-        if (TimeoutCounter < 0)
+        if (blogic_global_options.trace_hw_reset)
+                blogic_notice("BusLogic_HardwareReset(0x%X): Host Adapter Ready, " "Status 0x%02X\n", adapter, adapter->io_addr, statusreg.all);
+        if (timeout < 0)
                 return false;
         /*
-           If Diagnostic Failure is set or Host Adapter Ready is reset, then an
-           error occurred during the Host Adapter diagnostics.  If Data In Register
-           Ready is set, then there is an Error Code available.
-         */
-        if (StatusRegister.sr.DiagnosticFailure || !StatusRegister.sr.HostAdapterReady) {
-                BusLogic_CommandFailureReason = NULL;
-                BusLogic_Failure(HostAdapter, "HARD RESET DIAGNOSTICS");
-                BusLogic_Error("HOST ADAPTER STATUS REGISTER = %02X\n", HostAdapter, StatusRegister.All);
-                if (StatusRegister.sr.DataInRegisterReady) {
-                        unsigned char ErrorCode = BusLogic_ReadDataInRegister(HostAdapter);
-                        BusLogic_Error("HOST ADAPTER ERROR CODE = %d\n", HostAdapter, ErrorCode);
-                }
+           If Diagnostic Failure is set or Host Adapter Ready is reset,
+           then an error occurred during the Host Adapter diagnostics.
+           If Data In Register Ready is set, then there is an Error Code
+           available.
+         */
+        if (statusreg.sr.diag_failed || !statusreg.sr.adapter_ready) {
+                blogic_cmd_failure_reason = NULL;
+                blogic_failure(adapter, "HARD RESET DIAGNOSTICS");
+                blogic_err("HOST ADAPTER STATUS REGISTER = %02X\n", adapter,
+                                statusreg.all);
+                if (statusreg.sr.datain_ready)
+                        blogic_err("HOST ADAPTER ERROR CODE = %d\n", adapter,
+                                        blogic_rddatain(adapter));
                 return false;
         }
         /*
@@ -1206,161 +1298,175 @@ static bool BusLogic_HardwareResetHostAdapter(struct BusLogic_HostAdapter
 
 
 /*
-  BusLogic_CheckHostAdapter checks to be sure this really is a BusLogic
+  blogic_checkadapter checks to be sure this really is a BusLogic
   Host Adapter.
 */
 
-static bool __init BusLogic_CheckHostAdapter(struct BusLogic_HostAdapter *HostAdapter)
+static bool __init blogic_checkadapter(struct blogic_adapter *adapter)
 {
-        struct BusLogic_ExtendedSetupInformation ExtendedSetupInformation;
-        unsigned char RequestedReplyLength;
-        bool Result = true;
+        struct blogic_ext_setup ext_setupinfo;
+        unsigned char req_replylen;
+        bool result = true;
         /*
            FlashPoint Host Adapters do not require this protection.
          */
-        if (BusLogic_FlashPointHostAdapterP(HostAdapter))
+        if (blogic_flashpoint_type(adapter))
                 return true;
         /*
-           Issue the Inquire Extended Setup Information command.  Only genuine
-           BusLogic Host Adapters and true clones support this command.  Adaptec 1542C
-           series Host Adapters that respond to the Geometry Register I/O port will
-           fail this command.
+           Issue the Inquire Extended Setup Information command. Only genuine
+           BusLogic Host Adapters and true clones support this command.
+           Adaptec 1542C series Host Adapters that respond to the Geometry
+           Register I/O port will fail this command.
          */
-        RequestedReplyLength = sizeof(ExtendedSetupInformation);
-        if (BusLogic_Command(HostAdapter, BusLogic_InquireExtendedSetupInformation, &RequestedReplyLength, sizeof(RequestedReplyLength), &ExtendedSetupInformation, sizeof(ExtendedSetupInformation))
-            != sizeof(ExtendedSetupInformation))
-                Result = false;
+        req_replylen = sizeof(ext_setupinfo);
+        if (blogic_cmd(adapter, BLOGIC_INQ_EXTSETUP, &req_replylen,
+                                sizeof(req_replylen), &ext_setupinfo,
+                                sizeof(ext_setupinfo)) != sizeof(ext_setupinfo))
+                result = false;
         /*
            Provide tracing information if requested and return.
          */
-        if (BusLogic_GlobalOptions.TraceProbe)
-                BusLogic_Notice("BusLogic_Check(0x%X): MultiMaster %s\n", HostAdapter, HostAdapter->IO_Address, (Result ? "Found" : "Not Found"));
-        return Result;
+        if (blogic_global_options.trace_probe)
+                blogic_notice("BusLogic_Check(0x%X): MultiMaster %s\n", adapter,
+                                adapter->io_addr,
+                                (result ? "Found" : "Not Found"));
+        return result;
 }
 
 
 /*
-  BusLogic_ReadHostAdapterConfiguration reads the Configuration Information
+  blogic_rdconfig reads the Configuration Information
   from Host Adapter and initializes the Host Adapter structure.
 */
 
-static bool __init BusLogic_ReadHostAdapterConfiguration(struct BusLogic_HostAdapter
-                                                            *HostAdapter)
+static bool __init blogic_rdconfig(struct blogic_adapter *adapter)
 {
-        struct BusLogic_BoardID BoardID;
-        struct BusLogic_Configuration Configuration;
-        struct BusLogic_SetupInformation SetupInformation;
-        struct BusLogic_ExtendedSetupInformation ExtendedSetupInformation;
-        unsigned char HostAdapterModelNumber[5];
-        unsigned char FirmwareVersion3rdDigit;
-        unsigned char FirmwareVersionLetter;
-        struct BusLogic_PCIHostAdapterInformation PCIHostAdapterInformation;
-        struct BusLogic_FetchHostAdapterLocalRAMRequest FetchHostAdapterLocalRAMRequest;
-        struct BusLogic_AutoSCSIData AutoSCSIData;
-        union BusLogic_GeometryRegister GeometryRegister;
-        unsigned char RequestedReplyLength;
-        unsigned char *TargetPointer, Character;
-        int TargetID, i;
-        /*
-           Configuration Information for FlashPoint Host Adapters is provided in the
-           FlashPoint_Info structure by the FlashPoint SCCB Manager's Probe Function.
-           Initialize fields in the Host Adapter structure from the FlashPoint_Info
-           structure.
-         */
-        if (BusLogic_FlashPointHostAdapterP(HostAdapter)) {
-                struct FlashPoint_Info *FlashPointInfo = &HostAdapter->FlashPointInfo;
-                TargetPointer = HostAdapter->ModelName;
-                *TargetPointer++ = 'B';
-                *TargetPointer++ = 'T';
-                *TargetPointer++ = '-';
-                for (i = 0; i < sizeof(FlashPointInfo->ModelNumber); i++)
-                        *TargetPointer++ = FlashPointInfo->ModelNumber[i];
-                *TargetPointer++ = '\0';
-                strcpy(HostAdapter->FirmwareVersion, FlashPoint_FirmwareVersion);
-                HostAdapter->SCSI_ID = FlashPointInfo->SCSI_ID;
-                HostAdapter->ExtendedTranslationEnabled = FlashPointInfo->ExtendedTranslationEnabled;
-                HostAdapter->ParityCheckingEnabled = FlashPointInfo->ParityCheckingEnabled;
-                HostAdapter->BusResetEnabled = !FlashPointInfo->HostSoftReset;
-                HostAdapter->LevelSensitiveInterrupt = true;
-                HostAdapter->HostWideSCSI = FlashPointInfo->HostWideSCSI;
-                HostAdapter->HostDifferentialSCSI = false;
-                HostAdapter->HostSupportsSCAM = true;
-                HostAdapter->HostUltraSCSI = true;
-                HostAdapter->ExtendedLUNSupport = true;
-                HostAdapter->TerminationInfoValid = true;
-                HostAdapter->LowByteTerminated = FlashPointInfo->LowByteTerminated;
-                HostAdapter->HighByteTerminated = FlashPointInfo->HighByteTerminated;
-                HostAdapter->SCAM_Enabled = FlashPointInfo->SCAM_Enabled;
-                HostAdapter->SCAM_Level2 = FlashPointInfo->SCAM_Level2;
-                HostAdapter->DriverScatterGatherLimit = BusLogic_ScatterGatherLimit;
-                HostAdapter->MaxTargetDevices = (HostAdapter->HostWideSCSI ? 16 : 8);
-                HostAdapter->MaxLogicalUnits = 32;
-                HostAdapter->InitialCCBs = 4 * BusLogic_CCB_AllocationGroupSize;
-                HostAdapter->IncrementalCCBs = BusLogic_CCB_AllocationGroupSize;
-                HostAdapter->DriverQueueDepth = 255;
-                HostAdapter->HostAdapterQueueDepth = HostAdapter->DriverQueueDepth;
-                HostAdapter->SynchronousPermitted = FlashPointInfo->SynchronousPermitted;
-                HostAdapter->FastPermitted = FlashPointInfo->FastPermitted;
-                HostAdapter->UltraPermitted = FlashPointInfo->UltraPermitted;
-                HostAdapter->WidePermitted = FlashPointInfo->WidePermitted;
-                HostAdapter->DisconnectPermitted = FlashPointInfo->DisconnectPermitted;
-                HostAdapter->TaggedQueuingPermitted = 0xFFFF;
-                goto Common;
+        struct blogic_board_id id;
+        struct blogic_config config;
+        struct blogic_setup_info setupinfo;
+        struct blogic_ext_setup ext_setupinfo;
+        unsigned char model[5];
+        unsigned char fw_ver_digit3;
+        unsigned char fw_ver_letter;
+        struct blogic_adapter_info adapter_info;
+        struct blogic_fetch_localram fetch_localram;
+        struct blogic_autoscsi autoscsi;
+        union blogic_geo_reg georeg;
+        unsigned char req_replylen;
+        unsigned char *tgt, ch;
+        int tgt_id, i;
+        /*
+           Configuration Information for FlashPoint Host Adapters is
+           provided in the fpoint_info structure by the FlashPoint
+           SCCB Manager's Probe Function. Initialize fields in the
+           Host Adapter structure from the fpoint_info structure.
+         */
+        if (blogic_flashpoint_type(adapter)) {
+                struct fpoint_info *fpinfo = &adapter->fpinfo;
+                tgt = adapter->model;
+                *tgt++ = 'B';
+                *tgt++ = 'T';
+                *tgt++ = '-';
+                for (i = 0; i < sizeof(fpinfo->model); i++)
+                        *tgt++ = fpinfo->model[i];
+                *tgt++ = '\0';
+                strcpy(adapter->fw_ver, FLASHPOINT_FW_VER);
+                adapter->scsi_id = fpinfo->scsi_id;
+                adapter->ext_trans_enable = fpinfo->ext_trans_enable;
+                adapter->parity = fpinfo->parity;
+                adapter->reset_enabled = !fpinfo->softreset;
+                adapter->level_int = true;
+                adapter->wide = fpinfo->wide;
+                adapter->differential = false;
+                adapter->scam = true;
+                adapter->ultra = true;
+                adapter->ext_lun = true;
+                adapter->terminfo_valid = true;
+                adapter->low_term = fpinfo->low_term;
+                adapter->high_term = fpinfo->high_term;
+                adapter->scam_enabled = fpinfo->scam_enabled;
+                adapter->scam_lev2 = fpinfo->scam_lev2;
+                adapter->drvr_sglimit = BLOGIC_SG_LIMIT;
+                adapter->maxdev = (adapter->wide ? 16 : 8);
+                adapter->maxlun = 32;
+                adapter->initccbs = 4 * BLOGIC_CCB_GRP_ALLOCSIZE;
+                adapter->inc_ccbs = BLOGIC_CCB_GRP_ALLOCSIZE;
+                adapter->drvr_qdepth = 255;
+                adapter->adapter_qdepth = adapter->drvr_qdepth;
+                adapter->sync_ok = fpinfo->sync_ok;
+                adapter->fast_ok = fpinfo->fast_ok;
+                adapter->ultra_ok = fpinfo->ultra_ok;
+                adapter->wide_ok = fpinfo->wide_ok;
+                adapter->discon_ok = fpinfo->discon_ok;
+                adapter->tagq_ok = 0xFFFF;
+                goto common;
         }
         /*
            Issue the Inquire Board ID command.
          */
-        if (BusLogic_Command(HostAdapter, BusLogic_InquireBoardID, NULL, 0, &BoardID, sizeof(BoardID)) != sizeof(BoardID))
-                return BusLogic_Failure(HostAdapter, "INQUIRE BOARD ID");
+        if (blogic_cmd(adapter, BLOGIC_GET_BOARD_ID, NULL, 0, &id,
+                                sizeof(id)) != sizeof(id))
+                return blogic_failure(adapter, "INQUIRE BOARD ID");
         /*
            Issue the Inquire Configuration command.
          */
-        if (BusLogic_Command(HostAdapter, BusLogic_InquireConfiguration, NULL, 0, &Configuration, sizeof(Configuration))
-            != sizeof(Configuration))
-                return BusLogic_Failure(HostAdapter, "INQUIRE CONFIGURATION");
+        if (blogic_cmd(adapter, BLOGIC_INQ_CONFIG, NULL, 0, &config,
+                                sizeof(config))
+            != sizeof(config))
+                return blogic_failure(adapter, "INQUIRE CONFIGURATION");
         /*
            Issue the Inquire Setup Information command.
          */
-        RequestedReplyLength = sizeof(SetupInformation);
-        if (BusLogic_Command(HostAdapter, BusLogic_InquireSetupInformation, &RequestedReplyLength, sizeof(RequestedReplyLength), &SetupInformation, sizeof(SetupInformation))
-            != sizeof(SetupInformation))
-                return BusLogic_Failure(HostAdapter, "INQUIRE SETUP INFORMATION");
+        req_replylen = sizeof(setupinfo);
+        if (blogic_cmd(adapter, BLOGIC_INQ_SETUPINFO, &req_replylen,
+                                sizeof(req_replylen), &setupinfo,
+                                sizeof(setupinfo)) != sizeof(setupinfo))
+                return blogic_failure(adapter, "INQUIRE SETUP INFORMATION");
         /*
            Issue the Inquire Extended Setup Information command.
          */
-        RequestedReplyLength = sizeof(ExtendedSetupInformation);
-        if (BusLogic_Command(HostAdapter, BusLogic_InquireExtendedSetupInformation, &RequestedReplyLength, sizeof(RequestedReplyLength), &ExtendedSetupInformation, sizeof(ExtendedSetupInformation))
-            != sizeof(ExtendedSetupInformation))
-                return BusLogic_Failure(HostAdapter, "INQUIRE EXTENDED SETUP INFORMATION");
+        req_replylen = sizeof(ext_setupinfo);
+        if (blogic_cmd(adapter, BLOGIC_INQ_EXTSETUP, &req_replylen,
+                                sizeof(req_replylen), &ext_setupinfo,
+                                sizeof(ext_setupinfo)) != sizeof(ext_setupinfo))
+                return blogic_failure(adapter,
+                                        "INQUIRE EXTENDED SETUP INFORMATION");
         /*
            Issue the Inquire Firmware Version 3rd Digit command.
          */
-        FirmwareVersion3rdDigit = '\0';
-        if (BoardID.FirmwareVersion1stDigit > '0')
-                if (BusLogic_Command(HostAdapter, BusLogic_InquireFirmwareVersion3rdDigit, NULL, 0, &FirmwareVersion3rdDigit, sizeof(FirmwareVersion3rdDigit))
-                    != sizeof(FirmwareVersion3rdDigit))
-                        return BusLogic_Failure(HostAdapter, "INQUIRE FIRMWARE 3RD DIGIT");
+        fw_ver_digit3 = '\0';
+        if (id.fw_ver_digit1 > '0')
+                if (blogic_cmd(adapter, BLOGIC_INQ_FWVER_D3, NULL, 0,
+                                &fw_ver_digit3,
+                                sizeof(fw_ver_digit3)) != sizeof(fw_ver_digit3))
+                        return blogic_failure(adapter,
+                                                "INQUIRE FIRMWARE 3RD DIGIT");
         /*
            Issue the Inquire Host Adapter Model Number command.
          */
-        if (ExtendedSetupInformation.BusType == 'A' && BoardID.FirmwareVersion1stDigit == '2')
+        if (ext_setupinfo.bus_type == 'A' && id.fw_ver_digit1 == '2')
                 /* BusLogic BT-542B ISA 2.xx */
-                strcpy(HostAdapterModelNumber, "542B");
-        else if (ExtendedSetupInformation.BusType == 'E' && BoardID.FirmwareVersion1stDigit == '2' && (BoardID.FirmwareVersion2ndDigit <= '1' || (BoardID.FirmwareVersion2ndDigit == '2' && FirmwareVersion3rdDigit == '0')))
+                strcpy(model, "542B");
+        else if (ext_setupinfo.bus_type == 'E' && id.fw_ver_digit1 == '2' &&
+                        (id.fw_ver_digit2 <= '1' || (id.fw_ver_digit2 == '2' &&
+                                                     fw_ver_digit3 == '0')))
                 /* BusLogic BT-742A EISA 2.1x or 2.20 */
-                strcpy(HostAdapterModelNumber, "742A");
-        else if (ExtendedSetupInformation.BusType == 'E' && BoardID.FirmwareVersion1stDigit == '0')
+                strcpy(model, "742A");
+        else if (ext_setupinfo.bus_type == 'E' && id.fw_ver_digit1 == '0')
                 /* AMI FastDisk EISA Series 441 0.x */
-                strcpy(HostAdapterModelNumber, "747A");
+                strcpy(model, "747A");
         else {
-                RequestedReplyLength = sizeof(HostAdapterModelNumber);
-                if (BusLogic_Command(HostAdapter, BusLogic_InquireHostAdapterModelNumber, &RequestedReplyLength, sizeof(RequestedReplyLength), &HostAdapterModelNumber, sizeof(HostAdapterModelNumber))
-                    != sizeof(HostAdapterModelNumber))
-                        return BusLogic_Failure(HostAdapter, "INQUIRE HOST ADAPTER MODEL NUMBER");
+                req_replylen = sizeof(model);
+                if (blogic_cmd(adapter, BLOGIC_INQ_MODELNO, &req_replylen,
+                                        sizeof(req_replylen), &model,
+                                        sizeof(model)) != sizeof(model))
+                        return blogic_failure(adapter,
+                                        "INQUIRE HOST ADAPTER MODEL NUMBER");
         }
         /*
-           BusLogic MultiMaster Host Adapters can be identified by their model number
-           and the major version number of their firmware as follows:
+           BusLogic MultiMaster Host Adapters can be identified by their
+           model number and the major version number of their firmware
+           as follows:
 
            5.xx       BusLogic "W" Series Host Adapters:
            BT-948/958/958D
@@ -1374,497 +1480,535 @@ static bool __init BusLogic_ReadHostAdapterConfiguration(struct BusLogic_HostAda
            0.xx       AMI FastDisk VLB/EISA BusLogic Clone Host Adapter
          */
         /*
-           Save the Model Name and Host Adapter Name in the Host Adapter structure.
+           Save the Model Name and Host Adapter Name in the Host Adapter
+           structure.
          */
-        TargetPointer = HostAdapter->ModelName;
-        *TargetPointer++ = 'B';
-        *TargetPointer++ = 'T';
-        *TargetPointer++ = '-';
-        for (i = 0; i < sizeof(HostAdapterModelNumber); i++) {
-                Character = HostAdapterModelNumber[i];
-                if (Character == ' ' || Character == '\0')
+        tgt = adapter->model;
+        *tgt++ = 'B';
+        *tgt++ = 'T';
+        *tgt++ = '-';
+        for (i = 0; i < sizeof(model); i++) {
+                ch = model[i];
+                if (ch == ' ' || ch == '\0')
                         break;
-                *TargetPointer++ = Character;
+                *tgt++ = ch;
         }
-        *TargetPointer++ = '\0';
+        *tgt++ = '\0';
         /*
            Save the Firmware Version in the Host Adapter structure.
          */
-        TargetPointer = HostAdapter->FirmwareVersion;
-        *TargetPointer++ = BoardID.FirmwareVersion1stDigit;
-        *TargetPointer++ = '.';
-        *TargetPointer++ = BoardID.FirmwareVersion2ndDigit;
-        if (FirmwareVersion3rdDigit != ' ' && FirmwareVersion3rdDigit != '\0')
-                *TargetPointer++ = FirmwareVersion3rdDigit;
-        *TargetPointer = '\0';
+        tgt = adapter->fw_ver;
+        *tgt++ = id.fw_ver_digit1;
+        *tgt++ = '.';
+        *tgt++ = id.fw_ver_digit2;
+        if (fw_ver_digit3 != ' ' && fw_ver_digit3 != '\0')
+                *tgt++ = fw_ver_digit3;
+        *tgt = '\0';
         /*
            Issue the Inquire Firmware Version Letter command.
          */
-        if (strcmp(HostAdapter->FirmwareVersion, "3.3") >= 0) {
-                if (BusLogic_Command(HostAdapter, BusLogic_InquireFirmwareVersionLetter, NULL, 0, &FirmwareVersionLetter, sizeof(FirmwareVersionLetter))
-                    != sizeof(FirmwareVersionLetter))
-                        return BusLogic_Failure(HostAdapter, "INQUIRE FIRMWARE VERSION LETTER");
-                if (FirmwareVersionLetter != ' ' && FirmwareVersionLetter != '\0')
-                        *TargetPointer++ = FirmwareVersionLetter;
-                *TargetPointer = '\0';
+        if (strcmp(adapter->fw_ver, "3.3") >= 0) {
+                if (blogic_cmd(adapter, BLOGIC_INQ_FWVER_LETTER, NULL, 0,
+                                &fw_ver_letter,
+                                sizeof(fw_ver_letter)) != sizeof(fw_ver_letter))
+                        return blogic_failure(adapter,
+                                        "INQUIRE FIRMWARE VERSION LETTER");
+                if (fw_ver_letter != ' ' && fw_ver_letter != '\0')
+                        *tgt++ = fw_ver_letter;
+                *tgt = '\0';
         }
         /*
            Save the Host Adapter SCSI ID in the Host Adapter structure.
          */
-        HostAdapter->SCSI_ID = Configuration.HostAdapterID;
-        /*
-           Determine the Bus Type and save it in the Host Adapter structure, determine
-           and save the IRQ Channel if necessary, and determine and save the DMA
-           Channel for ISA Host Adapters.
-         */
-        HostAdapter->HostAdapterBusType = BusLogic_HostAdapterBusTypes[HostAdapter->ModelName[3] - '4'];
-        if (HostAdapter->IRQ_Channel == 0) {
-                if (Configuration.IRQ_Channel9)
-                        HostAdapter->IRQ_Channel = 9;
-                else if (Configuration.IRQ_Channel10)
-                        HostAdapter->IRQ_Channel = 10;
-                else if (Configuration.IRQ_Channel11)
-                        HostAdapter->IRQ_Channel = 11;
-                else if (Configuration.IRQ_Channel12)
-                        HostAdapter->IRQ_Channel = 12;
-                else if (Configuration.IRQ_Channel14)
-                        HostAdapter->IRQ_Channel = 14;
-                else if (Configuration.IRQ_Channel15)
-                        HostAdapter->IRQ_Channel = 15;
-        }
-        if (HostAdapter->HostAdapterBusType == BusLogic_ISA_Bus) {
-                if (Configuration.DMA_Channel5)
-                        HostAdapter->DMA_Channel = 5;
-                else if (Configuration.DMA_Channel6)
-                        HostAdapter->DMA_Channel = 6;
-                else if (Configuration.DMA_Channel7)
-                        HostAdapter->DMA_Channel = 7;
+        adapter->scsi_id = config.id;
+        /*
+           Determine the Bus Type and save it in the Host Adapter structure,
+           determine and save the IRQ Channel if necessary, and determine
+           and save the DMA Channel for ISA Host Adapters.
+         */
+        adapter->adapter_bus_type =
+                        blogic_adater_bus_types[adapter->model[3] - '4'];
+        if (adapter->irq_ch == 0) {
+                if (config.irq_ch9)
+                        adapter->irq_ch = 9;
+                else if (config.irq_ch10)
+                        adapter->irq_ch = 10;
+                else if (config.irq_ch11)
+                        adapter->irq_ch = 11;
+                else if (config.irq_ch12)
+                        adapter->irq_ch = 12;
+                else if (config.irq_ch14)
+                        adapter->irq_ch = 14;
+                else if (config.irq_ch15)
+                        adapter->irq_ch = 15;
+        }
+        if (adapter->adapter_bus_type == BLOGIC_ISA_BUS) {
+                if (config.dma_ch5)
+                        adapter->dma_ch = 5;
+                else if (config.dma_ch6)
+                        adapter->dma_ch = 6;
+                else if (config.dma_ch7)
+                        adapter->dma_ch = 7;
         }
         /*
            Determine whether Extended Translation is enabled and save it in
            the Host Adapter structure.
          */
-        GeometryRegister.All = BusLogic_ReadGeometryRegister(HostAdapter);
-        HostAdapter->ExtendedTranslationEnabled = GeometryRegister.gr.ExtendedTranslationEnabled;
+        georeg.all = blogic_rdgeom(adapter);
+        adapter->ext_trans_enable = georeg.gr.ext_trans_enable;
         /*
            Save the Scatter Gather Limits, Level Sensitive Interrupt flag, Wide
            SCSI flag, Differential SCSI flag, SCAM Supported flag, and
            Ultra SCSI flag in the Host Adapter structure.
          */
-        HostAdapter->HostAdapterScatterGatherLimit = ExtendedSetupInformation.ScatterGatherLimit;
-        HostAdapter->DriverScatterGatherLimit = HostAdapter->HostAdapterScatterGatherLimit;
-        if (HostAdapter->HostAdapterScatterGatherLimit > BusLogic_ScatterGatherLimit)
-                HostAdapter->DriverScatterGatherLimit = BusLogic_ScatterGatherLimit;
-        if (ExtendedSetupInformation.Misc.LevelSensitiveInterrupt)
-                HostAdapter->LevelSensitiveInterrupt = true;
-        HostAdapter->HostWideSCSI = ExtendedSetupInformation.HostWideSCSI;
-        HostAdapter->HostDifferentialSCSI = ExtendedSetupInformation.HostDifferentialSCSI;
-        HostAdapter->HostSupportsSCAM = ExtendedSetupInformation.HostSupportsSCAM;
-        HostAdapter->HostUltraSCSI = ExtendedSetupInformation.HostUltraSCSI;
+        adapter->adapter_sglimit = ext_setupinfo.sg_limit;
+        adapter->drvr_sglimit = adapter->adapter_sglimit;
+        if (adapter->adapter_sglimit > BLOGIC_SG_LIMIT)
+                adapter->drvr_sglimit = BLOGIC_SG_LIMIT;
+        if (ext_setupinfo.misc.level_int)
+                adapter->level_int = true;
+        adapter->wide = ext_setupinfo.wide;
+        adapter->differential = ext_setupinfo.differential;
+        adapter->scam = ext_setupinfo.scam;
+        adapter->ultra = ext_setupinfo.ultra;
         /*
            Determine whether Extended LUN Format CCBs are supported and save the
            information in the Host Adapter structure.
          */
-        if (HostAdapter->FirmwareVersion[0] == '5' || (HostAdapter->FirmwareVersion[0] == '4' && HostAdapter->HostWideSCSI))
-                HostAdapter->ExtendedLUNSupport = true;
+        if (adapter->fw_ver[0] == '5' || (adapter->fw_ver[0] == '4' &&
+                                adapter->wide))
+                adapter->ext_lun = true;
         /*
            Issue the Inquire PCI Host Adapter Information command to read the
            Termination Information from "W" series MultiMaster Host Adapters.
          */
-        if (HostAdapter->FirmwareVersion[0] == '5') {
-                if (BusLogic_Command(HostAdapter, BusLogic_InquirePCIHostAdapterInformation, NULL, 0, &PCIHostAdapterInformation, sizeof(PCIHostAdapterInformation))
-                    != sizeof(PCIHostAdapterInformation))
-                        return BusLogic_Failure(HostAdapter, "INQUIRE PCI HOST ADAPTER INFORMATION");
+        if (adapter->fw_ver[0] == '5') {
+                if (blogic_cmd(adapter, BLOGIC_INQ_PCI_INFO, NULL, 0,
+                                &adapter_info,
+                                sizeof(adapter_info)) != sizeof(adapter_info))
+                        return blogic_failure(adapter,
+                                        "INQUIRE PCI HOST ADAPTER INFORMATION");
                 /*
-                   Save the Termination Information in the Host Adapter structure.
+                   Save the Termination Information in the Host Adapter
+                   structure.
                  */
-                if (PCIHostAdapterInformation.GenericInfoValid) {
-                        HostAdapter->TerminationInfoValid = true;
-                        HostAdapter->LowByteTerminated = PCIHostAdapterInformation.LowByteTerminated;
-                        HostAdapter->HighByteTerminated = PCIHostAdapterInformation.HighByteTerminated;
+                if (adapter_info.genericinfo_valid) {
+                        adapter->terminfo_valid = true;
+                        adapter->low_term = adapter_info.low_term;
+                        adapter->high_term = adapter_info.high_term;
                 }
         }
         /*
-           Issue the Fetch Host Adapter Local RAM command to read the AutoSCSI data
-           from "W" and "C" series MultiMaster Host Adapters.
+           Issue the Fetch Host Adapter Local RAM command to read the
+           AutoSCSI data from "W" and "C" series MultiMaster Host Adapters.
          */
-        if (HostAdapter->FirmwareVersion[0] >= '4') {
-                FetchHostAdapterLocalRAMRequest.ByteOffset = BusLogic_AutoSCSI_BaseOffset;
-                FetchHostAdapterLocalRAMRequest.ByteCount = sizeof(AutoSCSIData);
-                if (BusLogic_Command(HostAdapter, BusLogic_FetchHostAdapterLocalRAM, &FetchHostAdapterLocalRAMRequest, sizeof(FetchHostAdapterLocalRAMRequest), &AutoSCSIData, sizeof(AutoSCSIData))
-                    != sizeof(AutoSCSIData))
-                        return BusLogic_Failure(HostAdapter, "FETCH HOST ADAPTER LOCAL RAM");
+        if (adapter->fw_ver[0] >= '4') {
+                fetch_localram.offset = BLOGIC_AUTOSCSI_BASE;
+                fetch_localram.count = sizeof(autoscsi);
+                if (blogic_cmd(adapter, BLOGIC_FETCH_LOCALRAM, &fetch_localram,
+                                        sizeof(fetch_localram), &autoscsi,
+                                        sizeof(autoscsi)) != sizeof(autoscsi))
+                        return blogic_failure(adapter,
+                                                "FETCH HOST ADAPTER LOCAL RAM");
                 /*
-                   Save the Parity Checking Enabled, Bus Reset Enabled, and Termination
-                   Information in the Host Adapter structure.
+                   Save the Parity Checking Enabled, Bus Reset Enabled,
+                   and Termination Information in the Host Adapter structure.
                  */
-                HostAdapter->ParityCheckingEnabled = AutoSCSIData.ParityCheckingEnabled;
-                HostAdapter->BusResetEnabled = AutoSCSIData.BusResetEnabled;
-                if (HostAdapter->FirmwareVersion[0] == '4') {
-                        HostAdapter->TerminationInfoValid = true;
-                        HostAdapter->LowByteTerminated = AutoSCSIData.LowByteTerminated;
-                        HostAdapter->HighByteTerminated = AutoSCSIData.HighByteTerminated;
+                adapter->parity = autoscsi.parity;
+                adapter->reset_enabled = autoscsi.reset_enabled;
+                if (adapter->fw_ver[0] == '4') {
+                        adapter->terminfo_valid = true;
+                        adapter->low_term = autoscsi.low_term;
+                        adapter->high_term = autoscsi.high_term;
                 }
                 /*
-                   Save the Wide Permitted, Fast Permitted, Synchronous Permitted,
-                   Disconnect Permitted, Ultra Permitted, and SCAM Information in the
-                   Host Adapter structure.
+                   Save the Wide Permitted, Fast Permitted, Synchronous
+                   Permitted, Disconnect Permitted, Ultra Permitted, and
+                   SCAM Information in the Host Adapter structure.
                  */
-                HostAdapter->WidePermitted = AutoSCSIData.WidePermitted;
-                HostAdapter->FastPermitted = AutoSCSIData.FastPermitted;
-                HostAdapter->SynchronousPermitted = AutoSCSIData.SynchronousPermitted;
-                HostAdapter->DisconnectPermitted = AutoSCSIData.DisconnectPermitted;
-                if (HostAdapter->HostUltraSCSI)
-                        HostAdapter->UltraPermitted = AutoSCSIData.UltraPermitted;
-                if (HostAdapter->HostSupportsSCAM) {
-                        HostAdapter->SCAM_Enabled = AutoSCSIData.SCAM_Enabled;
-                        HostAdapter->SCAM_Level2 = AutoSCSIData.SCAM_Level2;
+                adapter->wide_ok = autoscsi.wide_ok;
+                adapter->fast_ok = autoscsi.fast_ok;
+                adapter->sync_ok = autoscsi.sync_ok;
+                adapter->discon_ok = autoscsi.discon_ok;
+                if (adapter->ultra)
+                        adapter->ultra_ok = autoscsi.ultra_ok;
+                if (adapter->scam) {
+                        adapter->scam_enabled = autoscsi.scam_enabled;
+                        adapter->scam_lev2 = autoscsi.scam_lev2;
                 }
         }
         /*
-           Initialize fields in the Host Adapter structure for "S" and "A" series
-           MultiMaster Host Adapters.
+           Initialize fields in the Host Adapter structure for "S" and "A"
+           series MultiMaster Host Adapters.
          */
-        if (HostAdapter->FirmwareVersion[0] < '4') {
-                if (SetupInformation.SynchronousInitiationEnabled) {
-                        HostAdapter->SynchronousPermitted = 0xFF;
-                        if (HostAdapter->HostAdapterBusType == BusLogic_EISA_Bus) {
-                                if (ExtendedSetupInformation.Misc.FastOnEISA)
-                                        HostAdapter->FastPermitted = 0xFF;
-                                if (strcmp(HostAdapter->ModelName, "BT-757") == 0)
-                                        HostAdapter->WidePermitted = 0xFF;
+        if (adapter->fw_ver[0] < '4') {
+                if (setupinfo.sync) {
+                        adapter->sync_ok = 0xFF;
+                        if (adapter->adapter_bus_type == BLOGIC_EISA_BUS) {
+                                if (ext_setupinfo.misc.fast_on_eisa)
+                                        adapter->fast_ok = 0xFF;
+                                if (strcmp(adapter->model, "BT-757") == 0)
+                                        adapter->wide_ok = 0xFF;
                         }
                 }
-                HostAdapter->DisconnectPermitted = 0xFF;
-                HostAdapter->ParityCheckingEnabled = SetupInformation.ParityCheckingEnabled;
-                HostAdapter->BusResetEnabled = true;
+                adapter->discon_ok = 0xFF;
+                adapter->parity = setupinfo.parity;
+                adapter->reset_enabled = true;
         }
         /*
-           Determine the maximum number of Target IDs and Logical Units supported by
-           this driver for Wide and Narrow Host Adapters.
+           Determine the maximum number of Target IDs and Logical Units
+           supported by this driver for Wide and Narrow Host Adapters.
          */
-        HostAdapter->MaxTargetDevices = (HostAdapter->HostWideSCSI ? 16 : 8);
-        HostAdapter->MaxLogicalUnits = (HostAdapter->ExtendedLUNSupport ? 32 : 8);
+        adapter->maxdev = (adapter->wide ? 16 : 8);
+        adapter->maxlun = (adapter->ext_lun ? 32 : 8);
         /*
            Select appropriate values for the Mailbox Count, Driver Queue Depth,
-           Initial CCBs, and Incremental CCBs variables based on whether or not Strict
-           Round Robin Mode is supported.  If Strict Round Robin Mode is supported,
-           then there is no performance degradation in using the maximum possible
-           number of Outgoing and Incoming Mailboxes and allowing the Tagged and
-           Untagged Queue Depths to determine the actual utilization.  If Strict Round
-           Robin Mode is not supported, then the Host Adapter must scan all the
-           Outgoing Mailboxes whenever an Outgoing Mailbox entry is made, which can
-           cause a substantial performance penalty.  The host adapters actually have
-           room to store the following number of CCBs internally; that is, they can
-           internally queue and manage this many active commands on the SCSI bus
-           simultaneously.  Performance measurements demonstrate that the Driver Queue
-           Depth should be set to the Mailbox Count, rather than the Host Adapter
-           Queue Depth (internal CCB capacity), as it is more efficient to have the
-           queued commands waiting in Outgoing Mailboxes if necessary than to block
-           the process in the higher levels of the SCSI Subsystem.
+           Initial CCBs, and Incremental CCBs variables based on whether
+           or not Strict Round Robin Mode is supported.  If Strict Round
+           Robin Mode is supported, then there is no performance degradation
+           in using the maximum possible number of Outgoing and Incoming
+           Mailboxes and allowing the Tagged and Untagged Queue Depths to
+           determine the actual utilization.  If Strict Round Robin Mode is
+           not supported, then the Host Adapter must scan all the Outgoing
+           Mailboxes whenever an Outgoing Mailbox entry is made, which can
+           cause a substantial performance penalty.  The host adapters
+           actually have room to store the following number of CCBs
+           internally; that is, they can internally queue and manage this
+           many active commands on the SCSI bus simultaneously.  Performance
+           measurements demonstrate that the Driver Queue Depth should be
+           set to the Mailbox Count, rather than the Host Adapter Queue
+           Depth (internal CCB capacity), as it is more efficient to have the
+           queued commands waiting in Outgoing Mailboxes if necessary than
+           to block the process in the higher levels of the SCSI Subsystem.
 
            192          BT-948/958/958D
            100          BT-946C/956C/956CD/747C/757C/757CD/445C
            50   BT-545C/540CF
            30   BT-747S/747D/757S/757D/445S/545S/542D/542B/742A
          */
-        if (HostAdapter->FirmwareVersion[0] == '5')
-                HostAdapter->HostAdapterQueueDepth = 192;
-        else if (HostAdapter->FirmwareVersion[0] == '4')
-                HostAdapter->HostAdapterQueueDepth = (HostAdapter->HostAdapterBusType != BusLogic_ISA_Bus ? 100 : 50);
+        if (adapter->fw_ver[0] == '5')
+                adapter->adapter_qdepth = 192;
+        else if (adapter->fw_ver[0] == '4')
+                adapter->adapter_qdepth = (adapter->adapter_bus_type !=
+                                                BLOGIC_ISA_BUS ? 100 : 50);
         else
-                HostAdapter->HostAdapterQueueDepth = 30;
-        if (strcmp(HostAdapter->FirmwareVersion, "3.31") >= 0) {
-                HostAdapter->StrictRoundRobinModeSupport = true;
-                HostAdapter->MailboxCount = BusLogic_MaxMailboxes;
+                adapter->adapter_qdepth = 30;
+        if (strcmp(adapter->fw_ver, "3.31") >= 0) {
+                adapter->strict_rr = true;
+                adapter->mbox_count = BLOGIC_MAX_MAILBOX;
         } else {
-                HostAdapter->StrictRoundRobinModeSupport = false;
-                HostAdapter->MailboxCount = 32;
+                adapter->strict_rr = false;
+                adapter->mbox_count = 32;
         }
-        HostAdapter->DriverQueueDepth = HostAdapter->MailboxCount;
-        HostAdapter->InitialCCBs = 4 * BusLogic_CCB_AllocationGroupSize;
-        HostAdapter->IncrementalCCBs = BusLogic_CCB_AllocationGroupSize;
+        adapter->drvr_qdepth = adapter->mbox_count;
+        adapter->initccbs = 4 * BLOGIC_CCB_GRP_ALLOCSIZE;
+        adapter->inc_ccbs = BLOGIC_CCB_GRP_ALLOCSIZE;
         /*
-           Tagged Queuing support is available and operates properly on all "W" series
-           MultiMaster Host Adapters, on "C" series MultiMaster Host Adapters with
-           firmware version 4.22 and above, and on "S" series MultiMaster Host
-           Adapters with firmware version 3.35 and above.
+           Tagged Queuing support is available and operates properly on
+           all "W" series MultiMaster Host Adapters, on "C" series
+           MultiMaster Host Adapters with firmware version 4.22 and above,
+           and on "S" series MultiMaster Host Adapters with firmware version
+           3.35 and above.
          */
-        HostAdapter->TaggedQueuingPermitted = 0;
-        switch (HostAdapter->FirmwareVersion[0]) {
+        adapter->tagq_ok = 0;
+        switch (adapter->fw_ver[0]) {
         case '5':
-                HostAdapter->TaggedQueuingPermitted = 0xFFFF;
+                adapter->tagq_ok = 0xFFFF;
                 break;
         case '4':
-                if (strcmp(HostAdapter->FirmwareVersion, "4.22") >= 0)
-                        HostAdapter->TaggedQueuingPermitted = 0xFFFF;
+                if (strcmp(adapter->fw_ver, "4.22") >= 0)
+                        adapter->tagq_ok = 0xFFFF;
                 break;
         case '3':
-                if (strcmp(HostAdapter->FirmwareVersion, "3.35") >= 0)
-                        HostAdapter->TaggedQueuingPermitted = 0xFFFF;
+                if (strcmp(adapter->fw_ver, "3.35") >= 0)
+                        adapter->tagq_ok = 0xFFFF;
                 break;
         }
         /*
            Determine the Host Adapter BIOS Address if the BIOS is enabled and
            save it in the Host Adapter structure.  The BIOS is disabled if the
-           BIOS_Address is 0.
+           bios_addr is 0.
          */
-        HostAdapter->BIOS_Address = ExtendedSetupInformation.BIOS_Address << 12;
+        adapter->bios_addr = ext_setupinfo.bios_addr << 12;
         /*
-           ISA Host Adapters require Bounce Buffers if there is more than 16MB memory.
+           ISA Host Adapters require Bounce Buffers if there is more than
+           16MB memory.
          */
-        if (HostAdapter->HostAdapterBusType == BusLogic_ISA_Bus && (void *) high_memory > (void *) MAX_DMA_ADDRESS)
-                HostAdapter->BounceBuffersRequired = true;
+        if (adapter->adapter_bus_type == BLOGIC_ISA_BUS &&
+                        (void *) high_memory > (void *) MAX_DMA_ADDRESS)
+                adapter->need_bouncebuf = true;
         /*
-           BusLogic BT-445S Host Adapters prior to board revision E have a hardware
-           bug whereby when the BIOS is enabled, transfers to/from the same address
-           range the BIOS occupies modulo 16MB are handled incorrectly.  Only properly
-           functioning BT-445S Host Adapters have firmware version 3.37, so require
-           that ISA Bounce Buffers be used for the buggy BT-445S models if there is
-           more than 16MB memory.
+           BusLogic BT-445S Host Adapters prior to board revision E have a
+           hardware bug whereby when the BIOS is enabled, transfers to/from
+           the same address range the BIOS occupies modulo 16MB are handled
+           incorrectly.  Only properly functioning BT-445S Host Adapters
+           have firmware version 3.37, so require that ISA Bounce Buffers
+           be used for the buggy BT-445S models if there is more than 16MB
+           memory.
          */
-        if (HostAdapter->BIOS_Address > 0 && strcmp(HostAdapter->ModelName, "BT-445S") == 0 && strcmp(HostAdapter->FirmwareVersion, "3.37") < 0 && (void *) high_memory > (void *) MAX_DMA_ADDRESS)
-                HostAdapter->BounceBuffersRequired = true;
+        if (adapter->bios_addr > 0 && strcmp(adapter->model, "BT-445S") == 0 &&
+                        strcmp(adapter->fw_ver, "3.37") < 0 &&
+                        (void *) high_memory > (void *) MAX_DMA_ADDRESS)
+                adapter->need_bouncebuf = true;
         /*
-           Initialize parameters common to MultiMaster and FlashPoint Host Adapters.
+           Initialize parameters common to MultiMaster and FlashPoint
+           Host Adapters.
          */
-      Common:
+common:
         /*
            Initialize the Host Adapter Full Model Name from the Model Name.
          */
-        strcpy(HostAdapter->FullModelName, "BusLogic ");
-        strcat(HostAdapter->FullModelName, HostAdapter->ModelName);
+        strcpy(adapter->full_model, "BusLogic ");
+        strcat(adapter->full_model, adapter->model);
         /*
            Select an appropriate value for the Tagged Queue Depth either from a
            BusLogic Driver Options specification, or based on whether this Host
-           Adapter requires that ISA Bounce Buffers be used.  The Tagged Queue Depth
-           is left at 0 for automatic determination in BusLogic_SelectQueueDepths.
-           Initialize the Untagged Queue Depth.
-         */
-        for (TargetID = 0; TargetID < BusLogic_MaxTargetDevices; TargetID++) {
-                unsigned char QueueDepth = 0;
-                if (HostAdapter->DriverOptions != NULL && HostAdapter->DriverOptions->QueueDepth[TargetID] > 0)
-                        QueueDepth = HostAdapter->DriverOptions->QueueDepth[TargetID];
-                else if (HostAdapter->BounceBuffersRequired)
-                        QueueDepth = BusLogic_TaggedQueueDepthBB;
-                HostAdapter->QueueDepth[TargetID] = QueueDepth;
-        }
-        if (HostAdapter->BounceBuffersRequired)
-                HostAdapter->UntaggedQueueDepth = BusLogic_UntaggedQueueDepthBB;
+           Adapter requires that ISA Bounce Buffers be used.  The Tagged Queue
+           Depth is left at 0 for automatic determination in
+           BusLogic_SelectQueueDepths. Initialize the Untagged Queue Depth.
+         */
+        for (tgt_id = 0; tgt_id < BLOGIC_MAXDEV; tgt_id++) {
+                unsigned char qdepth = 0;
+                if (adapter->drvr_opts != NULL &&
+                                adapter->drvr_opts->qdepth[tgt_id] > 0)
+                        qdepth = adapter->drvr_opts->qdepth[tgt_id];
+                else if (adapter->need_bouncebuf)
+                        qdepth = BLOGIC_TAG_DEPTH_BB;
+                adapter->qdepth[tgt_id] = qdepth;
+        }
+        if (adapter->need_bouncebuf)
+                adapter->untag_qdepth = BLOGIC_UNTAG_DEPTH_BB;
         else
-                HostAdapter->UntaggedQueueDepth = BusLogic_UntaggedQueueDepth;
-        if (HostAdapter->DriverOptions != NULL)
-                HostAdapter->CommonQueueDepth = HostAdapter->DriverOptions->CommonQueueDepth;
-        if (HostAdapter->CommonQueueDepth > 0 && HostAdapter->CommonQueueDepth < HostAdapter->UntaggedQueueDepth)
-                HostAdapter->UntaggedQueueDepth = HostAdapter->CommonQueueDepth;
+                adapter->untag_qdepth = BLOGIC_UNTAG_DEPTH;
+        if (adapter->drvr_opts != NULL)
+                adapter->common_qdepth = adapter->drvr_opts->common_qdepth;
+        if (adapter->common_qdepth > 0 &&
+                        adapter->common_qdepth < adapter->untag_qdepth)
+                adapter->untag_qdepth = adapter->common_qdepth;
         /*
            Tagged Queuing is only allowed if Disconnect/Reconnect is permitted.
            Therefore, mask the Tagged Queuing Permitted Default bits with the
            Disconnect/Reconnect Permitted bits.
          */
-        HostAdapter->TaggedQueuingPermitted &= HostAdapter->DisconnectPermitted;
+        adapter->tagq_ok &= adapter->discon_ok;
         /*
-           Combine the default Tagged Queuing Permitted bits with any BusLogic Driver
-           Options Tagged Queuing specification.
+           Combine the default Tagged Queuing Permitted bits with any
+           BusLogic Driver Options Tagged Queuing specification.
          */
-        if (HostAdapter->DriverOptions != NULL)
-                HostAdapter->TaggedQueuingPermitted =
-                    (HostAdapter->DriverOptions->TaggedQueuingPermitted & HostAdapter->DriverOptions->TaggedQueuingPermittedMask) | (HostAdapter->TaggedQueuingPermitted & ~HostAdapter->DriverOptions->TaggedQueuingPermittedMask);
+        if (adapter->drvr_opts != NULL)
+                adapter->tagq_ok = (adapter->drvr_opts->tagq_ok &
+                                adapter->drvr_opts->tagq_ok_mask) |
+                        (adapter->tagq_ok & ~adapter->drvr_opts->tagq_ok_mask);
 
         /*
-           Select an appropriate value for Bus Settle Time either from a BusLogic
-           Driver Options specification, or from BusLogic_DefaultBusSettleTime.
+           Select an appropriate value for Bus Settle Time either from a
+           BusLogic Driver Options specification, or from
+           BLOGIC_BUS_SETTLE_TIME.
          */
-        if (HostAdapter->DriverOptions != NULL && HostAdapter->DriverOptions->BusSettleTime > 0)
-                HostAdapter->BusSettleTime = HostAdapter->DriverOptions->BusSettleTime;
+        if (adapter->drvr_opts != NULL &&
+                        adapter->drvr_opts->bus_settle_time > 0)
+                adapter->bus_settle_time = adapter->drvr_opts->bus_settle_time;
         else
-                HostAdapter->BusSettleTime = BusLogic_DefaultBusSettleTime;
+                adapter->bus_settle_time = BLOGIC_BUS_SETTLE_TIME;
         /*
-           Indicate reading the Host Adapter Configuration completed successfully.
+           Indicate reading the Host Adapter Configuration completed
+           successfully.
          */
         return true;
 }
 
 
 /*
-  BusLogic_ReportHostAdapterConfiguration reports the configuration of
-  Host Adapter.
+  blogic_reportconfig reports the configuration of Host Adapter.
 */
 
-static bool __init BusLogic_ReportHostAdapterConfiguration(struct BusLogic_HostAdapter
-                                                              *HostAdapter)
+static bool __init blogic_reportconfig(struct blogic_adapter *adapter)
 {
-        unsigned short AllTargetsMask = (1 << HostAdapter->MaxTargetDevices) - 1;
-        unsigned short SynchronousPermitted, FastPermitted;
-        unsigned short UltraPermitted, WidePermitted;
-        unsigned short DisconnectPermitted, TaggedQueuingPermitted;
-        bool CommonSynchronousNegotiation, CommonTaggedQueueDepth;
-        char SynchronousString[BusLogic_MaxTargetDevices + 1];
-        char WideString[BusLogic_MaxTargetDevices + 1];
-        char DisconnectString[BusLogic_MaxTargetDevices + 1];
-        char TaggedQueuingString[BusLogic_MaxTargetDevices + 1];
-        char *SynchronousMessage = SynchronousString;
-        char *WideMessage = WideString;
-        char *DisconnectMessage = DisconnectString;
-        char *TaggedQueuingMessage = TaggedQueuingString;
-        int TargetID;
-        BusLogic_Info("Configuring BusLogic Model %s %s%s%s%s SCSI Host Adapter\n",
-                      HostAdapter, HostAdapter->ModelName,
-                      BusLogic_HostAdapterBusNames[HostAdapter->HostAdapterBusType], (HostAdapter->HostWideSCSI ? " Wide" : ""), (HostAdapter->HostDifferentialSCSI ? " Differential" : ""), (HostAdapter->HostUltraSCSI ? " Ultra" : ""));
-        BusLogic_Info("  Firmware Version: %s, I/O Address: 0x%X, " "IRQ Channel: %d/%s\n", HostAdapter, HostAdapter->FirmwareVersion, HostAdapter->IO_Address, HostAdapter->IRQ_Channel, (HostAdapter->LevelSensitiveInterrupt ? "Level" : "Edge"));
-        if (HostAdapter->HostAdapterBusType != BusLogic_PCI_Bus) {
-                BusLogic_Info("  DMA Channel: ", HostAdapter);
-                if (HostAdapter->DMA_Channel > 0)
-                        BusLogic_Info("%d, ", HostAdapter, HostAdapter->DMA_Channel);
+        unsigned short alltgt_mask = (1 << adapter->maxdev) - 1;
+        unsigned short sync_ok, fast_ok;
+        unsigned short ultra_ok, wide_ok;
+        unsigned short discon_ok, tagq_ok;
+        bool common_syncneg, common_tagq_depth;
+        char syncstr[BLOGIC_MAXDEV + 1];
+        char widestr[BLOGIC_MAXDEV + 1];
+        char discon_str[BLOGIC_MAXDEV + 1];
+        char tagq_str[BLOGIC_MAXDEV + 1];
+        char *syncmsg = syncstr;
+        char *widemsg = widestr;
+        char *discon_msg = discon_str;
+        char *tagq_msg = tagq_str;
+        int tgt_id;
+
+        blogic_info("Configuring BusLogic Model %s %s%s%s%s SCSI Host Adapter\n", adapter, adapter->model, blogic_adapter_busnames[adapter->adapter_bus_type], (adapter->wide ? " Wide" : ""), (adapter->differential ? " Differential" : ""), (adapter->ultra ? " Ultra" : ""));
+        blogic_info("  Firmware Version: %s, I/O Address: 0x%X, " "IRQ Channel: %d/%s\n", adapter, adapter->fw_ver, adapter->io_addr, adapter->irq_ch, (adapter->level_int ? "Level" : "Edge"));
+        if (adapter->adapter_bus_type != BLOGIC_PCI_BUS) {
+                blogic_info("  DMA Channel: ", adapter);
+                if (adapter->dma_ch > 0)
+                        blogic_info("%d, ", adapter, adapter->dma_ch);
                 else
-                        BusLogic_Info("None, ", HostAdapter);
-                if (HostAdapter->BIOS_Address > 0)
-                        BusLogic_Info("BIOS Address: 0x%X, ", HostAdapter, HostAdapter->BIOS_Address);
+                        blogic_info("None, ", adapter);
+                if (adapter->bios_addr > 0)
+                        blogic_info("BIOS Address: 0x%X, ", adapter,
+                                        adapter->bios_addr);
                 else
-                        BusLogic_Info("BIOS Address: None, ", HostAdapter);
+                        blogic_info("BIOS Address: None, ", adapter);
         } else {
-                BusLogic_Info("  PCI Bus: %d, Device: %d, Address: ", HostAdapter, HostAdapter->Bus, HostAdapter->Device);
-                if (HostAdapter->PCI_Address > 0)
-                        BusLogic_Info("0x%X, ", HostAdapter, HostAdapter->PCI_Address);
+                blogic_info("  PCI Bus: %d, Device: %d, Address: ", adapter,
+                                adapter->bus, adapter->dev);
+                if (adapter->pci_addr > 0)
+                        blogic_info("0x%X, ", adapter, adapter->pci_addr);
                 else
-                        BusLogic_Info("Unassigned, ", HostAdapter);
-        }
-        BusLogic_Info("Host Adapter SCSI ID: %d\n", HostAdapter, HostAdapter->SCSI_ID);
-        BusLogic_Info("  Parity Checking: %s, Extended Translation: %s\n", HostAdapter, (HostAdapter->ParityCheckingEnabled ? "Enabled" : "Disabled"), (HostAdapter->ExtendedTranslationEnabled ? "Enabled" : "Disabled"));
-        AllTargetsMask &= ~(1 << HostAdapter->SCSI_ID);
-        SynchronousPermitted = HostAdapter->SynchronousPermitted & AllTargetsMask;
-        FastPermitted = HostAdapter->FastPermitted & AllTargetsMask;
-        UltraPermitted = HostAdapter->UltraPermitted & AllTargetsMask;
-        if ((BusLogic_MultiMasterHostAdapterP(HostAdapter) && (HostAdapter->FirmwareVersion[0] >= '4' || HostAdapter->HostAdapterBusType == BusLogic_EISA_Bus)) || BusLogic_FlashPointHostAdapterP(HostAdapter)) {
-                CommonSynchronousNegotiation = false;
-                if (SynchronousPermitted == 0) {
-                        SynchronousMessage = "Disabled";
-                        CommonSynchronousNegotiation = true;
-                } else if (SynchronousPermitted == AllTargetsMask) {
-                        if (FastPermitted == 0) {
-                                SynchronousMessage = "Slow";
-                                CommonSynchronousNegotiation = true;
-                        } else if (FastPermitted == AllTargetsMask) {
-                                if (UltraPermitted == 0) {
-                                        SynchronousMessage = "Fast";
-                                        CommonSynchronousNegotiation = true;
-                                } else if (UltraPermitted == AllTargetsMask) {
-                                        SynchronousMessage = "Ultra";
-                                        CommonSynchronousNegotiation = true;
+                        blogic_info("Unassigned, ", adapter);
+        }
+        blogic_info("Host Adapter SCSI ID: %d\n", adapter, adapter->scsi_id);
+        blogic_info("  Parity Checking: %s, Extended Translation: %s\n",
+                        adapter, (adapter->parity ? "Enabled" : "Disabled"),
+                        (adapter->ext_trans_enable ? "Enabled" : "Disabled"));
+        alltgt_mask &= ~(1 << adapter->scsi_id);
+        sync_ok = adapter->sync_ok & alltgt_mask;
+        fast_ok = adapter->fast_ok & alltgt_mask;
+        ultra_ok = adapter->ultra_ok & alltgt_mask;
+        if ((blogic_multimaster_type(adapter) &&
+                        (adapter->fw_ver[0] >= '4' ||
+                         adapter->adapter_bus_type == BLOGIC_EISA_BUS)) ||
+                        blogic_flashpoint_type(adapter)) {
+                common_syncneg = false;
+                if (sync_ok == 0) {
+                        syncmsg = "Disabled";
+                        common_syncneg = true;
+                } else if (sync_ok == alltgt_mask) {
+                        if (fast_ok == 0) {
+                                syncmsg = "Slow";
+                                common_syncneg = true;
+                        } else if (fast_ok == alltgt_mask) {
+                                if (ultra_ok == 0) {
+                                        syncmsg = "Fast";
+                                        common_syncneg = true;
+                                } else if (ultra_ok == alltgt_mask) {
+                                        syncmsg = "Ultra";
+                                        common_syncneg = true;
                                 }
                         }
                 }
-                if (!CommonSynchronousNegotiation) {
-                        for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
-                                SynchronousString[TargetID] = ((!(SynchronousPermitted & (1 << TargetID))) ? 'N' : (!(FastPermitted & (1 << TargetID)) ? 'S' : (!(UltraPermitted & (1 << TargetID)) ? 'F' : 'U')));
-                        SynchronousString[HostAdapter->SCSI_ID] = '#';
-                        SynchronousString[HostAdapter->MaxTargetDevices] = '\0';
+                if (!common_syncneg) {
+                        for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)
+                                syncstr[tgt_id] = ((!(sync_ok & (1 << tgt_id))) ? 'N' : (!(fast_ok & (1 << tgt_id)) ? 'S' : (!(ultra_ok & (1 << tgt_id)) ? 'F' : 'U')));
+                        syncstr[adapter->scsi_id] = '#';
+                        syncstr[adapter->maxdev] = '\0';
                 }
         } else
-                SynchronousMessage = (SynchronousPermitted == 0 ? "Disabled" : "Enabled");
-        WidePermitted = HostAdapter->WidePermitted & AllTargetsMask;
-        if (WidePermitted == 0)
-                WideMessage = "Disabled";
-        else if (WidePermitted == AllTargetsMask)
-                WideMessage = "Enabled";
+                syncmsg = (sync_ok == 0 ? "Disabled" : "Enabled");
+        wide_ok = adapter->wide_ok & alltgt_mask;
+        if (wide_ok == 0)
+                widemsg = "Disabled";
+        else if (wide_ok == alltgt_mask)
+                widemsg = "Enabled";
         else {
-                for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
-                        WideString[TargetID] = ((WidePermitted & (1 << TargetID)) ? 'Y' : 'N');
-                WideString[HostAdapter->SCSI_ID] = '#';
-                WideString[HostAdapter->MaxTargetDevices] = '\0';
-        }
-        DisconnectPermitted = HostAdapter->DisconnectPermitted & AllTargetsMask;
-        if (DisconnectPermitted == 0)
-                DisconnectMessage = "Disabled";
-        else if (DisconnectPermitted == AllTargetsMask)
-                DisconnectMessage = "Enabled";
+                for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)
+                        widestr[tgt_id] = ((wide_ok & (1 << tgt_id)) ? 'Y' : 'N');
+                widestr[adapter->scsi_id] = '#';
+                widestr[adapter->maxdev] = '\0';
+        }
+        discon_ok = adapter->discon_ok & alltgt_mask;
+        if (discon_ok == 0)
+                discon_msg = "Disabled";
+        else if (discon_ok == alltgt_mask)
+                discon_msg = "Enabled";
         else {
-                for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
-                        DisconnectString[TargetID] = ((DisconnectPermitted & (1 << TargetID)) ? 'Y' : 'N');
-                DisconnectString[HostAdapter->SCSI_ID] = '#';
-                DisconnectString[HostAdapter->MaxTargetDevices] = '\0';
-        }
-        TaggedQueuingPermitted = HostAdapter->TaggedQueuingPermitted & AllTargetsMask;
-        if (TaggedQueuingPermitted == 0)
-                TaggedQueuingMessage = "Disabled";
-        else if (TaggedQueuingPermitted == AllTargetsMask)
-                TaggedQueuingMessage = "Enabled";
+                for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)
+                        discon_str[tgt_id] = ((discon_ok & (1 << tgt_id)) ? 'Y' : 'N');
+                discon_str[adapter->scsi_id] = '#';
+                discon_str[adapter->maxdev] = '\0';
+        }
+        tagq_ok = adapter->tagq_ok & alltgt_mask;
+        if (tagq_ok == 0)
+                tagq_msg = "Disabled";
+        else if (tagq_ok == alltgt_mask)
+                tagq_msg = "Enabled";
         else {
-                for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
-                        TaggedQueuingString[TargetID] = ((TaggedQueuingPermitted & (1 << TargetID)) ? 'Y' : 'N');
-                TaggedQueuingString[HostAdapter->SCSI_ID] = '#';
-                TaggedQueuingString[HostAdapter->MaxTargetDevices] = '\0';
-        }
-        BusLogic_Info("  Synchronous Negotiation: %s, Wide Negotiation: %s\n", HostAdapter, SynchronousMessage, WideMessage);
-        BusLogic_Info("  Disconnect/Reconnect: %s, Tagged Queuing: %s\n", HostAdapter, DisconnectMessage, TaggedQueuingMessage);
-        if (BusLogic_MultiMasterHostAdapterP(HostAdapter)) {
-                BusLogic_Info("  Scatter/Gather Limit: %d of %d segments, " "Mailboxes: %d\n", HostAdapter, HostAdapter->DriverScatterGatherLimit, HostAdapter->HostAdapterScatterGatherLimit, HostAdapter->MailboxCount);
-                BusLogic_Info("  Driver Queue Depth: %d, " "Host Adapter Queue Depth: %d\n", HostAdapter, HostAdapter->DriverQueueDepth, HostAdapter->HostAdapterQueueDepth);
+                for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)
+                        tagq_str[tgt_id] = ((tagq_ok & (1 << tgt_id)) ? 'Y' : 'N');
+                tagq_str[adapter->scsi_id] = '#';
+                tagq_str[adapter->maxdev] = '\0';
+        }
+        blogic_info("  Synchronous Negotiation: %s, Wide Negotiation: %s\n",
+                        adapter, syncmsg, widemsg);
+        blogic_info("  Disconnect/Reconnect: %s, Tagged Queuing: %s\n", adapter,
+                        discon_msg, tagq_msg);
+        if (blogic_multimaster_type(adapter)) {
+                blogic_info("  Scatter/Gather Limit: %d of %d segments, " "Mailboxes: %d\n", adapter, adapter->drvr_sglimit, adapter->adapter_sglimit, adapter->mbox_count);
+                blogic_info("  Driver Queue Depth: %d, " "Host Adapter Queue Depth: %d\n", adapter, adapter->drvr_qdepth, adapter->adapter_qdepth);
         } else
-                BusLogic_Info("  Driver Queue Depth: %d, " "Scatter/Gather Limit: %d segments\n", HostAdapter, HostAdapter->DriverQueueDepth, HostAdapter->DriverScatterGatherLimit);
-        BusLogic_Info("  Tagged Queue Depth: ", HostAdapter);
-        CommonTaggedQueueDepth = true;
-        for (TargetID = 1; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
-                if (HostAdapter->QueueDepth[TargetID] != HostAdapter->QueueDepth[0]) {
-                        CommonTaggedQueueDepth = false;
+                blogic_info("  Driver Queue Depth: %d, " "Scatter/Gather Limit: %d segments\n", adapter, adapter->drvr_qdepth, adapter->drvr_sglimit);
+        blogic_info("  Tagged Queue Depth: ", adapter);
+        common_tagq_depth = true;
+        for (tgt_id = 1; tgt_id < adapter->maxdev; tgt_id++)
+                if (adapter->qdepth[tgt_id] != adapter->qdepth[0]) {
+                        common_tagq_depth = false;
                         break;
                 }
-        if (CommonTaggedQueueDepth) {
-                if (HostAdapter->QueueDepth[0] > 0)
-                        BusLogic_Info("%d", HostAdapter, HostAdapter->QueueDepth[0]);
+        if (common_tagq_depth) {
+                if (adapter->qdepth[0] > 0)
+                        blogic_info("%d", adapter, adapter->qdepth[0]);
                 else
-                        BusLogic_Info("Automatic", HostAdapter);
+                        blogic_info("Automatic", adapter);
         } else
-                BusLogic_Info("Individual", HostAdapter);
-        BusLogic_Info(", Untagged Queue Depth: %d\n", HostAdapter, HostAdapter->UntaggedQueueDepth);
-        if (HostAdapter->TerminationInfoValid) {
-                if (HostAdapter->HostWideSCSI)
-                        BusLogic_Info("  SCSI Bus Termination: %s", HostAdapter, (HostAdapter->LowByteTerminated ? (HostAdapter->HighByteTerminated ? "Both Enabled" : "Low Enabled")
-                                                                                  : (HostAdapter->HighByteTerminated ? "High Enabled" : "Both Disabled")));
+                blogic_info("Individual", adapter);
+        blogic_info(", Untagged Queue Depth: %d\n", adapter,
+                        adapter->untag_qdepth);
+        if (adapter->terminfo_valid) {
+                if (adapter->wide)
+                        blogic_info("  SCSI Bus Termination: %s", adapter,
+                                (adapter->low_term ? (adapter->high_term ? "Both Enabled" : "Low Enabled") : (adapter->high_term ? "High Enabled" : "Both Disabled")));
                 else
-                        BusLogic_Info("  SCSI Bus Termination: %s", HostAdapter, (HostAdapter->LowByteTerminated ? "Enabled" : "Disabled"));
-                if (HostAdapter->HostSupportsSCAM)
-                        BusLogic_Info(", SCAM: %s", HostAdapter, (HostAdapter->SCAM_Enabled ? (HostAdapter->SCAM_Level2 ? "Enabled, Level 2" : "Enabled, Level 1")
-                                                                  : "Disabled"));
-                BusLogic_Info("\n", HostAdapter);
+                        blogic_info("  SCSI Bus Termination: %s", adapter,
+                                (adapter->low_term ? "Enabled" : "Disabled"));
+                if (adapter->scam)
+                        blogic_info(", SCAM: %s", adapter,
+                                (adapter->scam_enabled ? (adapter->scam_lev2 ? "Enabled, Level 2" : "Enabled, Level 1") : "Disabled"));
+                blogic_info("\n", adapter);
         }
         /*
-           Indicate reporting the Host Adapter configuration completed successfully.
+           Indicate reporting the Host Adapter configuration completed
+           successfully.
          */
         return true;
 }
 
 
 /*
-  BusLogic_AcquireResources acquires the system resources necessary to use
+  blogic_getres acquires the system resources necessary to use
   Host Adapter.
 */
 
-static bool __init BusLogic_AcquireResources(struct BusLogic_HostAdapter *HostAdapter)
+static bool __init blogic_getres(struct blogic_adapter *adapter)
 {
-        if (HostAdapter->IRQ_Channel == 0) {
-                BusLogic_Error("NO LEGAL INTERRUPT CHANNEL ASSIGNED - DETACHING\n", HostAdapter);
+        if (adapter->irq_ch == 0) {
+                blogic_err("NO LEGAL INTERRUPT CHANNEL ASSIGNED - DETACHING\n",
+                                adapter);
                 return false;
         }
         /*
            Acquire shared access to the IRQ Channel.
          */
-        if (request_irq(HostAdapter->IRQ_Channel, BusLogic_InterruptHandler, IRQF_SHARED, HostAdapter->FullModelName, HostAdapter) < 0) {
-                BusLogic_Error("UNABLE TO ACQUIRE IRQ CHANNEL %d - DETACHING\n", HostAdapter, HostAdapter->IRQ_Channel);
+        if (request_irq(adapter->irq_ch, blogic_inthandler, IRQF_SHARED,
+                                adapter->full_model, adapter) < 0) {
+                blogic_err("UNABLE TO ACQUIRE IRQ CHANNEL %d - DETACHING\n",
+                                adapter, adapter->irq_ch);
                 return false;
         }
-        HostAdapter->IRQ_ChannelAcquired = true;
+        adapter->irq_acquired = true;
         /*
            Acquire exclusive access to the DMA Channel.
          */
-        if (HostAdapter->DMA_Channel > 0) {
-                if (request_dma(HostAdapter->DMA_Channel, HostAdapter->FullModelName) < 0) {
-                        BusLogic_Error("UNABLE TO ACQUIRE DMA CHANNEL %d - DETACHING\n", HostAdapter, HostAdapter->DMA_Channel);
+        if (adapter->dma_ch > 0) {
+                if (request_dma(adapter->dma_ch, adapter->full_model) < 0) {
+                        blogic_err("UNABLE TO ACQUIRE DMA CHANNEL %d - DETACHING\n", adapter, adapter->dma_ch);
                         return false;
                 }
-                set_dma_mode(HostAdapter->DMA_Channel, DMA_MODE_CASCADE);
-                enable_dma(HostAdapter->DMA_Channel);
-                HostAdapter->DMA_ChannelAcquired = true;
+                set_dma_mode(adapter->dma_ch, DMA_MODE_CASCADE);
+                enable_dma(adapter->dma_ch);
+                adapter->dma_chan_acquired = true;
         }
         /*
            Indicate the System Resource Acquisition completed successfully,
@@ -1874,127 +2018,146 @@ static bool __init BusLogic_AcquireResources(struct BusLogic_HostAdapter *HostAd
 
 
 /*
-  BusLogic_ReleaseResources releases any system resources previously acquired
-  by BusLogic_AcquireResources.
+  blogic_relres releases any system resources previously acquired
+  by blogic_getres.
 */
 
-static void BusLogic_ReleaseResources(struct BusLogic_HostAdapter *HostAdapter)
+static void blogic_relres(struct blogic_adapter *adapter)
 {
         /*
            Release shared access to the IRQ Channel.
          */
-        if (HostAdapter->IRQ_ChannelAcquired)
-                free_irq(HostAdapter->IRQ_Channel, HostAdapter);
+        if (adapter->irq_acquired)
+                free_irq(adapter->irq_ch, adapter);
         /*
            Release exclusive access to the DMA Channel.
          */
-        if (HostAdapter->DMA_ChannelAcquired)
-                free_dma(HostAdapter->DMA_Channel);
+        if (adapter->dma_chan_acquired)
+                free_dma(adapter->dma_ch);
         /*
            Release any allocated memory structs not released elsewhere
          */
-        if (HostAdapter->MailboxSpace)
-                pci_free_consistent(HostAdapter->PCI_Device, HostAdapter->MailboxSize, HostAdapter->MailboxSpace, HostAdapter->MailboxSpaceHandle);
-        pci_dev_put(HostAdapter->PCI_Device);
-        HostAdapter->MailboxSpace = NULL;
-        HostAdapter->MailboxSpaceHandle = 0;
-        HostAdapter->MailboxSize = 0;
+        if (adapter->mbox_space)
+                pci_free_consistent(adapter->pci_device, adapter->mbox_sz,
+                        adapter->mbox_space, adapter->mbox_space_handle);
+        pci_dev_put(adapter->pci_device);
+        adapter->mbox_space = NULL;
+        adapter->mbox_space_handle = 0;
+        adapter->mbox_sz = 0;
 }
 
 
 /*
-  BusLogic_InitializeHostAdapter initializes Host Adapter.  This is the only
+  blogic_initadapter initializes Host Adapter.  This is the only
   function called during SCSI Host Adapter detection which modifies the state
   of the Host Adapter from its initial power on or hard reset state.
 */
 
-static bool BusLogic_InitializeHostAdapter(struct BusLogic_HostAdapter
-                                              *HostAdapter)
+static bool blogic_initadapter(struct blogic_adapter *adapter)
 {
-        struct BusLogic_ExtendedMailboxRequest ExtendedMailboxRequest;
-        enum BusLogic_RoundRobinModeRequest RoundRobinModeRequest;
-        enum BusLogic_SetCCBFormatRequest SetCCBFormatRequest;
-        int TargetID;
+        struct blogic_extmbox_req extmbox_req;
+        enum blogic_rr_req rr_req;
+        enum blogic_setccb_fmt setccb_fmt;
+        int tgt_id;
+
         /*
-           Initialize the pointers to the first and last CCBs that are queued for
-           completion processing.
+           Initialize the pointers to the first and last CCBs that are
+           queued for completion processing.
          */
-        HostAdapter->FirstCompletedCCB = NULL;
-        HostAdapter->LastCompletedCCB = NULL;
+        adapter->firstccb = NULL;
+        adapter->lastccb = NULL;
+
         /*
            Initialize the Bus Device Reset Pending CCB, Tagged Queuing Active,
            Command Successful Flag, Active Commands, and Commands Since Reset
            for each Target Device.
          */
-        for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++) {
-                HostAdapter->BusDeviceResetPendingCCB[TargetID] = NULL;
-                HostAdapter->TargetFlags[TargetID].TaggedQueuingActive = false;
-                HostAdapter->TargetFlags[TargetID].CommandSuccessfulFlag = false;
-                HostAdapter->ActiveCommands[TargetID] = 0;
-                HostAdapter->CommandsSinceReset[TargetID] = 0;
+        for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++) {
+                adapter->bdr_pend[tgt_id] = NULL;
+                adapter->tgt_flags[tgt_id].tagq_active = false;
+                adapter->tgt_flags[tgt_id].cmd_good = false;
+                adapter->active_cmds[tgt_id] = 0;
+                adapter->cmds_since_rst[tgt_id] = 0;
         }
+
         /*
            FlashPoint Host Adapters do not use Outgoing and Incoming Mailboxes.
          */
-        if (BusLogic_FlashPointHostAdapterP(HostAdapter))
-                goto Done;
+        if (blogic_flashpoint_type(adapter))
+                goto done;
+
         /*
            Initialize the Outgoing and Incoming Mailbox pointers.
          */
-        HostAdapter->MailboxSize = HostAdapter->MailboxCount * (sizeof(struct BusLogic_OutgoingMailbox) + sizeof(struct BusLogic_IncomingMailbox));
-        HostAdapter->MailboxSpace = pci_alloc_consistent(HostAdapter->PCI_Device, HostAdapter->MailboxSize, &HostAdapter->MailboxSpaceHandle);
-        if (HostAdapter->MailboxSpace == NULL)
-                return BusLogic_Failure(HostAdapter, "MAILBOX ALLOCATION");
-        HostAdapter->FirstOutgoingMailbox = (struct BusLogic_OutgoingMailbox *) HostAdapter->MailboxSpace;
-        HostAdapter->LastOutgoingMailbox = HostAdapter->FirstOutgoingMailbox + HostAdapter->MailboxCount - 1;
-        HostAdapter->NextOutgoingMailbox = HostAdapter->FirstOutgoingMailbox;
-        HostAdapter->FirstIncomingMailbox = (struct BusLogic_IncomingMailbox *) (HostAdapter->LastOutgoingMailbox + 1);
-        HostAdapter->LastIncomingMailbox = HostAdapter->FirstIncomingMailbox + HostAdapter->MailboxCount - 1;
-        HostAdapter->NextIncomingMailbox = HostAdapter->FirstIncomingMailbox;
+        adapter->mbox_sz = adapter->mbox_count * (sizeof(struct blogic_outbox) + sizeof(struct blogic_inbox));
+        adapter->mbox_space = pci_alloc_consistent(adapter->pci_device,
+                                adapter->mbox_sz, &adapter->mbox_space_handle);
+        if (adapter->mbox_space == NULL)
+                return blogic_failure(adapter, "MAILBOX ALLOCATION");
+        adapter->first_outbox = (struct blogic_outbox *) adapter->mbox_space;
+        adapter->last_outbox = adapter->first_outbox + adapter->mbox_count - 1;
+        adapter->next_outbox = adapter->first_outbox;
+        adapter->first_inbox = (struct blogic_inbox *) (adapter->last_outbox + 1);
+        adapter->last_inbox = adapter->first_inbox + adapter->mbox_count - 1;
+        adapter->next_inbox = adapter->first_inbox;
 
         /*
            Initialize the Outgoing and Incoming Mailbox structures.
          */
-        memset(HostAdapter->FirstOutgoingMailbox, 0, HostAdapter->MailboxCount * sizeof(struct BusLogic_OutgoingMailbox));
-        memset(HostAdapter->FirstIncomingMailbox, 0, HostAdapter->MailboxCount * sizeof(struct BusLogic_IncomingMailbox));
+        memset(adapter->first_outbox, 0,
+                        adapter->mbox_count * sizeof(struct blogic_outbox));
+        memset(adapter->first_inbox, 0,
+                        adapter->mbox_count * sizeof(struct blogic_inbox));
+
         /*
-           Initialize the Host Adapter's Pointer to the Outgoing/Incoming Mailboxes.
+           Initialize the Host Adapter's Pointer to the Outgoing/Incoming
+           Mailboxes.
          */
-        ExtendedMailboxRequest.MailboxCount = HostAdapter->MailboxCount;
-        ExtendedMailboxRequest.BaseMailboxAddress = (u32) HostAdapter->MailboxSpaceHandle;
-        if (BusLogic_Command(HostAdapter, BusLogic_InitializeExtendedMailbox, &ExtendedMailboxRequest, sizeof(ExtendedMailboxRequest), NULL, 0) < 0)
-                return BusLogic_Failure(HostAdapter, "MAILBOX INITIALIZATION");
+        extmbox_req.mbox_count = adapter->mbox_count;
+        extmbox_req.base_mbox_addr = (u32) adapter->mbox_space_handle;
+        if (blogic_cmd(adapter, BLOGIC_INIT_EXT_MBOX, &extmbox_req,
+                                sizeof(extmbox_req), NULL, 0) < 0)
+                return blogic_failure(adapter, "MAILBOX INITIALIZATION");
         /*
-           Enable Strict Round Robin Mode if supported by the Host Adapter.  In
-           Strict Round Robin Mode, the Host Adapter only looks at the next Outgoing
-           Mailbox for each new command, rather than scanning through all the
-           Outgoing Mailboxes to find any that have new commands in them.  Strict
-           Round Robin Mode is significantly more efficient.
+           Enable Strict Round Robin Mode if supported by the Host Adapter. In
+           Strict Round Robin Mode, the Host Adapter only looks at the next
+           Outgoing Mailbox for each new command, rather than scanning
+           through all the Outgoing Mailboxes to find any that have new
+           commands in them.  Strict Round Robin Mode is significantly more
+           efficient.
          */
-        if (HostAdapter->StrictRoundRobinModeSupport) {
-                RoundRobinModeRequest = BusLogic_StrictRoundRobinMode;
-                if (BusLogic_Command(HostAdapter, BusLogic_EnableStrictRoundRobinMode, &RoundRobinModeRequest, sizeof(RoundRobinModeRequest), NULL, 0) < 0)
-                        return BusLogic_Failure(HostAdapter, "ENABLE STRICT ROUND ROBIN MODE");
+        if (adapter->strict_rr) {
+                rr_req = BLOGIC_STRICT_RR_MODE;
+                if (blogic_cmd(adapter, BLOGIC_STRICT_RR, &rr_req,
+                                        sizeof(rr_req), NULL, 0) < 0)
+                        return blogic_failure(adapter,
+                                        "ENABLE STRICT ROUND ROBIN MODE");
         }
+
         /*
-           For Host Adapters that support Extended LUN Format CCBs, issue the Set CCB
-           Format command to allow 32 Logical Units per Target Device.
+           For Host Adapters that support Extended LUN Format CCBs, issue the
+           Set CCB Format command to allow 32 Logical Units per Target Device.
          */
-        if (HostAdapter->ExtendedLUNSupport) {
-                SetCCBFormatRequest = BusLogic_ExtendedLUNFormatCCB;
-                if (BusLogic_Command(HostAdapter, BusLogic_SetCCBFormat, &SetCCBFormatRequest, sizeof(SetCCBFormatRequest), NULL, 0) < 0)
-                        return BusLogic_Failure(HostAdapter, "SET CCB FORMAT");
+        if (adapter->ext_lun) {
+                setccb_fmt = BLOGIC_EXT_LUN_CCB;
+                if (blogic_cmd(adapter, BLOGIC_SETCCB_FMT, &setccb_fmt,
+                                        sizeof(setccb_fmt), NULL, 0) < 0)
+                        return blogic_failure(adapter, "SET CCB FORMAT");
         }
+
         /*
            Announce Successful Initialization.
          */
-      Done:
-        if (!HostAdapter->HostAdapterInitialized) {
-                BusLogic_Info("*** %s Initialized Successfully ***\n", HostAdapter, HostAdapter->FullModelName);
-                BusLogic_Info("\n", HostAdapter);
+done:
+        if (!adapter->adapter_initd) {
+                blogic_info("*** %s Initialized Successfully ***\n", adapter,
+                                adapter->full_model);
+                blogic_info("\n", adapter);
         } else
-                BusLogic_Warning("*** %s Initialized Successfully ***\n", HostAdapter, HostAdapter->FullModelName);
-        HostAdapter->HostAdapterInitialized = true;
+                blogic_warn("*** %s Initialized Successfully ***\n", adapter,
+                                adapter->full_model);
+        adapter->adapter_initd = true;
+
         /*
            Indicate the Host Adapter Initialization completed successfully.
          */
@@ -2003,109 +2166,116 @@ static bool BusLogic_InitializeHostAdapter(struct BusLogic_HostAdapter
 
 
 /*
-  BusLogic_TargetDeviceInquiry inquires about the Target Devices accessible
+  blogic_inquiry inquires about the Target Devices accessible
   through Host Adapter.
 */
 
-static bool __init BusLogic_TargetDeviceInquiry(struct BusLogic_HostAdapter
-                                                   *HostAdapter)
+static bool __init blogic_inquiry(struct blogic_adapter *adapter)
 {
-        u16 InstalledDevices;
-        u8 InstalledDevicesID0to7[8];
-        struct BusLogic_SetupInformation SetupInformation;
-        u8 SynchronousPeriod[BusLogic_MaxTargetDevices];
-        unsigned char RequestedReplyLength;
-        int TargetID;
+        u16 installed_devs;
+        u8 installed_devs0to7[8];
+        struct blogic_setup_info setupinfo;
+        u8 sync_period[BLOGIC_MAXDEV];
+        unsigned char req_replylen;
+        int tgt_id;
+
         /*
-           Wait a few seconds between the Host Adapter Hard Reset which initiates
-           a SCSI Bus Reset and issuing any SCSI Commands.  Some SCSI devices get
-           confused if they receive SCSI Commands too soon after a SCSI Bus Reset.
+           Wait a few seconds between the Host Adapter Hard Reset which
+           initiates a SCSI Bus Reset and issuing any SCSI Commands. Some
+           SCSI devices get confused if they receive SCSI Commands too soon
+           after a SCSI Bus Reset.
          */
-        BusLogic_Delay(HostAdapter->BusSettleTime);
+        blogic_delay(adapter->bus_settle_time);
         /*
            FlashPoint Host Adapters do not provide for Target Device Inquiry.
          */
-        if (BusLogic_FlashPointHostAdapterP(HostAdapter))
+        if (blogic_flashpoint_type(adapter))
                 return true;
         /*
            Inhibit the Target Device Inquiry if requested.
          */
-        if (HostAdapter->DriverOptions != NULL && HostAdapter->DriverOptions->LocalOptions.InhibitTargetInquiry)
+        if (adapter->drvr_opts != NULL && adapter->drvr_opts->stop_tgt_inquiry)
                 return true;
         /*
-           Issue the Inquire Target Devices command for host adapters with firmware
-           version 4.25 or later, or the Inquire Installed Devices ID 0 to 7 command
-           for older host adapters.  This is necessary to force Synchronous Transfer
-           Negotiation so that the Inquire Setup Information and Inquire Synchronous
-           Period commands will return valid data.  The Inquire Target Devices command
-           is preferable to Inquire Installed Devices ID 0 to 7 since it only probes
-           Logical Unit 0 of each Target Device.
+           Issue the Inquire Target Devices command for host adapters with
+           firmware version 4.25 or later, or the Inquire Installed Devices
+           ID 0 to 7 command for older host adapters.  This is necessary to
+           force Synchronous Transfer Negotiation so that the Inquire Setup
+           Information and Inquire Synchronous Period commands will return
+           valid data.  The Inquire Target Devices command is preferable to
+           Inquire Installed Devices ID 0 to 7 since it only probes Logical
+           Unit 0 of each Target Device.
          */
-        if (strcmp(HostAdapter->FirmwareVersion, "4.25") >= 0) {
+        if (strcmp(adapter->fw_ver, "4.25") >= 0) {
 
                 /*
-                 * Issue a Inquire Target Devices command.  Inquire Target Devices only
-                 * tests Logical Unit 0 of each Target Device unlike the Inquire Installed
-                 * Devices commands which test Logical Units 0 - 7.  Two bytes are
-                 * returned, where byte 0 bit 0 set indicates that Target Device 0 exists,
-                 * and so on.
+                   Issue a Inquire Target Devices command. Inquire Target
+                   Devices only tests Logical Unit 0 of each Target Device
+                   unlike the Inquire Installed Devices commands which test
+                   Logical Units 0 - 7.  Two bytes are returned, where byte
+                   0 bit 0 set indicates that Target Device 0 exists, and so on.
                  */
 
-                if (BusLogic_Command(HostAdapter, BusLogic_InquireTargetDevices, NULL, 0, &InstalledDevices, sizeof(InstalledDevices))
-                    != sizeof(InstalledDevices))
-                        return BusLogic_Failure(HostAdapter, "INQUIRE TARGET DEVICES");
-                for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
-                        HostAdapter->TargetFlags[TargetID].TargetExists = (InstalledDevices & (1 << TargetID) ? true : false);
+                if (blogic_cmd(adapter, BLOGIC_INQ_DEV, NULL, 0,
+                                        &installed_devs, sizeof(installed_devs))
+                    != sizeof(installed_devs))
+                        return blogic_failure(adapter, "INQUIRE TARGET DEVICES");
+                for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)
+                        adapter->tgt_flags[tgt_id].tgt_exists =
+                                (installed_devs & (1 << tgt_id) ? true : false);
         } else {
 
                 /*
-                 * Issue an Inquire Installed Devices command.  For each Target Device,
-                 * a byte is returned where bit 0 set indicates that Logical Unit 0
-                 * exists, bit 1 set indicates that Logical Unit 1 exists, and so on.
+                   Issue an Inquire Installed Devices command. For each
+                   Target Device, a byte is returned where bit 0 set
+                   indicates that Logical Unit 0 * exists, bit 1 set
+                   indicates that Logical Unit 1 exists, and so on.
                  */
 
-                if (BusLogic_Command(HostAdapter, BusLogic_InquireInstalledDevicesID0to7, NULL, 0, &InstalledDevicesID0to7, sizeof(InstalledDevicesID0to7))
-                    != sizeof(InstalledDevicesID0to7))
-                        return BusLogic_Failure(HostAdapter, "INQUIRE INSTALLED DEVICES ID 0 TO 7");
-                for (TargetID = 0; TargetID < 8; TargetID++)
-                        HostAdapter->TargetFlags[TargetID].TargetExists = (InstalledDevicesID0to7[TargetID] != 0 ? true : false);
+                if (blogic_cmd(adapter, BLOGIC_INQ_DEV0TO7, NULL, 0,
+                                &installed_devs0to7, sizeof(installed_devs0to7))
+                    != sizeof(installed_devs0to7))
+                        return blogic_failure(adapter,
+                                        "INQUIRE INSTALLED DEVICES ID 0 TO 7");
+                for (tgt_id = 0; tgt_id < 8; tgt_id++)
+                        adapter->tgt_flags[tgt_id].tgt_exists =
+                                (installed_devs0to7[tgt_id] != 0 ? true : false);
         }
         /*
            Issue the Inquire Setup Information command.
          */
-        RequestedReplyLength = sizeof(SetupInformation);
-        if (BusLogic_Command(HostAdapter, BusLogic_InquireSetupInformation, &RequestedReplyLength, sizeof(RequestedReplyLength), &SetupInformation, sizeof(SetupInformation))
-            != sizeof(SetupInformation))
-                return BusLogic_Failure(HostAdapter, "INQUIRE SETUP INFORMATION");
-        for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
-                HostAdapter->SynchronousOffset[TargetID] = (TargetID < 8 ? SetupInformation.SynchronousValuesID0to7[TargetID].Offset : SetupInformation.SynchronousValuesID8to15[TargetID - 8].Offset);
-        if (strcmp(HostAdapter->FirmwareVersion, "5.06L") >= 0)
-                for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
-                        HostAdapter->TargetFlags[TargetID].WideTransfersActive = (TargetID < 8 ? (SetupInformation.WideTransfersActiveID0to7 & (1 << TargetID)
-                                                                                                  ? true : false)
-                                                                                  : (SetupInformation.WideTransfersActiveID8to15 & (1 << (TargetID - 8))
-                                                                                     ? true : false));
+        req_replylen = sizeof(setupinfo);
+        if (blogic_cmd(adapter, BLOGIC_INQ_SETUPINFO, &req_replylen,
+                        sizeof(req_replylen), &setupinfo, sizeof(setupinfo))
+            != sizeof(setupinfo))
+                return blogic_failure(adapter, "INQUIRE SETUP INFORMATION");
+        for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)
+                adapter->sync_offset[tgt_id] = (tgt_id < 8 ? setupinfo.sync0to7[tgt_id].offset : setupinfo.sync8to15[tgt_id - 8].offset);
+        if (strcmp(adapter->fw_ver, "5.06L") >= 0)
+                for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)
+                        adapter->tgt_flags[tgt_id].wide_active = (tgt_id < 8 ? (setupinfo.wide_tx_active0to7 & (1 << tgt_id) ? true : false) : (setupinfo.wide_tx_active8to15 & (1 << (tgt_id - 8)) ? true : false));
         /*
            Issue the Inquire Synchronous Period command.
          */
-        if (HostAdapter->FirmwareVersion[0] >= '3') {
+        if (adapter->fw_ver[0] >= '3') {
 
-                /* Issue a Inquire Synchronous Period command.  For each Target Device,
-                 * a byte is returned which represents the Synchronous Transfer Period
-                 * in units of 10 nanoseconds.
+                /* Issue a Inquire Synchronous Period command. For each
+                   Target Device, a byte is returned which represents the
+                   Synchronous Transfer Period in units of 10 nanoseconds.
                  */
 
-                RequestedReplyLength = sizeof(SynchronousPeriod);
-                if (BusLogic_Command(HostAdapter, BusLogic_InquireSynchronousPeriod, &RequestedReplyLength, sizeof(RequestedReplyLength), &SynchronousPeriod, sizeof(SynchronousPeriod))
-                    != sizeof(SynchronousPeriod))
-                        return BusLogic_Failure(HostAdapter, "INQUIRE SYNCHRONOUS PERIOD");
-                for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
-                        HostAdapter->SynchronousPeriod[TargetID] = SynchronousPeriod[TargetID];
+                req_replylen = sizeof(sync_period);
+                if (blogic_cmd(adapter, BLOGIC_INQ_SYNC_PERIOD, &req_replylen,
+                                sizeof(req_replylen), &sync_period,
+                                sizeof(sync_period)) != sizeof(sync_period))
+                        return blogic_failure(adapter,
+                                        "INQUIRE SYNCHRONOUS PERIOD");
+                for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)
+                        adapter->sync_period[tgt_id] = sync_period[tgt_id];
         } else
-                for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
-                        if (SetupInformation.SynchronousValuesID0to7[TargetID].Offset > 0)
-                                HostAdapter->SynchronousPeriod[TargetID] = 20 + 5 * SetupInformation.SynchronousValuesID0to7[TargetID]
-                                    .TransferPeriod;
+                for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)
+                        if (setupinfo.sync0to7[tgt_id].offset > 0)
+                                adapter->sync_period[tgt_id] = 20 + 5 * setupinfo.sync0to7[tgt_id].tx_period;
         /*
            Indicate the Target Device Inquiry completed successfully.
          */
@@ -2113,7 +2283,7 @@ static bool __init BusLogic_TargetDeviceInquiry(struct BusLogic_HostAdapter
 }
 
 /*
-  BusLogic_InitializeHostStructure initializes the fields in the SCSI Host
+  blogic_inithoststruct initializes the fields in the SCSI Host
   structure.  The base, io_port, n_io_ports, irq, and dma_channel fields in the
   SCSI Host structure are intentionally left uninitialized, as this driver
   handles acquisition and release of these resources explicitly, as well as
@@ -2121,517 +2291,556 @@ static bool __init BusLogic_TargetDeviceInquiry(struct BusLogic_HostAdapter
   through explicit acquisition and release of the Host Adapter's Lock.
 */
 
-static void __init BusLogic_InitializeHostStructure(struct BusLogic_HostAdapter
-                                                    *HostAdapter, struct Scsi_Host *Host)
+static void __init blogic_inithoststruct(struct blogic_adapter *adapter,
+                struct Scsi_Host *host)
 {
-        Host->max_id = HostAdapter->MaxTargetDevices;
-        Host->max_lun = HostAdapter->MaxLogicalUnits;
-        Host->max_channel = 0;
-        Host->unique_id = HostAdapter->IO_Address;
-        Host->this_id = HostAdapter->SCSI_ID;
-        Host->can_queue = HostAdapter->DriverQueueDepth;
-        Host->sg_tablesize = HostAdapter->DriverScatterGatherLimit;
-        Host->unchecked_isa_dma = HostAdapter->BounceBuffersRequired;
-        Host->cmd_per_lun = HostAdapter->UntaggedQueueDepth;
+        host->max_id = adapter->maxdev;
+        host->max_lun = adapter->maxlun;
+        host->max_channel = 0;
+        host->unique_id = adapter->io_addr;
+        host->this_id = adapter->scsi_id;
+        host->can_queue = adapter->drvr_qdepth;
+        host->sg_tablesize = adapter->drvr_sglimit;
+        host->unchecked_isa_dma = adapter->need_bouncebuf;
+        host->cmd_per_lun = adapter->untag_qdepth;
 }
 
 /*
-  BusLogic_SlaveConfigure will actually set the queue depth on individual
+  blogic_slaveconfig will actually set the queue depth on individual
   scsi devices as they are permanently added to the device chain.  We
   shamelessly rip off the SelectQueueDepths code to make this work mostly
   like it used to.  Since we don't get called once at the end of the scan
   but instead get called for each device, we have to do things a bit
   differently.
 */
-static int BusLogic_SlaveConfigure(struct scsi_device *Device)
+static int blogic_slaveconfig(struct scsi_device *dev)
 {
-        struct BusLogic_HostAdapter *HostAdapter = (struct BusLogic_HostAdapter *) Device->host->hostdata;
-        int TargetID = Device->id;
-        int QueueDepth = HostAdapter->QueueDepth[TargetID];
-
-        if (HostAdapter->TargetFlags[TargetID].TaggedQueuingSupported && (HostAdapter->TaggedQueuingPermitted & (1 << TargetID))) {
-                if (QueueDepth == 0)
-                        QueueDepth = BusLogic_MaxAutomaticTaggedQueueDepth;
-                HostAdapter->QueueDepth[TargetID] = QueueDepth;
-                scsi_adjust_queue_depth(Device, MSG_SIMPLE_TAG, QueueDepth);
+        struct blogic_adapter *adapter =
+                (struct blogic_adapter *) dev->host->hostdata;
+        int tgt_id = dev->id;
+        int qdepth = adapter->qdepth[tgt_id];
+
+        if (adapter->tgt_flags[tgt_id].tagq_ok &&
+                        (adapter->tagq_ok & (1 << tgt_id))) {
+                if (qdepth == 0)
+                        qdepth = BLOGIC_MAX_AUTO_TAG_DEPTH;
+                adapter->qdepth[tgt_id] = qdepth;
+                scsi_adjust_queue_depth(dev, MSG_SIMPLE_TAG, qdepth);
         } else {
-                HostAdapter->TaggedQueuingPermitted &= ~(1 << TargetID);
-                QueueDepth = HostAdapter->UntaggedQueueDepth;
-                HostAdapter->QueueDepth[TargetID] = QueueDepth;
-                scsi_adjust_queue_depth(Device, 0, QueueDepth);
-        }
-        QueueDepth = 0;
-        for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
-                if (HostAdapter->TargetFlags[TargetID].TargetExists) {
-                        QueueDepth += HostAdapter->QueueDepth[TargetID];
-                }
-        if (QueueDepth > HostAdapter->AllocatedCCBs)
-                BusLogic_CreateAdditionalCCBs(HostAdapter, QueueDepth - HostAdapter->AllocatedCCBs, false);
+                adapter->tagq_ok &= ~(1 << tgt_id);
+                qdepth = adapter->untag_qdepth;
+                adapter->qdepth[tgt_id] = qdepth;
+                scsi_adjust_queue_depth(dev, 0, qdepth);
+        }
+        qdepth = 0;
+        for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)
+                if (adapter->tgt_flags[tgt_id].tgt_exists)
+                        qdepth += adapter->qdepth[tgt_id];
+        if (qdepth > adapter->alloc_ccbs)
+                blogic_create_addlccbs(adapter, qdepth - adapter->alloc_ccbs,
+                                false);
         return 0;
 }
 
 /*
-  BusLogic_DetectHostAdapter probes for BusLogic Host Adapters at the standard
+  blogic_init probes for BusLogic Host Adapters at the standard
   I/O Addresses where they may be located, initializing, registering, and
   reporting the configuration of each BusLogic Host Adapter it finds.  It
   returns the number of BusLogic Host Adapters successfully initialized and
   registered.
 */
 
-static int __init BusLogic_init(void)
+static int __init blogic_init(void)
 {
-        int BusLogicHostAdapterCount = 0, DriverOptionsIndex = 0, ProbeIndex;
-        struct BusLogic_HostAdapter *PrototypeHostAdapter;
+        int adapter_count = 0, drvr_optindex = 0, probeindex;
+        struct blogic_adapter *adapter;
         int ret = 0;
 
 #ifdef MODULE
         if (BusLogic)
-                BusLogic_Setup(BusLogic);
+                blogic_setup(BusLogic);
 #endif
 
-        if (BusLogic_ProbeOptions.NoProbe)
+        if (blogic_probe_options.noprobe)
                 return -ENODEV;
-        BusLogic_ProbeInfoList =
-            kzalloc(BusLogic_MaxHostAdapters * sizeof(struct BusLogic_ProbeInfo), GFP_KERNEL);
-        if (BusLogic_ProbeInfoList == NULL) {
-                BusLogic_Error("BusLogic: Unable to allocate Probe Info List\n", NULL);
+        blogic_probeinfo_list =
+            kzalloc(BLOGIC_MAX_ADAPTERS * sizeof(struct blogic_probeinfo),
+                            GFP_KERNEL);
+        if (blogic_probeinfo_list == NULL) {
+                blogic_err("BusLogic: Unable to allocate Probe Info List\n",
+                                NULL);
                 return -ENOMEM;
         }
 
-        PrototypeHostAdapter =
-            kzalloc(sizeof(struct BusLogic_HostAdapter), GFP_KERNEL);
-        if (PrototypeHostAdapter == NULL) {
-                kfree(BusLogic_ProbeInfoList);
-                BusLogic_Error("BusLogic: Unable to allocate Prototype " "Host Adapter\n", NULL);
+        adapter =
+            kzalloc(sizeof(struct blogic_adapter), GFP_KERNEL);
+        if (adapter == NULL) {
+                kfree(blogic_probeinfo_list);
+                blogic_err("BusLogic: Unable to allocate Prototype Host Adapter\n", NULL);
                 return -ENOMEM;
         }
 
 #ifdef MODULE
         if (BusLogic != NULL)
-                BusLogic_Setup(BusLogic);
+                blogic_setup(BusLogic);
 #endif
-        BusLogic_InitializeProbeInfoList(PrototypeHostAdapter);
-        for (ProbeIndex = 0; ProbeIndex < BusLogic_ProbeInfoCount; ProbeIndex++) {
-                struct BusLogic_ProbeInfo *ProbeInfo = &BusLogic_ProbeInfoList[ProbeIndex];
-                struct BusLogic_HostAdapter *HostAdapter = PrototypeHostAdapter;
-                struct Scsi_Host *Host;
-                if (ProbeInfo->IO_Address == 0)
+        blogic_init_probeinfo_list(adapter);
+        for (probeindex = 0; probeindex < blogic_probeinfo_count; probeindex++) {
+                struct blogic_probeinfo *probeinfo =
+                        &blogic_probeinfo_list[probeindex];
+                struct blogic_adapter *myadapter = adapter;
+                struct Scsi_Host *host;
+
+                if (probeinfo->io_addr == 0)
                         continue;
-                memset(HostAdapter, 0, sizeof(struct BusLogic_HostAdapter));
-                HostAdapter->HostAdapterType = ProbeInfo->HostAdapterType;
-                HostAdapter->HostAdapterBusType = ProbeInfo->HostAdapterBusType;
-                HostAdapter->IO_Address = ProbeInfo->IO_Address;
-                HostAdapter->PCI_Address = ProbeInfo->PCI_Address;
-                HostAdapter->Bus = ProbeInfo->Bus;
-                HostAdapter->Device = ProbeInfo->Device;
-                HostAdapter->PCI_Device = ProbeInfo->PCI_Device;
-                HostAdapter->IRQ_Channel = ProbeInfo->IRQ_Channel;
-                HostAdapter->AddressCount = BusLogic_HostAdapterAddressCount[HostAdapter->HostAdapterType];
+                memset(myadapter, 0, sizeof(struct blogic_adapter));
+                myadapter->adapter_type = probeinfo->adapter_type;
+                myadapter->adapter_bus_type = probeinfo->adapter_bus_type;
+                myadapter->io_addr = probeinfo->io_addr;
+                myadapter->pci_addr = probeinfo->pci_addr;
+                myadapter->bus = probeinfo->bus;
+                myadapter->dev = probeinfo->dev;
+                myadapter->pci_device = probeinfo->pci_device;
+                myadapter->irq_ch = probeinfo->irq_ch;
+                myadapter->addr_count =
+                        blogic_adapter_addr_count[myadapter->adapter_type];
 
                 /*
                    Make sure region is free prior to probing.
                  */
-                if (!request_region(HostAdapter->IO_Address, HostAdapter->AddressCount,
+                if (!request_region(myadapter->io_addr, myadapter->addr_count,
                                         "BusLogic"))
                         continue;
                 /*
-                   Probe the Host Adapter.  If unsuccessful, abort further initialization.
+                   Probe the Host Adapter. If unsuccessful, abort further
+                   initialization.
                  */
-                if (!BusLogic_ProbeHostAdapter(HostAdapter)) {
-                        release_region(HostAdapter->IO_Address, HostAdapter->AddressCount);
+                if (!blogic_probe(myadapter)) {
+                        release_region(myadapter->io_addr,
+                                        myadapter->addr_count);
                         continue;
                 }
                 /*
                    Hard Reset the Host Adapter.  If unsuccessful, abort further
                    initialization.
                  */
-                if (!BusLogic_HardwareResetHostAdapter(HostAdapter, true)) {
-                        release_region(HostAdapter->IO_Address, HostAdapter->AddressCount);
+                if (!blogic_hwreset(myadapter, true)) {
+                        release_region(myadapter->io_addr,
+                                        myadapter->addr_count);
                         continue;
                 }
                 /*
-                   Check the Host Adapter.  If unsuccessful, abort further initialization.
+                   Check the Host Adapter.  If unsuccessful, abort further
+                   initialization.
                  */
-                if (!BusLogic_CheckHostAdapter(HostAdapter)) {
-                        release_region(HostAdapter->IO_Address, HostAdapter->AddressCount);
+                if (!blogic_checkadapter(myadapter)) {
+                        release_region(myadapter->io_addr,
+                                        myadapter->addr_count);
                         continue;
                 }
                 /*
                    Initialize the Driver Options field if provided.
                  */
-                if (DriverOptionsIndex < BusLogic_DriverOptionsCount)
-                        HostAdapter->DriverOptions = &BusLogic_DriverOptions[DriverOptionsIndex++];
+                if (drvr_optindex < blogic_drvr_options_count)
+                        myadapter->drvr_opts =
+                                &blogic_drvr_options[drvr_optindex++];
                 /*
-                   Announce the Driver Version and Date, Author's Name, Copyright Notice,
-                   and Electronic Mail Address.
+                   Announce the Driver Version and Date, Author's Name,
+                   Copyright Notice, and Electronic Mail Address.
                  */
-                BusLogic_AnnounceDriver(HostAdapter);
+                blogic_announce_drvr(myadapter);
                 /*
                    Register the SCSI Host structure.
                  */
 
-                Host = scsi_host_alloc(&Bus_Logic_template, sizeof(struct BusLogic_HostAdapter));
-                if (Host == NULL) {
-                        release_region(HostAdapter->IO_Address, HostAdapter->AddressCount);
+                host = scsi_host_alloc(&blogic_template,
+                                sizeof(struct blogic_adapter));
+                if (host == NULL) {
+                        release_region(myadapter->io_addr,
+                                        myadapter->addr_count);
                         continue;
                 }
-                HostAdapter = (struct BusLogic_HostAdapter *) Host->hostdata;
-                memcpy(HostAdapter, PrototypeHostAdapter, sizeof(struct BusLogic_HostAdapter));
-                HostAdapter->SCSI_Host = Host;
-                HostAdapter->HostNumber = Host->host_no;
+                myadapter = (struct blogic_adapter *) host->hostdata;
+                memcpy(myadapter, adapter, sizeof(struct blogic_adapter));
+                myadapter->scsi_host = host;
+                myadapter->host_no = host->host_no;
                 /*
-                   Add Host Adapter to the end of the list of registered BusLogic
-                   Host Adapters.
+                   Add Host Adapter to the end of the list of registered
+                   BusLogic Host Adapters.
                  */
-                list_add_tail(&HostAdapter->host_list, &BusLogic_host_list);
+                list_add_tail(&myadapter->host_list, &blogic_host_list);
 
                 /*
-                   Read the Host Adapter Configuration, Configure the Host Adapter,
-                   Acquire the System Resources necessary to use the Host Adapter, then
-                   Create the Initial CCBs, Initialize the Host Adapter, and finally
-                   perform Target Device Inquiry.
-
-                   From this point onward, any failure will be assumed to be due to a
-                   problem with the Host Adapter, rather than due to having mistakenly
-                   identified this port as belonging to a BusLogic Host Adapter.  The
-                   I/O Address range will not be released, thereby preventing it from
-                   being incorrectly identified as any other type of Host Adapter.
+                   Read the Host Adapter Configuration, Configure the Host
+                   Adapter, Acquire the System Resources necessary to use
+                   the Host Adapter, then Create the Initial CCBs, Initialize
+                   the Host Adapter, and finally perform Target Device
+                   Inquiry. From this point onward, any failure will be
+                   assumed to be due to a problem with the Host Adapter,
+                   rather than due to having mistakenly identified this port
+                   as belonging to a BusLogic Host Adapter. The I/O Address
+                   range will not be released, thereby preventing it from
+                   being incorrectly identified as any other type of Host
+                   Adapter.
                  */
-                if (BusLogic_ReadHostAdapterConfiguration(HostAdapter) &&
-                    BusLogic_ReportHostAdapterConfiguration(HostAdapter) &&
-                    BusLogic_AcquireResources(HostAdapter) &&
-                    BusLogic_CreateInitialCCBs(HostAdapter) &&
-                    BusLogic_InitializeHostAdapter(HostAdapter) &&
-                    BusLogic_TargetDeviceInquiry(HostAdapter)) {
+                if (blogic_rdconfig(myadapter) &&
+                    blogic_reportconfig(myadapter) &&
+                    blogic_getres(myadapter) &&
+                    blogic_create_initccbs(myadapter) &&
+                    blogic_initadapter(myadapter) &&
+                    blogic_inquiry(myadapter)) {
                         /*
-                           Initialization has been completed successfully.  Release and
-                           re-register usage of the I/O Address range so that the Model
-                           Name of the Host Adapter will appear, and initialize the SCSI
-                           Host structure.
+                           Initialization has been completed successfully.
+                           Release and re-register usage of the I/O Address
+                           range so that the Model Name of the Host Adapter
+                           will appear, and initialize the SCSI Host structure.
                          */
-                        release_region(HostAdapter->IO_Address,
-                                       HostAdapter->AddressCount);
-                        if (!request_region(HostAdapter->IO_Address,
-                                            HostAdapter->AddressCount,
-                                            HostAdapter->FullModelName)) {
+                        release_region(myadapter->io_addr,
+                                       myadapter->addr_count);
+                        if (!request_region(myadapter->io_addr,
+                                            myadapter->addr_count,
+                                            myadapter->full_model)) {
                                 printk(KERN_WARNING
                                         "BusLogic: Release and re-register of "
                                         "port 0x%04lx failed \n",
-                                        (unsigned long)HostAdapter->IO_Address);
-                                BusLogic_DestroyCCBs(HostAdapter);
-                                BusLogic_ReleaseResources(HostAdapter);
-                                list_del(&HostAdapter->host_list);
-                                scsi_host_put(Host);
+                                        (unsigned long)myadapter->io_addr);
+                                blogic_destroy_ccbs(myadapter);
+                                blogic_relres(myadapter);
+                                list_del(&myadapter->host_list);
+                                scsi_host_put(host);
                                 ret = -ENOMEM;
                         } else {
-                                BusLogic_InitializeHostStructure(HostAdapter,
-                                                                 Host);
-                                if (scsi_add_host(Host, HostAdapter->PCI_Device
-                                                ? &HostAdapter->PCI_Device->dev
+                                blogic_inithoststruct(myadapter,
+                                                                 host);
+                                if (scsi_add_host(host, myadapter->pci_device
+                                                ? &myadapter->pci_device->dev
                                                   : NULL)) {
                                         printk(KERN_WARNING
                                                "BusLogic: scsi_add_host()"
                                                "failed!\n");
-                                        BusLogic_DestroyCCBs(HostAdapter);
-                                        BusLogic_ReleaseResources(HostAdapter);
-                                        list_del(&HostAdapter->host_list);
-                                        scsi_host_put(Host);
+                                        blogic_destroy_ccbs(myadapter);
+                                        blogic_relres(myadapter);
+                                        list_del(&myadapter->host_list);
+                                        scsi_host_put(host);
                                         ret = -ENODEV;
                                 } else {
-                                        scsi_scan_host(Host);
-                                        BusLogicHostAdapterCount++;
+                                        scsi_scan_host(host);
+                                        adapter_count++;
                                 }
                         }
                 } else {
                         /*
-                           An error occurred during Host Adapter Configuration Querying, Host
-                           Adapter Configuration, Resource Acquisition, CCB Creation, Host
-                           Adapter Initialization, or Target Device Inquiry, so remove Host
-                           Adapter from the list of registered BusLogic Host Adapters, destroy
-                           the CCBs, Release the System Resources, and Unregister the SCSI
+                           An error occurred during Host Adapter Configuration
+                           Querying, Host Adapter Configuration, Resource
+                           Acquisition, CCB Creation, Host Adapter
+                           Initialization, or Target Device Inquiry, so
+                           remove Host Adapter from the list of registered
+                           BusLogic Host Adapters, destroy the CCBs, Release
+                           the System Resources, and Unregister the SCSI
                            Host.
                          */
-                        BusLogic_DestroyCCBs(HostAdapter);
-                        BusLogic_ReleaseResources(HostAdapter);
-                        list_del(&HostAdapter->host_list);
-                        scsi_host_put(Host);
+                        blogic_destroy_ccbs(myadapter);
+                        blogic_relres(myadapter);
+                        list_del(&myadapter->host_list);
+                        scsi_host_put(host);
                         ret = -ENODEV;
                 }
         }
-        kfree(PrototypeHostAdapter);
-        kfree(BusLogic_ProbeInfoList);
-        BusLogic_ProbeInfoList = NULL;
+        kfree(adapter);
+        kfree(blogic_probeinfo_list);
+        blogic_probeinfo_list = NULL;
         return ret;
 }
 
 
 /*
-  BusLogic_ReleaseHostAdapter releases all resources previously acquired to
+  blogic_deladapter releases all resources previously acquired to
   support a specific Host Adapter, including the I/O Address range, and
   unregisters the BusLogic Host Adapter.
 */
 
-static int __exit BusLogic_ReleaseHostAdapter(struct BusLogic_HostAdapter *HostAdapter)
+static int __exit blogic_deladapter(struct blogic_adapter *adapter)
 {
-        struct Scsi_Host *Host = HostAdapter->SCSI_Host;
+        struct Scsi_Host *host = adapter->scsi_host;
 
-        scsi_remove_host(Host);
+        scsi_remove_host(host);
 
         /*
            FlashPoint Host Adapters must first be released by the FlashPoint
            SCCB Manager.
          */
-        if (BusLogic_FlashPointHostAdapterP(HostAdapter))
-                FlashPoint_ReleaseHostAdapter(HostAdapter->CardHandle);
+        if (blogic_flashpoint_type(adapter))
+                FlashPoint_ReleaseHostAdapter(adapter->cardhandle);
         /*
            Destroy the CCBs and release any system resources acquired to
            support Host Adapter.
          */
-        BusLogic_DestroyCCBs(HostAdapter);
-        BusLogic_ReleaseResources(HostAdapter);
+        blogic_destroy_ccbs(adapter);
+        blogic_relres(adapter);
         /*
            Release usage of the I/O Address range.
          */
-        release_region(HostAdapter->IO_Address, HostAdapter->AddressCount);
+        release_region(adapter->io_addr, adapter->addr_count);
         /*
-           Remove Host Adapter from the list of registered BusLogic Host Adapters.
+           Remove Host Adapter from the list of registered BusLogic
+           Host Adapters.
          */
-        list_del(&HostAdapter->host_list);
+        list_del(&adapter->host_list);
 
-        scsi_host_put(Host);
+        scsi_host_put(host);
         return 0;
 }
 
 
 /*
-  BusLogic_QueueCompletedCCB queues CCB for completion processing.
+  blogic_qcompleted_ccb queues CCB for completion processing.
 */
 
-static void BusLogic_QueueCompletedCCB(struct BusLogic_CCB *CCB)
+static void blogic_qcompleted_ccb(struct blogic_ccb *ccb)
 {
-        struct BusLogic_HostAdapter *HostAdapter = CCB->HostAdapter;
-        CCB->Status = BusLogic_CCB_Completed;
-        CCB->Next = NULL;
-        if (HostAdapter->FirstCompletedCCB == NULL) {
-                HostAdapter->FirstCompletedCCB = CCB;
-                HostAdapter->LastCompletedCCB = CCB;
+        struct blogic_adapter *adapter = ccb->adapter;
+
+        ccb->status = BLOGIC_CCB_COMPLETE;
+        ccb->next = NULL;
+        if (adapter->firstccb == NULL) {
+                adapter->firstccb = ccb;
+                adapter->lastccb = ccb;
         } else {
-                HostAdapter->LastCompletedCCB->Next = CCB;
-                HostAdapter->LastCompletedCCB = CCB;
+                adapter->lastccb->next = ccb;
+                adapter->lastccb = ccb;
         }
-        HostAdapter->ActiveCommands[CCB->TargetID]--;
+        adapter->active_cmds[ccb->tgt_id]--;
 }
 
 
 /*
-  BusLogic_ComputeResultCode computes a SCSI Subsystem Result Code from
+  blogic_resultcode computes a SCSI Subsystem Result Code from
   the Host Adapter Status and Target Device Status.
 */
 
-static int BusLogic_ComputeResultCode(struct BusLogic_HostAdapter *HostAdapter, enum BusLogic_HostAdapterStatus HostAdapterStatus, enum BusLogic_TargetDeviceStatus TargetDeviceStatus)
+static int blogic_resultcode(struct blogic_adapter *adapter,
+                enum blogic_adapter_status adapter_status,
+                enum blogic_tgt_status tgt_status)
 {
-        int HostStatus;
-        switch (HostAdapterStatus) {
-        case BusLogic_CommandCompletedNormally:
-        case BusLogic_LinkedCommandCompleted:
-        case BusLogic_LinkedCommandCompletedWithFlag:
-                HostStatus = DID_OK;
+        int hoststatus;
+
+        switch (adapter_status) {
+        case BLOGIC_CMD_CMPLT_NORMAL:
+        case BLOGIC_LINK_CMD_CMPLT:
+        case BLOGIC_LINK_CMD_CMPLT_FLAG:
+                hoststatus = DID_OK;
                 break;
-        case BusLogic_SCSISelectionTimeout:
-                HostStatus = DID_TIME_OUT;
+        case BLOGIC_SELECT_TIMEOUT:
+                hoststatus = DID_TIME_OUT;
                 break;
-        case BusLogic_InvalidOutgoingMailboxActionCode:
-        case BusLogic_InvalidCommandOperationCode:
-        case BusLogic_InvalidCommandParameter:
-                BusLogic_Warning("BusLogic Driver Protocol Error 0x%02X\n", HostAdapter, HostAdapterStatus);
-        case BusLogic_DataUnderRun:
-        case BusLogic_DataOverRun:
-        case BusLogic_UnexpectedBusFree:
-        case BusLogic_LinkedCCBhasInvalidLUN:
-        case BusLogic_AutoRequestSenseFailed:
-        case BusLogic_TaggedQueuingMessageRejected:
-        case BusLogic_UnsupportedMessageReceived:
-        case BusLogic_HostAdapterHardwareFailed:
-        case BusLogic_TargetDeviceReconnectedImproperly:
-        case BusLogic_AbortQueueGenerated:
-        case BusLogic_HostAdapterSoftwareError:
-        case BusLogic_HostAdapterHardwareTimeoutError:
-        case BusLogic_SCSIParityErrorDetected:
-                HostStatus = DID_ERROR;
+        case BLOGIC_INVALID_OUTBOX_CODE:
+        case BLOGIC_INVALID_CMD_CODE:
+        case BLOGIC_BAD_CMD_PARAM:
+                blogic_warn("BusLogic Driver Protocol Error 0x%02X\n",
+                                adapter, adapter_status);
+        case BLOGIC_DATA_UNDERRUN:
+        case BLOGIC_DATA_OVERRUN:
+        case BLOGIC_NOEXPECT_BUSFREE:
+        case BLOGIC_LINKCCB_BADLUN:
+        case BLOGIC_AUTOREQSENSE_FAIL:
+        case BLOGIC_TAGQUEUE_REJECT:
+        case BLOGIC_BAD_MSG_RCVD:
+        case BLOGIC_HW_FAIL:
+        case BLOGIC_BAD_RECONNECT:
+        case BLOGIC_ABRT_QUEUE:
+        case BLOGIC_ADAPTER_SW_ERROR:
+        case BLOGIC_HW_TIMEOUT:
+        case BLOGIC_PARITY_ERR:
+                hoststatus = DID_ERROR;
                 break;
-        case BusLogic_InvalidBusPhaseRequested:
-        case BusLogic_TargetFailedResponseToATN:
-        case BusLogic_HostAdapterAssertedRST:
-        case BusLogic_OtherDeviceAssertedRST:
-        case BusLogic_HostAdapterAssertedBusDeviceReset:
-                HostStatus = DID_RESET;
+        case BLOGIC_INVALID_BUSPHASE:
+        case BLOGIC_NORESPONSE_TO_ATN:
+        case BLOGIC_HW_RESET:
+        case BLOGIC_RST_FROM_OTHERDEV:
+        case BLOGIC_HW_BDR:
+                hoststatus = DID_RESET;
                 break;
         default:
-                BusLogic_Warning("Unknown Host Adapter Status 0x%02X\n", HostAdapter, HostAdapterStatus);
-                HostStatus = DID_ERROR;
+                blogic_warn("Unknown Host Adapter Status 0x%02X\n", adapter,
+                                adapter_status);
+                hoststatus = DID_ERROR;
                 break;
         }
-        return (HostStatus << 16) | TargetDeviceStatus;
+        return (hoststatus << 16) | tgt_status;
 }
 
 
 /*
-  BusLogic_ScanIncomingMailboxes scans the Incoming Mailboxes saving any
+  blogic_scan_inbox scans the Incoming Mailboxes saving any
   Incoming Mailbox entries for completion processing.
 */
 
-static void BusLogic_ScanIncomingMailboxes(struct BusLogic_HostAdapter *HostAdapter)
+static void blogic_scan_inbox(struct blogic_adapter *adapter)
 {
         /*
-           Scan through the Incoming Mailboxes in Strict Round Robin fashion, saving
-           any completed CCBs for further processing.  It is essential that for each
-           CCB and SCSI Command issued, command completion processing is performed
-           exactly once.  Therefore, only Incoming Mailboxes with completion code
-           Command Completed Without Error, Command Completed With Error, or Command
-           Aborted At Host Request are saved for completion processing.  When an
-           Incoming Mailbox has a completion code of Aborted Command Not Found, the
-           CCB had already completed or been aborted before the current Abort request
-           was processed, and so completion processing has already occurred and no
-           further action should be taken.
-         */
-        struct BusLogic_IncomingMailbox *NextIncomingMailbox = HostAdapter->NextIncomingMailbox;
-        enum BusLogic_CompletionCode CompletionCode;
-        while ((CompletionCode = NextIncomingMailbox->CompletionCode) != BusLogic_IncomingMailboxFree) {
+           Scan through the Incoming Mailboxes in Strict Round Robin
+           fashion, saving any completed CCBs for further processing. It
+           is essential that for each CCB and SCSI Command issued, command
+           completion processing is performed exactly once.  Therefore,
+           only Incoming Mailboxes with completion code Command Completed
+           Without Error, Command Completed With Error, or Command Aborted
+           At Host Request are saved for completion processing. When an
+           Incoming Mailbox has a completion code of Aborted Command Not
+           Found, the CCB had already completed or been aborted before the
+           current Abort request was processed, and so completion processing
+           has already occurred and no further action should be taken.
+         */
+        struct blogic_inbox *next_inbox = adapter->next_inbox;
+        enum blogic_cmplt_code comp_code;
+
+        while ((comp_code = next_inbox->comp_code) != BLOGIC_INBOX_FREE) {
                 /*
-                   We are only allowed to do this because we limit our architectures we
-                   run on to machines where bus_to_virt() actually works.  There *needs*
-                   to be a dma_addr_to_virt() in the new PCI DMA mapping interface to
-                   replace bus_to_virt() or else this code is going to become very
+                   We are only allowed to do this because we limit our
+                   architectures we run on to machines where bus_to_virt(
+                   actually works.  There *needs* to be a dma_addr_to_virt()
+                   in the new PCI DMA mapping interface to replace
+                   bus_to_virt() or else this code is going to become very
                    innefficient.
                  */
-                struct BusLogic_CCB *CCB = (struct BusLogic_CCB *) Bus_to_Virtual(NextIncomingMailbox->CCB);
-                if (CompletionCode != BusLogic_AbortedCommandNotFound) {
-                        if (CCB->Status == BusLogic_CCB_Active || CCB->Status == BusLogic_CCB_Reset) {
+                struct blogic_ccb *ccb =
+                        (struct blogic_ccb *) bus_to_virt(next_inbox->ccb);
+                if (comp_code != BLOGIC_CMD_NOTFOUND) {
+                        if (ccb->status == BLOGIC_CCB_ACTIVE ||
+                                        ccb->status == BLOGIC_CCB_RESET) {
                                 /*
-                                   Save the Completion Code for this CCB and queue the CCB
-                                   for completion processing.
+                                   Save the Completion Code for this CCB and
+                                   queue the CCB for completion processing.
                                  */
-                                CCB->CompletionCode = CompletionCode;
-                                BusLogic_QueueCompletedCCB(CCB);
+                                ccb->comp_code = comp_code;
+                                blogic_qcompleted_ccb(ccb);
                         } else {
                                 /*
-                                   If a CCB ever appears in an Incoming Mailbox and is not marked
-                                   as status Active or Reset, then there is most likely a bug in
+                                   If a CCB ever appears in an Incoming Mailbox
+                                   and is not marked as status Active or Reset,
+                                   then there is most likely a bug in
                                    the Host Adapter firmware.
                                  */
-                                BusLogic_Warning("Illegal CCB #%ld status %d in " "Incoming Mailbox\n", HostAdapter, CCB->SerialNumber, CCB->Status);
+                                blogic_warn("Illegal CCB #%ld status %d in " "Incoming Mailbox\n", adapter, ccb->serial, ccb->status);
                         }
                 }
-                NextIncomingMailbox->CompletionCode = BusLogic_IncomingMailboxFree;
-                if (++NextIncomingMailbox > HostAdapter->LastIncomingMailbox)
-                        NextIncomingMailbox = HostAdapter->FirstIncomingMailbox;
+                next_inbox->comp_code = BLOGIC_INBOX_FREE;
+                if (++next_inbox > adapter->last_inbox)
+                        next_inbox = adapter->first_inbox;
         }
-        HostAdapter->NextIncomingMailbox = NextIncomingMailbox;
+        adapter->next_inbox = next_inbox;
 }
 
 
 /*
-  BusLogic_ProcessCompletedCCBs iterates over the completed CCBs for Host
+  blogic_process_ccbs iterates over the completed CCBs for Host
   Adapter setting the SCSI Command Result Codes, deallocating the CCBs, and
   calling the SCSI Subsystem Completion Routines.  The Host Adapter's Lock
   should already have been acquired by the caller.
 */
 
-static void BusLogic_ProcessCompletedCCBs(struct BusLogic_HostAdapter *HostAdapter)
+static void blogic_process_ccbs(struct blogic_adapter *adapter)
 {
-        if (HostAdapter->ProcessCompletedCCBsActive)
+        if (adapter->processing_ccbs)
                 return;
-        HostAdapter->ProcessCompletedCCBsActive = true;
-        while (HostAdapter->FirstCompletedCCB != NULL) {
-                struct BusLogic_CCB *CCB = HostAdapter->FirstCompletedCCB;
-                struct scsi_cmnd *Command = CCB->Command;
-                HostAdapter->FirstCompletedCCB = CCB->Next;
-                if (HostAdapter->FirstCompletedCCB == NULL)
-                        HostAdapter->LastCompletedCCB = NULL;
+        adapter->processing_ccbs = true;
+        while (adapter->firstccb != NULL) {
+                struct blogic_ccb *ccb = adapter->firstccb;
+                struct scsi_cmnd *command = ccb->command;
+                adapter->firstccb = ccb->next;
+                if (adapter->firstccb == NULL)
+                        adapter->lastccb = NULL;
                 /*
                    Process the Completed CCB.
                  */
-                if (CCB->Opcode == BusLogic_BusDeviceReset) {
-                        int TargetID = CCB->TargetID;
-                        BusLogic_Warning("Bus Device Reset CCB #%ld to Target " "%d Completed\n", HostAdapter, CCB->SerialNumber, TargetID);
-                        BusLogic_IncrementErrorCounter(&HostAdapter->TargetStatistics[TargetID].BusDeviceResetsCompleted);
-                        HostAdapter->TargetFlags[TargetID].TaggedQueuingActive = false;
-                        HostAdapter->CommandsSinceReset[TargetID] = 0;
-                        HostAdapter->LastResetCompleted[TargetID] = jiffies;
+                if (ccb->opcode == BLOGIC_BDR) {
+                        int tgt_id = ccb->tgt_id;
+
+                        blogic_warn("Bus Device Reset CCB #%ld to Target " "%d Completed\n", adapter, ccb->serial, tgt_id);
+                        blogic_inc_count(&adapter->tgt_stats[tgt_id].bdr_done);
+                        adapter->tgt_flags[tgt_id].tagq_active = false;
+                        adapter->cmds_since_rst[tgt_id] = 0;
+                        adapter->last_resetdone[tgt_id] = jiffies;
                         /*
                            Place CCB back on the Host Adapter's free list.
                          */
-                        BusLogic_DeallocateCCB(CCB);
+                        blogic_dealloc_ccb(ccb);
 #if 0                           /* this needs to be redone different for new EH */
                         /*
-                           Bus Device Reset CCBs have the Command field non-NULL only when a
-                           Bus Device Reset was requested for a Command that did not have a
-                           currently active CCB in the Host Adapter (i.e., a Synchronous
-                           Bus Device Reset), and hence would not have its Completion Routine
-                           called otherwise.
+                           Bus Device Reset CCBs have the command field
+                           non-NULL only when a Bus Device Reset was requested
+                           for a command that did not have a currently active
+                           CCB in the Host Adapter (i.e., a Synchronous Bus
+                           Device Reset), and hence would not have its
+                           Completion Routine called otherwise.
                          */
-                        while (Command != NULL) {
-                                struct scsi_cmnd *NextCommand = Command->reset_chain;
-                                Command->reset_chain = NULL;
-                                Command->result = DID_RESET << 16;
-                                Command->scsi_done(Command);
-                                Command = NextCommand;
+                        while (command != NULL) {
+                                struct scsi_cmnd *nxt_cmd =
+                                        command->reset_chain;
+                                command->reset_chain = NULL;
+                                command->result = DID_RESET << 16;
+                                command->scsi_done(command);
+                                command = nxt_cmd;
                         }
 #endif
                         /*
-                           Iterate over the CCBs for this Host Adapter performing completion
-                           processing for any CCBs marked as Reset for this Target.
+                           Iterate over the CCBs for this Host Adapter
+                           performing completion processing for any CCBs
+                           marked as Reset for this Target.
                          */
-                        for (CCB = HostAdapter->All_CCBs; CCB != NULL; CCB = CCB->NextAll)
-                                if (CCB->Status == BusLogic_CCB_Reset && CCB->TargetID == TargetID) {
-                                        Command = CCB->Command;
-                                        BusLogic_DeallocateCCB(CCB);
-                                        HostAdapter->ActiveCommands[TargetID]--;
-                                        Command->result = DID_RESET << 16;
-                                        Command->scsi_done(Command);
+                        for (ccb = adapter->all_ccbs; ccb != NULL;
+                                        ccb = ccb->next_all)
+                                if (ccb->status == BLOGIC_CCB_RESET &&
+                                                ccb->tgt_id == tgt_id) {
+                                        command = ccb->command;
+                                        blogic_dealloc_ccb(ccb);
+                                        adapter->active_cmds[tgt_id]--;
+                                        command->result = DID_RESET << 16;
+                                        command->scsi_done(command);
                                 }
-                        HostAdapter->BusDeviceResetPendingCCB[TargetID] = NULL;
+                        adapter->bdr_pend[tgt_id] = NULL;
                 } else {
                         /*
-                           Translate the Completion Code, Host Adapter Status, and Target
-                           Device Status into a SCSI Subsystem Result Code.
+                           Translate the Completion Code, Host Adapter Status,
+                           and Target Device Status into a SCSI Subsystem
+                           Result Code.
                          */
-                        switch (CCB->CompletionCode) {
-                        case BusLogic_IncomingMailboxFree:
-                        case BusLogic_AbortedCommandNotFound:
-                        case BusLogic_InvalidCCB:
-                                BusLogic_Warning("CCB #%ld to Target %d Impossible State\n", HostAdapter, CCB->SerialNumber, CCB->TargetID);
+                        switch (ccb->comp_code) {
+                        case BLOGIC_INBOX_FREE:
+                        case BLOGIC_CMD_NOTFOUND:
+                        case BLOGIC_INVALID_CCB:
+                                blogic_warn("CCB #%ld to Target %d Impossible State\n", adapter, ccb->serial, ccb->tgt_id);
                                 break;
-                        case BusLogic_CommandCompletedWithoutError:
-                                HostAdapter->TargetStatistics[CCB->TargetID]
-                                    .CommandsCompleted++;
-                                HostAdapter->TargetFlags[CCB->TargetID]
-                                    .CommandSuccessfulFlag = true;
-                                Command->result = DID_OK << 16;
+                        case BLOGIC_CMD_COMPLETE_GOOD:
+                                adapter->tgt_stats[ccb->tgt_id]
+                                    .cmds_complete++;
+                                adapter->tgt_flags[ccb->tgt_id]
+                                    .cmd_good = true;
+                                command->result = DID_OK << 16;
                                 break;
-                        case BusLogic_CommandAbortedAtHostRequest:
-                                BusLogic_Warning("CCB #%ld to Target %d Aborted\n", HostAdapter, CCB->SerialNumber, CCB->TargetID);
-                                BusLogic_IncrementErrorCounter(&HostAdapter->TargetStatistics[CCB->TargetID]
-                                                               .CommandAbortsCompleted);
-                                Command->result = DID_ABORT << 16;
+                        case BLOGIC_CMD_ABORT_BY_HOST:
+                                blogic_warn("CCB #%ld to Target %d Aborted\n",
+                                        adapter, ccb->serial, ccb->tgt_id);
+                                blogic_inc_count(&adapter->tgt_stats[ccb->tgt_id].aborts_done);
+                                command->result = DID_ABORT << 16;
                                 break;
-                        case BusLogic_CommandCompletedWithError:
-                                Command->result = BusLogic_ComputeResultCode(HostAdapter, CCB->HostAdapterStatus, CCB->TargetDeviceStatus);
-                                if (CCB->HostAdapterStatus != BusLogic_SCSISelectionTimeout) {
-                                        HostAdapter->TargetStatistics[CCB->TargetID]
-                                            .CommandsCompleted++;
-                                        if (BusLogic_GlobalOptions.TraceErrors) {
+                        case BLOGIC_CMD_COMPLETE_ERROR:
+                                command->result = blogic_resultcode(adapter,
+                                        ccb->adapter_status, ccb->tgt_status);
+                                if (ccb->adapter_status != BLOGIC_SELECT_TIMEOUT) {
+                                        adapter->tgt_stats[ccb->tgt_id]
+                                            .cmds_complete++;
+                                        if (blogic_global_options.trace_err) {
                                                 int i;
-                                                BusLogic_Notice("CCB #%ld Target %d: Result %X Host "
-                                                                "Adapter Status %02X " "Target Status %02X\n", HostAdapter, CCB->SerialNumber, CCB->TargetID, Command->result, CCB->HostAdapterStatus, CCB->TargetDeviceStatus);
-                                                BusLogic_Notice("CDB   ", HostAdapter);
-                                                for (i = 0; i < CCB->CDB_Length; i++)
-                                                        BusLogic_Notice(" %02X", HostAdapter, CCB->CDB[i]);
-                                                BusLogic_Notice("\n", HostAdapter);
-                                                BusLogic_Notice("Sense ", HostAdapter);
-                                                for (i = 0; i < CCB->SenseDataLength; i++)
-                                                        BusLogic_Notice(" %02X", HostAdapter, Command->sense_buffer[i]);
-                                                BusLogic_Notice("\n", HostAdapter);
+                                                blogic_notice("CCB #%ld Target %d: Result %X Host "
+                                                                "Adapter Status %02X " "Target Status %02X\n", adapter, ccb->serial, ccb->tgt_id, command->result, ccb->adapter_status, ccb->tgt_status);
+                                                blogic_notice("CDB   ", adapter);
+                                                for (i = 0; i < ccb->cdblen; i++)
+                                                        blogic_notice(" %02X", adapter, ccb->cdb[i]);
+                                                blogic_notice("\n", adapter);
+                                                blogic_notice("Sense ", adapter);
+                                                for (i = 0; i < ccb->sense_datalen; i++)
+                                                        blogic_notice(" %02X", adapter, command->sense_buffer[i]);
+                                                blogic_notice("\n", adapter);
                                         }
                                 }
                                 break;
@@ -2641,141 +2850,145 @@ static void BusLogic_ProcessCompletedCCBs(struct BusLogic_HostAdapter *HostAdapt
                            CmdQue (Tagged Queuing Supported) and WBus16 (16 Bit
                            Wide Data Transfers Supported) bits.
                          */
-                        if (CCB->CDB[0] == INQUIRY && CCB->CDB[1] == 0 && CCB->HostAdapterStatus == BusLogic_CommandCompletedNormally) {
-                                struct BusLogic_TargetFlags *TargetFlags = &HostAdapter->TargetFlags[CCB->TargetID];
-                                struct SCSI_Inquiry *InquiryResult =
-                                        (struct SCSI_Inquiry *) scsi_sglist(Command);
-                                TargetFlags->TargetExists = true;
-                                TargetFlags->TaggedQueuingSupported = InquiryResult->CmdQue;
-                                TargetFlags->WideTransfersSupported = InquiryResult->WBus16;
+                        if (ccb->cdb[0] == INQUIRY && ccb->cdb[1] == 0 &&
+                                ccb->adapter_status == BLOGIC_CMD_CMPLT_NORMAL) {
+                                struct blogic_tgt_flags *tgt_flags =
+                                        &adapter->tgt_flags[ccb->tgt_id];
+                                struct scsi_inquiry *inquiry =
+                                        (struct scsi_inquiry *) scsi_sglist(command);
+                                tgt_flags->tgt_exists = true;
+                                tgt_flags->tagq_ok = inquiry->CmdQue;
+                                tgt_flags->wide_ok = inquiry->WBus16;
                         }
                         /*
                            Place CCB back on the Host Adapter's free list.
                          */
-                        BusLogic_DeallocateCCB(CCB);
+                        blogic_dealloc_ccb(ccb);
                         /*
                            Call the SCSI Command Completion Routine.
                          */
-                        Command->scsi_done(Command);
+                        command->scsi_done(command);
                 }
         }
-        HostAdapter->ProcessCompletedCCBsActive = false;
+        adapter->processing_ccbs = false;
 }
 
 
 /*
-  BusLogic_InterruptHandler handles hardware interrupts from BusLogic Host
+  blogic_inthandler handles hardware interrupts from BusLogic Host
   Adapters.
 */
 
-static irqreturn_t BusLogic_InterruptHandler(int IRQ_Channel, void *DeviceIdentifier)
+static irqreturn_t blogic_inthandler(int irq_ch, void *devid)
 {
-        struct BusLogic_HostAdapter *HostAdapter = (struct BusLogic_HostAdapter *) DeviceIdentifier;
-        unsigned long ProcessorFlags;
+        struct blogic_adapter *adapter = (struct blogic_adapter *) devid;
+        unsigned long processor_flag;
         /*
            Acquire exclusive access to Host Adapter.
          */
-        spin_lock_irqsave(HostAdapter->SCSI_Host->host_lock, ProcessorFlags);
+        spin_lock_irqsave(adapter->scsi_host->host_lock, processor_flag);
         /*
            Handle Interrupts appropriately for each Host Adapter type.
          */
-        if (BusLogic_MultiMasterHostAdapterP(HostAdapter)) {
-                union BusLogic_InterruptRegister InterruptRegister;
+        if (blogic_multimaster_type(adapter)) {
+                union blogic_int_reg intreg;
                 /*
                    Read the Host Adapter Interrupt Register.
                  */
-                InterruptRegister.All = BusLogic_ReadInterruptRegister(HostAdapter);
-                if (InterruptRegister.ir.InterruptValid) {
+                intreg.all = blogic_rdint(adapter);
+                if (intreg.ir.int_valid) {
                         /*
                            Acknowledge the interrupt and reset the Host Adapter
                            Interrupt Register.
                          */
-                        BusLogic_InterruptReset(HostAdapter);
+                        blogic_intreset(adapter);
                         /*
-                           Process valid External SCSI Bus Reset and Incoming Mailbox
-                           Loaded Interrupts.  Command Complete Interrupts are noted,
-                           and Outgoing Mailbox Available Interrupts are ignored, as
-                           they are never enabled.
+                           Process valid External SCSI Bus Reset and Incoming
+                           Mailbox Loaded Interrupts. Command Complete
+                           Interrupts are noted, and Outgoing Mailbox Available
+                           Interrupts are ignored, as they are never enabled.
                          */
-                        if (InterruptRegister.ir.ExternalBusReset)
-                                HostAdapter->HostAdapterExternalReset = true;
-                        else if (InterruptRegister.ir.IncomingMailboxLoaded)
-                                BusLogic_ScanIncomingMailboxes(HostAdapter);
-                        else if (InterruptRegister.ir.CommandComplete)
-                                HostAdapter->HostAdapterCommandCompleted = true;
+                        if (intreg.ir.ext_busreset)
+                                adapter->adapter_extreset = true;
+                        else if (intreg.ir.mailin_loaded)
+                                blogic_scan_inbox(adapter);
+                        else if (intreg.ir.cmd_complete)
+                                adapter->adapter_cmd_complete = true;
                 }
         } else {
                 /*
                    Check if there is a pending interrupt for this Host Adapter.
                  */
-                if (FlashPoint_InterruptPending(HostAdapter->CardHandle))
-                        switch (FlashPoint_HandleInterrupt(HostAdapter->CardHandle)) {
-                        case FlashPoint_NormalInterrupt:
+                if (FlashPoint_InterruptPending(adapter->cardhandle))
+                        switch (FlashPoint_HandleInterrupt(adapter->cardhandle)) {
+                        case FPOINT_NORMAL_INT:
                                 break;
-                        case FlashPoint_ExternalBusReset:
-                                HostAdapter->HostAdapterExternalReset = true;
+                        case FPOINT_EXT_RESET:
+                                adapter->adapter_extreset = true;
                                 break;
-                        case FlashPoint_InternalError:
-                                BusLogic_Warning("Internal FlashPoint Error detected" " - Resetting Host Adapter\n", HostAdapter);
-                                HostAdapter->HostAdapterInternalError = true;
+                        case FPOINT_INTERN_ERR:
+                                blogic_warn("Internal FlashPoint Error detected - Resetting Host Adapter\n", adapter);
+                                adapter->adapter_intern_err = true;
                                 break;
                         }
         }
         /*
            Process any completed CCBs.
          */
-        if (HostAdapter->FirstCompletedCCB != NULL)
-                BusLogic_ProcessCompletedCCBs(HostAdapter);
+        if (adapter->firstccb != NULL)
+                blogic_process_ccbs(adapter);
         /*
            Reset the Host Adapter if requested.
          */
-        if (HostAdapter->HostAdapterExternalReset) {
-                BusLogic_Warning("Resetting %s due to External SCSI Bus Reset\n", HostAdapter, HostAdapter->FullModelName);
-                BusLogic_IncrementErrorCounter(&HostAdapter->ExternalHostAdapterResets);
-                BusLogic_ResetHostAdapter(HostAdapter, false);
-                HostAdapter->HostAdapterExternalReset = false;
-        } else if (HostAdapter->HostAdapterInternalError) {
-                BusLogic_Warning("Resetting %s due to Host Adapter Internal Error\n", HostAdapter, HostAdapter->FullModelName);
-                BusLogic_IncrementErrorCounter(&HostAdapter->HostAdapterInternalErrors);
-                BusLogic_ResetHostAdapter(HostAdapter, true);
-                HostAdapter->HostAdapterInternalError = false;
+        if (adapter->adapter_extreset) {
+                blogic_warn("Resetting %s due to External SCSI Bus Reset\n", adapter, adapter->full_model);
+                blogic_inc_count(&adapter->ext_resets);
+                blogic_resetadapter(adapter, false);
+                adapter->adapter_extreset = false;
+        } else if (adapter->adapter_intern_err) {
+                blogic_warn("Resetting %s due to Host Adapter Internal Error\n", adapter, adapter->full_model);
+                blogic_inc_count(&adapter->adapter_intern_errors);
+                blogic_resetadapter(adapter, true);
+                adapter->adapter_intern_err = false;
         }
         /*
            Release exclusive access to Host Adapter.
          */
-        spin_unlock_irqrestore(HostAdapter->SCSI_Host->host_lock, ProcessorFlags);
+        spin_unlock_irqrestore(adapter->scsi_host->host_lock, processor_flag);
         return IRQ_HANDLED;
 }
 
 
 /*
-  BusLogic_WriteOutgoingMailbox places CCB and Action Code into an Outgoing
+  blogic_write_outbox places CCB and Action Code into an Outgoing
   Mailbox for execution by Host Adapter.  The Host Adapter's Lock should
   already have been acquired by the caller.
 */
 
-static bool BusLogic_WriteOutgoingMailbox(struct BusLogic_HostAdapter
-                                             *HostAdapter, enum BusLogic_ActionCode ActionCode, struct BusLogic_CCB *CCB)
+static bool blogic_write_outbox(struct blogic_adapter *adapter,
+                enum blogic_action action, struct blogic_ccb *ccb)
 {
-        struct BusLogic_OutgoingMailbox *NextOutgoingMailbox;
-        NextOutgoingMailbox = HostAdapter->NextOutgoingMailbox;
-        if (NextOutgoingMailbox->ActionCode == BusLogic_OutgoingMailboxFree) {
-                CCB->Status = BusLogic_CCB_Active;
+        struct blogic_outbox *next_outbox;
+
+        next_outbox = adapter->next_outbox;
+        if (next_outbox->action == BLOGIC_OUTBOX_FREE) {
+                ccb->status = BLOGIC_CCB_ACTIVE;
                 /*
-                   The CCB field must be written before the Action Code field since
-                   the Host Adapter is operating asynchronously and the locking code
-                   does not protect against simultaneous access by the Host Adapter.
+                   The CCB field must be written before the Action Code field
+                   since the Host Adapter is operating asynchronously and the
+                   locking code does not protect against simultaneous access
+                   by the Host Adapter.
                  */
-                NextOutgoingMailbox->CCB = CCB->DMA_Handle;
-                NextOutgoingMailbox->ActionCode = ActionCode;
-                BusLogic_StartMailboxCommand(HostAdapter);
-                if (++NextOutgoingMailbox > HostAdapter->LastOutgoingMailbox)
-                        NextOutgoingMailbox = HostAdapter->FirstOutgoingMailbox;
-                HostAdapter->NextOutgoingMailbox = NextOutgoingMailbox;
-                if (ActionCode == BusLogic_MailboxStartCommand) {
-                        HostAdapter->ActiveCommands[CCB->TargetID]++;
-                        if (CCB->Opcode != BusLogic_BusDeviceReset)
-                                HostAdapter->TargetStatistics[CCB->TargetID].CommandsAttempted++;
+                next_outbox->ccb = ccb->dma_handle;
+                next_outbox->action = action;
+                blogic_execmbox(adapter);
+                if (++next_outbox > adapter->last_outbox)
+                        next_outbox = adapter->first_outbox;
+                adapter->next_outbox = next_outbox;
+                if (action == BLOGIC_MBOX_START) {
+                        adapter->active_cmds[ccb->tgt_id]++;
+                        if (ccb->opcode != BLOGIC_BDR)
+                                adapter->tgt_stats[ccb->tgt_id].cmds_tried++;
                 }
                 return true;
         }
@@ -2784,65 +2997,72 @@ static bool BusLogic_WriteOutgoingMailbox(struct BusLogic_HostAdapter
 
 /* Error Handling (EH) support */
 
-static int BusLogic_host_reset(struct scsi_cmnd * SCpnt)
+static int blogic_hostreset(struct scsi_cmnd *SCpnt)
 {
-        struct BusLogic_HostAdapter *HostAdapter = (struct BusLogic_HostAdapter *) SCpnt->device->host->hostdata;
+        struct blogic_adapter *adapter =
+                (struct blogic_adapter *) SCpnt->device->host->hostdata;
 
         unsigned int id = SCpnt->device->id;
-        struct BusLogic_TargetStatistics *stats = &HostAdapter->TargetStatistics[id];
+        struct blogic_tgt_stats *stats = &adapter->tgt_stats[id];
         int rc;
 
         spin_lock_irq(SCpnt->device->host->host_lock);
 
-        BusLogic_IncrementErrorCounter(&stats->HostAdapterResetsRequested);
+        blogic_inc_count(&stats->adatper_reset_req);
 
-        rc = BusLogic_ResetHostAdapter(HostAdapter, false);
+        rc = blogic_resetadapter(adapter, false);
         spin_unlock_irq(SCpnt->device->host->host_lock);
         return rc;
 }
 
 /*
-  BusLogic_QueueCommand creates a CCB for Command and places it into an
+  blogic_qcmd creates a CCB for Command and places it into an
   Outgoing Mailbox for execution by the associated Host Adapter.
 */
 
-static int BusLogic_QueueCommand_lck(struct scsi_cmnd *Command, void (*CompletionRoutine) (struct scsi_cmnd *))
+static int blogic_qcmd_lck(struct scsi_cmnd *command,
+                void (*comp_cb) (struct scsi_cmnd *))
 {
-        struct BusLogic_HostAdapter *HostAdapter = (struct BusLogic_HostAdapter *) Command->device->host->hostdata;
-        struct BusLogic_TargetFlags *TargetFlags = &HostAdapter->TargetFlags[Command->device->id];
-        struct BusLogic_TargetStatistics *TargetStatistics = HostAdapter->TargetStatistics;
-        unsigned char *CDB = Command->cmnd;
-        int CDB_Length = Command->cmd_len;
-        int TargetID = Command->device->id;
-        int LogicalUnit = Command->device->lun;
-        int BufferLength = scsi_bufflen(Command);
-        int Count;
-        struct BusLogic_CCB *CCB;
-        /*
-           SCSI REQUEST_SENSE commands will be executed automatically by the Host
-           Adapter for any errors, so they should not be executed explicitly unless
-           the Sense Data is zero indicating that no error occurred.
-         */
-        if (CDB[0] == REQUEST_SENSE && Command->sense_buffer[0] != 0) {
-                Command->result = DID_OK << 16;
-                CompletionRoutine(Command);
+        struct blogic_adapter *adapter =
+                (struct blogic_adapter *) command->device->host->hostdata;
+        struct blogic_tgt_flags *tgt_flags =
+                &adapter->tgt_flags[command->device->id];
+        struct blogic_tgt_stats *tgt_stats = adapter->tgt_stats;
+        unsigned char *cdb = command->cmnd;
+        int cdblen = command->cmd_len;
+        int tgt_id = command->device->id;
+        int lun = command->device->lun;
+        int buflen = scsi_bufflen(command);
+        int count;
+        struct blogic_ccb *ccb;
+
+        /*
+           SCSI REQUEST_SENSE commands will be executed automatically by the
+           Host Adapter for any errors, so they should not be executed
+           explicitly unless the Sense Data is zero indicating that no error
+           occurred.
+         */
+        if (cdb[0] == REQUEST_SENSE && command->sense_buffer[0] != 0) {
+                command->result = DID_OK << 16;
+                comp_cb(command);
                 return 0;
         }
         /*
-           Allocate a CCB from the Host Adapter's free list.  In the unlikely event
-           that there are none available and memory allocation fails, wait 1 second
-           and try again.  If that fails, the Host Adapter is probably hung so signal
-           an error as a Host Adapter Hard Reset should be initiated soon.
-         */
-        CCB = BusLogic_AllocateCCB(HostAdapter);
-        if (CCB == NULL) {
-                spin_unlock_irq(HostAdapter->SCSI_Host->host_lock);
-                BusLogic_Delay(1);
-                spin_lock_irq(HostAdapter->SCSI_Host->host_lock);
-                CCB = BusLogic_AllocateCCB(HostAdapter);
-                if (CCB == NULL) {
-                        Command->result = DID_ERROR << 16;
-                        CompletionRoutine(Command);
+           Allocate a CCB from the Host Adapter's free list. In the unlikely
+           event that there are none available and memory allocation fails,
+           wait 1 second and try again. If that fails, the Host Adapter is
+           probably hung so signal an error as a Host Adapter Hard Reset
+           should be initiated soon.
+         */
+        ccb = blogic_alloc_ccb(adapter);
+        if (ccb == NULL) {
+                spin_unlock_irq(adapter->scsi_host->host_lock);
+                blogic_delay(1);
+                spin_lock_irq(adapter->scsi_host->host_lock);
+                ccb = blogic_alloc_ccb(adapter);
+                if (ccb == NULL) {
+                        command->result = DID_ERROR << 16;
+                        comp_cb(command);
                         return 0;
                 }
         }
@@ -2850,217 +3070,241 @@ static int BusLogic_QueueCommand_lck(struct scsi_cmnd *Command, void (*Completio
         /*
            Initialize the fields in the BusLogic Command Control Block (CCB).
          */
-        Count = scsi_dma_map(Command);
-        BUG_ON(Count < 0);
-        if (Count) {
+        count = scsi_dma_map(command);
+        BUG_ON(count < 0);
+        if (count) {
                 struct scatterlist *sg;
                 int i;
 
-                CCB->Opcode = BusLogic_InitiatorCCB_ScatterGather;
-                CCB->DataLength = Count * sizeof(struct BusLogic_ScatterGatherSegment);
-                if (BusLogic_MultiMasterHostAdapterP(HostAdapter))
-                        CCB->DataPointer = (unsigned int) CCB->DMA_Handle + ((unsigned long) &CCB->ScatterGatherList - (unsigned long) CCB);
+                ccb->opcode = BLOGIC_INITIATOR_CCB_SG;
+                ccb->datalen = count * sizeof(struct blogic_sg_seg);
+                if (blogic_multimaster_type(adapter))
+                        ccb->data = (unsigned int) ccb->dma_handle +
+                                        ((unsigned long) &ccb->sglist -
+                                        (unsigned long) ccb);
                 else
-                        CCB->DataPointer = Virtual_to_32Bit_Virtual(CCB->ScatterGatherList);
+                        ccb->data = virt_to_32bit_virt(ccb->sglist);
 
-                scsi_for_each_sg(Command, sg, Count, i) {
-                        CCB->ScatterGatherList[i].SegmentByteCount =
-                                sg_dma_len(sg);
-                        CCB->ScatterGatherList[i].SegmentDataPointer =
-                                sg_dma_address(sg);
+                scsi_for_each_sg(command, sg, count, i) {
+                        ccb->sglist[i].segbytes = sg_dma_len(sg);
+                        ccb->sglist[i].segdata = sg_dma_address(sg);
                 }
-        } else if (!Count) {
-                CCB->Opcode = BusLogic_InitiatorCCB;
-                CCB->DataLength = BufferLength;
-                CCB->DataPointer = 0;
+        } else if (!count) {
+                ccb->opcode = BLOGIC_INITIATOR_CCB;
+                ccb->datalen = buflen;
+                ccb->data = 0;
         }
 
-        switch (CDB[0]) {
+        switch (cdb[0]) {
         case READ_6:
         case READ_10:
-                CCB->DataDirection = BusLogic_DataInLengthChecked;
-                TargetStatistics[TargetID].ReadCommands++;
-                BusLogic_IncrementByteCounter(&TargetStatistics[TargetID].TotalBytesRead, BufferLength);
-                BusLogic_IncrementSizeBucket(TargetStatistics[TargetID].ReadCommandSizeBuckets, BufferLength);
+                ccb->datadir = BLOGIC_DATAIN_CHECKED;
+                tgt_stats[tgt_id].read_cmds++;
+                blogic_addcount(&tgt_stats[tgt_id].bytesread, buflen);
+                blogic_incszbucket(tgt_stats[tgt_id].read_sz_buckets, buflen);
                 break;
         case WRITE_6:
         case WRITE_10:
-                CCB->DataDirection = BusLogic_DataOutLengthChecked;
-                TargetStatistics[TargetID].WriteCommands++;
-                BusLogic_IncrementByteCounter(&TargetStatistics[TargetID].TotalBytesWritten, BufferLength);
-                BusLogic_IncrementSizeBucket(TargetStatistics[TargetID].WriteCommandSizeBuckets, BufferLength);
+                ccb->datadir = BLOGIC_DATAOUT_CHECKED;
+                tgt_stats[tgt_id].write_cmds++;
+                blogic_addcount(&tgt_stats[tgt_id].byteswritten, buflen);
+                blogic_incszbucket(tgt_stats[tgt_id].write_sz_buckets, buflen);
                 break;
         default:
-                CCB->DataDirection = BusLogic_UncheckedDataTransfer;
+                ccb->datadir = BLOGIC_UNCHECKED_TX;
                 break;
         }
-        CCB->CDB_Length = CDB_Length;
-        CCB->HostAdapterStatus = 0;
-        CCB->TargetDeviceStatus = 0;
-        CCB->TargetID = TargetID;
-        CCB->LogicalUnit = LogicalUnit;
-        CCB->TagEnable = false;
-        CCB->LegacyTagEnable = false;
-        /*
-           BusLogic recommends that after a Reset the first couple of commands that
-           are sent to a Target Device be sent in a non Tagged Queue fashion so that
-           the Host Adapter and Target Device can establish Synchronous and Wide
-           Transfer before Queue Tag messages can interfere with the Synchronous and
-           Wide Negotiation messages.  By waiting to enable Tagged Queuing until after
-           the first BusLogic_MaxTaggedQueueDepth commands have been queued, it is
-           assured that after a Reset any pending commands are requeued before Tagged
-           Queuing is enabled and that the Tagged Queuing message will not occur while
-           the partition table is being printed.  In addition, some devices do not
-           properly handle the transition from non-tagged to tagged commands, so it is
-           necessary to wait until there are no pending commands for a target device
+        ccb->cdblen = cdblen;
+        ccb->adapter_status = 0;
+        ccb->tgt_status = 0;
+        ccb->tgt_id = tgt_id;
+        ccb->lun = lun;
+        ccb->tag_enable = false;
+        ccb->legacytag_enable = false;
+        /*
+           BusLogic recommends that after a Reset the first couple of
+           commands that are sent to a Target Device be sent in a non
+           Tagged Queue fashion so that the Host Adapter and Target Device
+           can establish Synchronous and Wide Transfer before Queue Tag
+           messages can interfere with the Synchronous and Wide Negotiation
+           messages.  By waiting to enable Tagged Queuing until after the
+           first BLOGIC_MAX_TAG_DEPTH commands have been queued, it is
+           assured that after a Reset any pending commands are requeued
+           before Tagged Queuing is enabled and that the Tagged Queuing
+           message will not occur while the partition table is being printed.
+           In addition, some devices do not properly handle the transition
+           from non-tagged to tagged commands, so it is necessary to wait
+           until there are no pending commands for a target device
            before queuing tagged commands.
          */
-        if (HostAdapter->CommandsSinceReset[TargetID]++ >=
-            BusLogic_MaxTaggedQueueDepth && !TargetFlags->TaggedQueuingActive && HostAdapter->ActiveCommands[TargetID] == 0 && TargetFlags->TaggedQueuingSupported && (HostAdapter->TaggedQueuingPermitted & (1 << TargetID))) {
-                TargetFlags->TaggedQueuingActive = true;
-                BusLogic_Notice("Tagged Queuing now active for Target %d\n", HostAdapter, TargetID);
-        }
-        if (TargetFlags->TaggedQueuingActive) {
-                enum BusLogic_QueueTag QueueTag = BusLogic_SimpleQueueTag;
+        if (adapter->cmds_since_rst[tgt_id]++ >= BLOGIC_MAX_TAG_DEPTH &&
+                        !tgt_flags->tagq_active &&
+                        adapter->active_cmds[tgt_id] == 0
+                        && tgt_flags->tagq_ok &&
+                        (adapter->tagq_ok & (1 << tgt_id))) {
+                tgt_flags->tagq_active = true;
+                blogic_notice("Tagged Queuing now active for Target %d\n",
+                                        adapter, tgt_id);
+        }
+        if (tgt_flags->tagq_active) {
+                enum blogic_queuetag queuetag = BLOGIC_SIMPLETAG;
                 /*
-                   When using Tagged Queuing with Simple Queue Tags, it appears that disk
-                   drive controllers do not guarantee that a queued command will not
-                   remain in a disconnected state indefinitely if commands that read or
-                   write nearer the head position continue to arrive without interruption.
-                   Therefore, for each Target Device this driver keeps track of the last
-                   time either the queue was empty or an Ordered Queue Tag was issued.  If
-                   more than 4 seconds (one fifth of the 20 second disk timeout) have
-                   elapsed since this last sequence point, this command will be issued
-                   with an Ordered Queue Tag rather than a Simple Queue Tag, which forces
-                   the Target Device to complete all previously queued commands before
-                   this command may be executed.
+                   When using Tagged Queuing with Simple Queue Tags, it
+                   appears that disk drive controllers do not guarantee that
+                   a queued command will not remain in a disconnected state
+                   indefinitely if commands that read or write nearer the
+                   head position continue to arrive without interruption.
+                   Therefore, for each Target Device this driver keeps track
+                   of the last time either the queue was empty or an Ordered
+                   Queue Tag was issued. If more than 4 seconds (one fifth
+                   of the 20 second disk timeout) have elapsed since this
+                   last sequence point, this command will be issued with an
+                   Ordered Queue Tag rather than a Simple Queue Tag, which
+                   forces the Target Device to complete all previously
+                   queued commands before this command may be executed.
                  */
-                if (HostAdapter->ActiveCommands[TargetID] == 0)
-                        HostAdapter->LastSequencePoint[TargetID] = jiffies;
-                else if (time_after(jiffies, HostAdapter->LastSequencePoint[TargetID] + 4 * HZ)) {
-                        HostAdapter->LastSequencePoint[TargetID] = jiffies;
-                        QueueTag = BusLogic_OrderedQueueTag;
+                if (adapter->active_cmds[tgt_id] == 0)
+                        adapter->last_seqpoint[tgt_id] = jiffies;
+                else if (time_after(jiffies,
+                                adapter->last_seqpoint[tgt_id] + 4 * HZ)) {
+                        adapter->last_seqpoint[tgt_id] = jiffies;
+                        queuetag = BLOGIC_ORDEREDTAG;
                 }
-                if (HostAdapter->ExtendedLUNSupport) {
-                        CCB->TagEnable = true;
-                        CCB->QueueTag = QueueTag;
+                if (adapter->ext_lun) {
+                        ccb->tag_enable = true;
+                        ccb->queuetag = queuetag;
                 } else {
-                        CCB->LegacyTagEnable = true;
-                        CCB->LegacyQueueTag = QueueTag;
+                        ccb->legacytag_enable = true;
+                        ccb->legacy_tag = queuetag;
                 }
         }
-        memcpy(CCB->CDB, CDB, CDB_Length);
-        CCB->SenseDataLength = SCSI_SENSE_BUFFERSIZE;
-        CCB->SenseDataPointer = pci_map_single(HostAdapter->PCI_Device, Command->sense_buffer, CCB->SenseDataLength, PCI_DMA_FROMDEVICE);
-        CCB->Command = Command;
-        Command->scsi_done = CompletionRoutine;
-        if (BusLogic_MultiMasterHostAdapterP(HostAdapter)) {
+        memcpy(ccb->cdb, cdb, cdblen);
+        ccb->sense_datalen = SCSI_SENSE_BUFFERSIZE;
+        ccb->sensedata = pci_map_single(adapter->pci_device,
+                                command->sense_buffer, ccb->sense_datalen,
+                                PCI_DMA_FROMDEVICE);
+        ccb->command = command;
+        command->scsi_done = comp_cb;
+        if (blogic_multimaster_type(adapter)) {
                 /*
-                   Place the CCB in an Outgoing Mailbox.  The higher levels of the SCSI
-                   Subsystem should not attempt to queue more commands than can be placed
-                   in Outgoing Mailboxes, so there should always be one free.  In the
-                   unlikely event that there are none available, wait 1 second and try
-                   again.  If that fails, the Host Adapter is probably hung so signal an
-                   error as a Host Adapter Hard Reset should be initiated soon.
+                   Place the CCB in an Outgoing Mailbox. The higher levels
+                   of the SCSI Subsystem should not attempt to queue more
+                   commands than can be placed in Outgoing Mailboxes, so
+                   there should always be one free.  In the unlikely event
+                   that there are none available, wait 1 second and try
+                   again. If that fails, the Host Adapter is probably hung
+                   so signal an error as a Host Adapter Hard Reset should
+                   be initiated soon.
                  */
-                if (!BusLogic_WriteOutgoingMailbox(HostAdapter, BusLogic_MailboxStartCommand, CCB)) {
-                        spin_unlock_irq(HostAdapter->SCSI_Host->host_lock);
-                        BusLogic_Warning("Unable to write Outgoing Mailbox - " "Pausing for 1 second\n", HostAdapter);
-                        BusLogic_Delay(1);
-                        spin_lock_irq(HostAdapter->SCSI_Host->host_lock);
-                        if (!BusLogic_WriteOutgoingMailbox(HostAdapter, BusLogic_MailboxStartCommand, CCB)) {
-                                BusLogic_Warning("Still unable to write Outgoing Mailbox - " "Host Adapter Dead?\n", HostAdapter);
-                                BusLogic_DeallocateCCB(CCB);
-                                Command->result = DID_ERROR << 16;
-                                Command->scsi_done(Command);
+                if (!blogic_write_outbox(adapter, BLOGIC_MBOX_START, ccb)) {
+                        spin_unlock_irq(adapter->scsi_host->host_lock);
+                        blogic_warn("Unable to write Outgoing Mailbox - " "Pausing for 1 second\n", adapter);
+                        blogic_delay(1);
+                        spin_lock_irq(adapter->scsi_host->host_lock);
+                        if (!blogic_write_outbox(adapter, BLOGIC_MBOX_START,
+                                                ccb)) {
+                                blogic_warn("Still unable to write Outgoing Mailbox - " "Host Adapter Dead?\n", adapter);
+                                blogic_dealloc_ccb(ccb);
+                                command->result = DID_ERROR << 16;
+                                command->scsi_done(command);
                         }
                 }
         } else {
                 /*
-                   Call the FlashPoint SCCB Manager to start execution of the CCB.
+                   Call the FlashPoint SCCB Manager to start execution of
+                   the CCB.
                  */
-                CCB->Status = BusLogic_CCB_Active;
-                HostAdapter->ActiveCommands[TargetID]++;
-                TargetStatistics[TargetID].CommandsAttempted++;
-                FlashPoint_StartCCB(HostAdapter->CardHandle, CCB);
+                ccb->status = BLOGIC_CCB_ACTIVE;
+                adapter->active_cmds[tgt_id]++;
+                tgt_stats[tgt_id].cmds_tried++;
+                FlashPoint_StartCCB(adapter->cardhandle, ccb);
                 /*
-                   The Command may have already completed and BusLogic_QueueCompletedCCB
-                   been called, or it may still be pending.
+                   The Command may have already completed and
+                   blogic_qcompleted_ccb been called, or it may still be
+                   pending.
                  */
-                if (CCB->Status == BusLogic_CCB_Completed)
-                        BusLogic_ProcessCompletedCCBs(HostAdapter);
+                if (ccb->status == BLOGIC_CCB_COMPLETE)
+                        blogic_process_ccbs(adapter);
         }
         return 0;
 }
 
-static DEF_SCSI_QCMD(BusLogic_QueueCommand)
+static DEF_SCSI_QCMD(blogic_qcmd)
 
 #if 0
 /*
-  BusLogic_AbortCommand aborts Command if possible.
+  blogic_abort aborts Command if possible.
 */
 
-static int BusLogic_AbortCommand(struct scsi_cmnd *Command)
+static int blogic_abort(struct scsi_cmnd *command)
 {
-        struct BusLogic_HostAdapter *HostAdapter = (struct BusLogic_HostAdapter *) Command->device->host->hostdata;
+        struct blogic_adapter *adapter =
+                (struct blogic_adapter *) command->device->host->hostdata;
+
+        int tgt_id = command->device->id;
+        struct blogic_ccb *ccb;
+        blogic_inc_count(&adapter->tgt_stats[tgt_id].aborts_request);
 
-        int TargetID = Command->device->id;
-        struct BusLogic_CCB *CCB;
-        BusLogic_IncrementErrorCounter(&HostAdapter->TargetStatistics[TargetID].CommandAbortsRequested);
         /*
-           Attempt to find an Active CCB for this Command.  If no Active CCB for this
-           Command is found, then no Abort is necessary.
+           Attempt to find an Active CCB for this Command. If no Active
+           CCB for this Command is found, then no Abort is necessary.
          */
-        for (CCB = HostAdapter->All_CCBs; CCB != NULL; CCB = CCB->NextAll)
-                if (CCB->Command == Command)
+        for (ccb = adapter->all_ccbs; ccb != NULL; ccb = ccb->next_all)
+                if (ccb->command == command)
                         break;
-        if (CCB == NULL) {
-                BusLogic_Warning("Unable to Abort Command to Target %d - " "No CCB Found\n", HostAdapter, TargetID);
+        if (ccb == NULL) {
+                blogic_warn("Unable to Abort Command to Target %d - No CCB Found\n", adapter, tgt_id);
                 return SUCCESS;
-        } else if (CCB->Status == BusLogic_CCB_Completed) {
-                BusLogic_Warning("Unable to Abort Command to Target %d - " "CCB Completed\n", HostAdapter, TargetID);
+        } else if (ccb->status == BLOGIC_CCB_COMPLETE) {
+                blogic_warn("Unable to Abort Command to Target %d - CCB Completed\n", adapter, tgt_id);
                 return SUCCESS;
-        } else if (CCB->Status == BusLogic_CCB_Reset) {
-                BusLogic_Warning("Unable to Abort Command to Target %d - " "CCB Reset\n", HostAdapter, TargetID);
+        } else if (ccb->status == BLOGIC_CCB_RESET) {
+                blogic_warn("Unable to Abort Command to Target %d - CCB Reset\n", adapter, tgt_id);
                 return SUCCESS;
         }
-        if (BusLogic_MultiMasterHostAdapterP(HostAdapter)) {
+        if (blogic_multimaster_type(adapter)) {
                 /*
-                   Attempt to Abort this CCB.  MultiMaster Firmware versions prior to 5.xx
-                   do not generate Abort Tag messages, but only generate the non-tagged
-                   Abort message.  Since non-tagged commands are not sent by the Host
-                   Adapter until the queue of outstanding tagged commands has completed,
-                   and the Abort message is treated as a non-tagged command, it is
-                   effectively impossible to abort commands when Tagged Queuing is active.
-                   Firmware version 5.xx does generate Abort Tag messages, so it is
-                   possible to abort commands when Tagged Queuing is active.
+                   Attempt to Abort this CCB.  MultiMaster Firmware versions
+                   prior to 5.xx do not generate Abort Tag messages, but only
+                   generate the non-tagged Abort message.  Since non-tagged
+                   commands are not sent by the Host Adapter until the queue
+                   of outstanding tagged commands has completed, and the
+                   Abort message is treated as a non-tagged command, it is
+                   effectively impossible to abort commands when Tagged
+                   Queuing is active. Firmware version 5.xx does generate
+                   Abort Tag messages, so it is possible to abort commands
+                   when Tagged Queuing is active.
                  */
-                if (HostAdapter->TargetFlags[TargetID].TaggedQueuingActive && HostAdapter->FirmwareVersion[0] < '5') {
-                        BusLogic_Warning("Unable to Abort CCB #%ld to Target %d - " "Abort Tag Not Supported\n", HostAdapter, CCB->SerialNumber, TargetID);
+                if (adapter->tgt_flags[tgt_id].tagq_active &&
+                                adapter->fw_ver[0] < '5') {
+                        blogic_warn("Unable to Abort CCB #%ld to Target %d - Abort Tag Not Supported\n", adapter, ccb->serial, tgt_id);
                         return FAILURE;
-                } else if (BusLogic_WriteOutgoingMailbox(HostAdapter, BusLogic_MailboxAbortCommand, CCB)) {
-                        BusLogic_Warning("Aborting CCB #%ld to Target %d\n", HostAdapter, CCB->SerialNumber, TargetID);
-                        BusLogic_IncrementErrorCounter(&HostAdapter->TargetStatistics[TargetID].CommandAbortsAttempted);
+                } else if (blogic_write_outbox(adapter, BLOGIC_MBOX_ABORT,
+                                        ccb)) {
+                        blogic_warn("Aborting CCB #%ld to Target %d\n",
+                                        adapter, ccb->serial, tgt_id);
+                        blogic_inc_count(&adapter->tgt_stats[tgt_id].aborts_tried);
                         return SUCCESS;
                 } else {
-                        BusLogic_Warning("Unable to Abort CCB #%ld to Target %d - " "No Outgoing Mailboxes\n", HostAdapter, CCB->SerialNumber, TargetID);
+                        blogic_warn("Unable to Abort CCB #%ld to Target %d - No Outgoing Mailboxes\n", adapter, ccb->serial, tgt_id);
                         return FAILURE;
                 }
         } else {
                 /*
-                   Call the FlashPoint SCCB Manager to abort execution of the CCB.
+                   Call the FlashPoint SCCB Manager to abort execution of
+                   the CCB.
                  */
-                BusLogic_Warning("Aborting CCB #%ld to Target %d\n", HostAdapter, CCB->SerialNumber, TargetID);
-                BusLogic_IncrementErrorCounter(&HostAdapter->TargetStatistics[TargetID].CommandAbortsAttempted);
-                FlashPoint_AbortCCB(HostAdapter->CardHandle, CCB);
+                blogic_warn("Aborting CCB #%ld to Target %d\n", adapter,
+                                ccb->serial, tgt_id);
+                blogic_inc_count(&adapter->tgt_stats[tgt_id].aborts_tried);
+                FlashPoint_AbortCCB(adapter->cardhandle, ccb);
                 /*
                    The Abort may have already been completed and
-                   BusLogic_QueueCompletedCCB been called, or it
+                   blogic_qcompleted_ccb been called, or it
                    may still be pending.
                  */
-                if (CCB->Status == BusLogic_CCB_Completed) {
-                        BusLogic_ProcessCompletedCCBs(HostAdapter);
-                }
+                if (ccb->status == BLOGIC_CCB_COMPLETE)
+                        blogic_process_ccbs(adapter);
                 return SUCCESS;
         }
         return SUCCESS;
@@ -3068,21 +3312,23 @@ static int BusLogic_AbortCommand(struct scsi_cmnd *Command)
 
 #endif
 /*
-  BusLogic_ResetHostAdapter resets Host Adapter if possible, marking all
+  blogic_resetadapter resets Host Adapter if possible, marking all
   currently executing SCSI Commands as having been Reset.
 */
 
-static int BusLogic_ResetHostAdapter(struct BusLogic_HostAdapter *HostAdapter, bool HardReset)
+static int blogic_resetadapter(struct blogic_adapter *adapter, bool hard_reset)
 {
-        struct BusLogic_CCB *CCB;
-        int TargetID;
+        struct blogic_ccb *ccb;
+        int tgt_id;
 
         /*
          * Attempt to Reset and Reinitialize the Host Adapter.
          */
 
-        if (!(BusLogic_HardwareResetHostAdapter(HostAdapter, HardReset) && BusLogic_InitializeHostAdapter(HostAdapter))) {
-                BusLogic_Error("Resetting %s Failed\n", HostAdapter, HostAdapter->FullModelName);
+        if (!(blogic_hwreset(adapter, hard_reset) &&
+                                blogic_initadapter(adapter))) {
+                blogic_err("Resetting %s Failed\n", adapter,
+                                                adapter->full_model);
                 return FAILURE;
         }
 
@@ -3090,9 +3336,9 @@ static int BusLogic_ResetHostAdapter(struct BusLogic_HostAdapter *HostAdapter, b
          * Deallocate all currently executing CCBs.
          */
 
-        for (CCB = HostAdapter->All_CCBs; CCB != NULL; CCB = CCB->NextAll)
-                if (CCB->Status == BusLogic_CCB_Active)
-                        BusLogic_DeallocateCCB(CCB);
+        for (ccb = adapter->all_ccbs; ccb != NULL; ccb = ccb->next_all)
+                if (ccb->status == BLOGIC_CCB_ACTIVE)
+                        blogic_dealloc_ccb(ccb);
         /*
          * Wait a few seconds between the Host Adapter Hard Reset which
          * initiates a SCSI Bus Reset and issuing any SCSI Commands.  Some
@@ -3100,21 +3346,21 @@ static int BusLogic_ResetHostAdapter(struct BusLogic_HostAdapter *HostAdapter, b
          * after a SCSI Bus Reset.
          */
 
-        if (HardReset) {
-                spin_unlock_irq(HostAdapter->SCSI_Host->host_lock);
-                BusLogic_Delay(HostAdapter->BusSettleTime);
-                spin_lock_irq(HostAdapter->SCSI_Host->host_lock);
+        if (hard_reset) {
+                spin_unlock_irq(adapter->scsi_host->host_lock);
+                blogic_delay(adapter->bus_settle_time);
+                spin_lock_irq(adapter->scsi_host->host_lock);
         }
 
-        for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++) {
-                HostAdapter->LastResetAttempted[TargetID] = jiffies;
-                HostAdapter->LastResetCompleted[TargetID] = jiffies;
+        for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++) {
+                adapter->last_resettried[tgt_id] = jiffies;
+                adapter->last_resetdone[tgt_id] = jiffies;
         }
         return SUCCESS;
 }
 
 /*
-  BusLogic_BIOSDiskParameters returns the Heads/Sectors/Cylinders BIOS Disk
+  blogic_diskparam returns the Heads/Sectors/Cylinders BIOS Disk
   Parameters for Disk.  The default disk geometry is 64 heads, 32 sectors, and
   the appropriate number of cylinders so as not to exceed drive capacity.  In
   order for disks equal to or larger than 1 GB to be addressable by the BIOS
@@ -3130,66 +3376,70 @@ static int BusLogic_ResetHostAdapter(struct BusLogic_HostAdapter *HostAdapter, b
   the BIOS, and a warning may be displayed.
 */
 
-static int BusLogic_BIOSDiskParameters(struct scsi_device *sdev, struct block_device *Device, sector_t capacity, int *Parameters)
+static int blogic_diskparam(struct scsi_device *sdev, struct block_device *dev,
+                sector_t capacity, int *params)
 {
-        struct BusLogic_HostAdapter *HostAdapter = (struct BusLogic_HostAdapter *) sdev->host->hostdata;
-        struct BIOS_DiskParameters *DiskParameters = (struct BIOS_DiskParameters *) Parameters;
+        struct blogic_adapter *adapter =
+                                (struct blogic_adapter *) sdev->host->hostdata;
+        struct bios_diskparam *diskparam = (struct bios_diskparam *) params;
         unsigned char *buf;
-        if (HostAdapter->ExtendedTranslationEnabled && capacity >= 2 * 1024 * 1024 /* 1 GB in 512 byte sectors */ ) {
-                if (capacity >= 4 * 1024 * 1024 /* 2 GB in 512 byte sectors */ ) {
-                        DiskParameters->Heads = 255;
-                        DiskParameters->Sectors = 63;
+
+        if (adapter->ext_trans_enable && capacity >= 2 * 1024 * 1024 /* 1 GB in 512 byte sectors */) {
+                if (capacity >= 4 * 1024 * 1024 /* 2 GB in 512 byte sectors */) {
+                        diskparam->heads = 255;
+                        diskparam->sectors = 63;
                 } else {
-                        DiskParameters->Heads = 128;
-                        DiskParameters->Sectors = 32;
+                        diskparam->heads = 128;
+                        diskparam->sectors = 32;
                 }
         } else {
-                DiskParameters->Heads = 64;
-                DiskParameters->Sectors = 32;
+                diskparam->heads = 64;
+                diskparam->sectors = 32;
         }
-        DiskParameters->Cylinders = (unsigned long) capacity / (DiskParameters->Heads * DiskParameters->Sectors);
-        buf = scsi_bios_ptable(Device);
+        diskparam->cylinders = (unsigned long) capacity / (diskparam->heads * diskparam->sectors);
+        buf = scsi_bios_ptable(dev);
         if (buf == NULL)
                 return 0;
         /*
-           If the boot sector partition table flag is valid, search for a partition
-           table entry whose end_head matches one of the standard BusLogic geometry
-           translations (64/32, 128/32, or 255/63).
+           If the boot sector partition table flag is valid, search for
+           a partition table entry whose end_head matches one of the
+           standard BusLogic geometry translations (64/32, 128/32, or 255/63).
          */
         if (*(unsigned short *) (buf + 64) == 0xAA55) {
-                struct partition *FirstPartitionEntry = (struct partition *) buf;
-                struct partition *PartitionEntry = FirstPartitionEntry;
-                int SavedCylinders = DiskParameters->Cylinders, PartitionNumber;
-                unsigned char PartitionEntryEndHead = 0, PartitionEntryEndSector = 0;
-                for (PartitionNumber = 0; PartitionNumber < 4; PartitionNumber++) {
-                        PartitionEntryEndHead = PartitionEntry->end_head;
-                        PartitionEntryEndSector = PartitionEntry->end_sector & 0x3F;
-                        if (PartitionEntryEndHead == 64 - 1) {
-                                DiskParameters->Heads = 64;
-                                DiskParameters->Sectors = 32;
+                struct partition *part1_entry = (struct partition *) buf;
+                struct partition *part_entry = part1_entry;
+                int saved_cyl = diskparam->cylinders, part_no;
+                unsigned char part_end_head = 0, part_end_sector = 0;
+
+                for (part_no = 0; part_no < 4; part_no++) {
+                        part_end_head = part_entry->end_head;
+                        part_end_sector = part_entry->end_sector & 0x3F;
+                        if (part_end_head == 64 - 1) {
+                                diskparam->heads = 64;
+                                diskparam->sectors = 32;
                                 break;
-                        } else if (PartitionEntryEndHead == 128 - 1) {
-                                DiskParameters->Heads = 128;
-                                DiskParameters->Sectors = 32;
+                        } else if (part_end_head == 128 - 1) {
+                                diskparam->heads = 128;
+                                diskparam->sectors = 32;
                                 break;
-                        } else if (PartitionEntryEndHead == 255 - 1) {
-                                DiskParameters->Heads = 255;
-                                DiskParameters->Sectors = 63;
+                        } else if (part_end_head == 255 - 1) {
+                                diskparam->heads = 255;
+                                diskparam->sectors = 63;
                                 break;
                         }
-                        PartitionEntry++;
+                        part_entry++;
                 }
-                if (PartitionNumber == 4) {
-                        PartitionEntryEndHead = FirstPartitionEntry->end_head;
-                        PartitionEntryEndSector = FirstPartitionEntry->end_sector & 0x3F;
+                if (part_no == 4) {
+                        part_end_head = part1_entry->end_head;
+                        part_end_sector = part1_entry->end_sector & 0x3F;
                 }
-                DiskParameters->Cylinders = (unsigned long) capacity / (DiskParameters->Heads * DiskParameters->Sectors);
-                if (PartitionNumber < 4 && PartitionEntryEndSector == DiskParameters->Sectors) {
-                        if (DiskParameters->Cylinders != SavedCylinders)
-                                BusLogic_Warning("Adopting Geometry %d/%d from Partition Table\n", HostAdapter, DiskParameters->Heads, DiskParameters->Sectors);
-                } else if (PartitionEntryEndHead > 0 || PartitionEntryEndSector > 0) {
-                        BusLogic_Warning("Warning: Partition Table appears to " "have Geometry %d/%d which is\n", HostAdapter, PartitionEntryEndHead + 1, PartitionEntryEndSector);
-                        BusLogic_Warning("not compatible with current BusLogic " "Host Adapter Geometry %d/%d\n", HostAdapter, DiskParameters->Heads, DiskParameters->Sectors);
+                diskparam->cylinders = (unsigned long) capacity / (diskparam->heads * diskparam->sectors);
+                if (part_no < 4 && part_end_sector == diskparam->sectors) {
+                        if (diskparam->cylinders != saved_cyl)
+                                blogic_warn("Adopting Geometry %d/%d from Partition Table\n", adapter, diskparam->heads, diskparam->sectors);
+                } else if (part_end_head > 0 || part_end_sector > 0) {
+                        blogic_warn("Warning: Partition Table appears to " "have Geometry %d/%d which is\n", adapter, part_end_head + 1, part_end_sector);
+                        blogic_warn("not compatible with current BusLogic " "Host Adapter Geometry %d/%d\n", adapter, diskparam->heads, diskparam->sectors);
                 }
         }
         kfree(buf);
@@ -3201,92 +3451,94 @@ static int BusLogic_BIOSDiskParameters(struct scsi_device *sdev, struct block_de
   BugLogic_ProcDirectoryInfo implements /proc/scsi/BusLogic/<N>.
 */
 
-static int BusLogic_write_info(struct Scsi_Host *shost, char *ProcBuffer, int BytesAvailable)
+static int blogic_write_info(struct Scsi_Host *shost, char *procbuf,
+                                int bytes_avail)
 {
-        struct BusLogic_HostAdapter *HostAdapter = (struct BusLogic_HostAdapter *) shost->hostdata;
-        struct BusLogic_TargetStatistics *TargetStatistics;
-
-        TargetStatistics = HostAdapter->TargetStatistics;
-        HostAdapter->ExternalHostAdapterResets = 0;
-        HostAdapter->HostAdapterInternalErrors = 0;
-        memset(TargetStatistics, 0, BusLogic_MaxTargetDevices * sizeof(struct BusLogic_TargetStatistics));
+        struct blogic_adapter *adapter =
+                                (struct blogic_adapter *) shost->hostdata;
+        struct blogic_tgt_stats *tgt_stats;
+
+        tgt_stats = adapter->tgt_stats;
+        adapter->ext_resets = 0;
+        adapter->adapter_intern_errors = 0;
+        memset(tgt_stats, 0, BLOGIC_MAXDEV * sizeof(struct blogic_tgt_stats));
         return 0;
 }
 
-static int BusLogic_show_info(struct seq_file *m, struct Scsi_Host *shost)
+static int blogic_show_info(struct seq_file *m, struct Scsi_Host *shost)
 {
-        struct BusLogic_HostAdapter *HostAdapter = (struct BusLogic_HostAdapter *) shost->hostdata;
-        struct BusLogic_TargetStatistics *TargetStatistics;
-        int TargetID;
+        struct blogic_adapter *adapter = (struct blogic_adapter *) shost->hostdata;
+        struct blogic_tgt_stats *tgt_stats;
+        int tgt;
 
-        TargetStatistics = HostAdapter->TargetStatistics;
-        seq_write(m, HostAdapter->MessageBuffer, HostAdapter->MessageBufferLength);
+        tgt_stats = adapter->tgt_stats;
+        seq_write(m, adapter->msgbuf, adapter->msgbuflen);
         seq_printf(m, "\n\
 Current Driver Queue Depth:     %d\n\
-Currently Allocated CCBs:       %d\n", HostAdapter->DriverQueueDepth, HostAdapter->AllocatedCCBs);
+Currently Allocated CCBs:       %d\n", adapter->drvr_qdepth, adapter->alloc_ccbs);
         seq_printf(m, "\n\n\
                            DATA TRANSFER STATISTICS\n\
 \n\
 Target  Tagged Queuing  Queue Depth  Active  Attempted  Completed\n\
 ======  ==============  ===========  ======  =========  =========\n");
-        for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++) {
-                struct BusLogic_TargetFlags *TargetFlags = &HostAdapter->TargetFlags[TargetID];
-                if (!TargetFlags->TargetExists)
+        for (tgt = 0; tgt < adapter->maxdev; tgt++) {
+                struct blogic_tgt_flags *tgt_flags = &adapter->tgt_flags[tgt];
+                if (!tgt_flags->tgt_exists)
                         continue;
-                seq_printf(m, "  %2d    %s", TargetID, (TargetFlags->TaggedQueuingSupported ? (TargetFlags->TaggedQueuingActive ? "    Active" : (HostAdapter->TaggedQueuingPermitted & (1 << TargetID)
+                seq_printf(m, "  %2d    %s", tgt, (tgt_flags->tagq_ok ? (tgt_flags->tagq_active ? "    Active" : (adapter->tagq_ok & (1 << tgt)
                                                                                                                                                                     ? "  Permitted" : "   Disabled"))
                                                                           : "Not Supported"));
                 seq_printf(m,
-                                  "         %3d       %3u    %9u        %9u\n", HostAdapter->QueueDepth[TargetID], HostAdapter->ActiveCommands[TargetID], TargetStatistics[TargetID].CommandsAttempted, TargetStatistics[TargetID].CommandsCompleted);
+                                  "         %3d       %3u    %9u        %9u\n", adapter->qdepth[tgt], adapter->active_cmds[tgt], tgt_stats[tgt].cmds_tried, tgt_stats[tgt].cmds_complete);
         }
         seq_printf(m, "\n\
 Target  Read Commands  Write Commands   Total Bytes Read    Total Bytes Written\n\
 ======  =============  ==============  ===================  ===================\n");
-        for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++) {
-                struct BusLogic_TargetFlags *TargetFlags = &HostAdapter->TargetFlags[TargetID];
-                if (!TargetFlags->TargetExists)
+        for (tgt = 0; tgt < adapter->maxdev; tgt++) {
+                struct blogic_tgt_flags *tgt_flags = &adapter->tgt_flags[tgt];
+                if (!tgt_flags->tgt_exists)
                         continue;
-                seq_printf(m, "  %2d      %9u    %9u", TargetID, TargetStatistics[TargetID].ReadCommands, TargetStatistics[TargetID].WriteCommands);
-                if (TargetStatistics[TargetID].TotalBytesRead.Billions > 0)
-                        seq_printf(m, "     %9u%09u", TargetStatistics[TargetID].TotalBytesRead.Billions, TargetStatistics[TargetID].TotalBytesRead.Units);
+                seq_printf(m, "  %2d      %9u    %9u", tgt, tgt_stats[tgt].read_cmds, tgt_stats[tgt].write_cmds);
+                if (tgt_stats[tgt].bytesread.billions > 0)
+                        seq_printf(m, "     %9u%09u", tgt_stats[tgt].bytesread.billions, tgt_stats[tgt].bytesread.units);
                 else
-                        seq_printf(m, "         %9u", TargetStatistics[TargetID].TotalBytesRead.Units);
-                if (TargetStatistics[TargetID].TotalBytesWritten.Billions > 0)
-                        seq_printf(m, "   %9u%09u\n", TargetStatistics[TargetID].TotalBytesWritten.Billions, TargetStatistics[TargetID].TotalBytesWritten.Units);
+                        seq_printf(m, "         %9u", tgt_stats[tgt].bytesread.units);
+                if (tgt_stats[tgt].byteswritten.billions > 0)
+                        seq_printf(m, "   %9u%09u\n", tgt_stats[tgt].byteswritten.billions, tgt_stats[tgt].byteswritten.units);
                 else
-                        seq_printf(m, "      %9u\n", TargetStatistics[TargetID].TotalBytesWritten.Units);
+                        seq_printf(m, "      %9u\n", tgt_stats[tgt].byteswritten.units);
         }
         seq_printf(m, "\n\
 Target  Command    0-1KB      1-2KB      2-4KB      4-8KB     8-16KB\n\
 ======  =======  =========  =========  =========  =========  =========\n");
-        for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++) {
-                struct BusLogic_TargetFlags *TargetFlags = &HostAdapter->TargetFlags[TargetID];
-                if (!TargetFlags->TargetExists)
+        for (tgt = 0; tgt < adapter->maxdev; tgt++) {
+                struct blogic_tgt_flags *tgt_flags = &adapter->tgt_flags[tgt];
+                if (!tgt_flags->tgt_exists)
                         continue;
                 seq_printf(m,
-                            "  %2d       Read    %9u  %9u  %9u  %9u  %9u\n", TargetID,
-                            TargetStatistics[TargetID].ReadCommandSizeBuckets[0],
-                            TargetStatistics[TargetID].ReadCommandSizeBuckets[1], TargetStatistics[TargetID].ReadCommandSizeBuckets[2], TargetStatistics[TargetID].ReadCommandSizeBuckets[3], TargetStatistics[TargetID].ReadCommandSizeBuckets[4]);
+                            "  %2d       Read    %9u  %9u  %9u  %9u  %9u\n", tgt,
+                            tgt_stats[tgt].read_sz_buckets[0],
+                            tgt_stats[tgt].read_sz_buckets[1], tgt_stats[tgt].read_sz_buckets[2], tgt_stats[tgt].read_sz_buckets[3], tgt_stats[tgt].read_sz_buckets[4]);
                 seq_printf(m,
-                            "  %2d       Write   %9u  %9u  %9u  %9u  %9u\n", TargetID,
-                            TargetStatistics[TargetID].WriteCommandSizeBuckets[0],
-                            TargetStatistics[TargetID].WriteCommandSizeBuckets[1], TargetStatistics[TargetID].WriteCommandSizeBuckets[2], TargetStatistics[TargetID].WriteCommandSizeBuckets[3], TargetStatistics[TargetID].WriteCommandSizeBuckets[4]);
+                            "  %2d       Write   %9u  %9u  %9u  %9u  %9u\n", tgt,
+                            tgt_stats[tgt].write_sz_buckets[0],
+                            tgt_stats[tgt].write_sz_buckets[1], tgt_stats[tgt].write_sz_buckets[2], tgt_stats[tgt].write_sz_buckets[3], tgt_stats[tgt].write_sz_buckets[4]);
         }
         seq_printf(m, "\n\
 Target  Command   16-32KB    32-64KB   64-128KB   128-256KB   256KB+\n\
 ======  =======  =========  =========  =========  =========  =========\n");
-        for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++) {
-                struct BusLogic_TargetFlags *TargetFlags = &HostAdapter->TargetFlags[TargetID];
-                if (!TargetFlags->TargetExists)
+        for (tgt = 0; tgt < adapter->maxdev; tgt++) {
+                struct blogic_tgt_flags *tgt_flags = &adapter->tgt_flags[tgt];
+                if (!tgt_flags->tgt_exists)
                         continue;
                 seq_printf(m,
-                            "  %2d       Read    %9u  %9u  %9u  %9u  %9u\n", TargetID,
-                            TargetStatistics[TargetID].ReadCommandSizeBuckets[5],
-                            TargetStatistics[TargetID].ReadCommandSizeBuckets[6], TargetStatistics[TargetID].ReadCommandSizeBuckets[7], TargetStatistics[TargetID].ReadCommandSizeBuckets[8], TargetStatistics[TargetID].ReadCommandSizeBuckets[9]);
+                            "  %2d       Read    %9u  %9u  %9u  %9u  %9u\n", tgt,
+                            tgt_stats[tgt].read_sz_buckets[5],
+                            tgt_stats[tgt].read_sz_buckets[6], tgt_stats[tgt].read_sz_buckets[7], tgt_stats[tgt].read_sz_buckets[8], tgt_stats[tgt].read_sz_buckets[9]);
                 seq_printf(m,
-                            "  %2d       Write   %9u  %9u  %9u  %9u  %9u\n", TargetID,
-                            TargetStatistics[TargetID].WriteCommandSizeBuckets[5],
-                            TargetStatistics[TargetID].WriteCommandSizeBuckets[6], TargetStatistics[TargetID].WriteCommandSizeBuckets[7], TargetStatistics[TargetID].WriteCommandSizeBuckets[8], TargetStatistics[TargetID].WriteCommandSizeBuckets[9]);
+                            "  %2d       Write   %9u  %9u  %9u  %9u  %9u\n", tgt,
+                            tgt_stats[tgt].write_sz_buckets[5],
+                            tgt_stats[tgt].write_sz_buckets[6], tgt_stats[tgt].write_sz_buckets[7], tgt_stats[tgt].write_sz_buckets[8], tgt_stats[tgt].write_sz_buckets[9]);
         }
         seq_printf(m, "\n\n\
                            ERROR RECOVERY STATISTICS\n\
@@ -3295,84 +3547,86 @@ Target  Command   16-32KB    32-64KB   64-128KB   128-256KB   256KB+\n\
 Target  Requested Completed  Requested Completed  Requested Completed\n\
   ID    \\\\\\\\ Attempted ////  \\\\\\\\ Attempted ////  \\\\\\\\ Attempted ////\n\
 ======   ===== ===== =====    ===== ===== =====    ===== ===== =====\n");
-        for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++) {
-                struct BusLogic_TargetFlags *TargetFlags = &HostAdapter->TargetFlags[TargetID];
-                if (!TargetFlags->TargetExists)
+        for (tgt = 0; tgt < adapter->maxdev; tgt++) {
+                struct blogic_tgt_flags *tgt_flags = &adapter->tgt_flags[tgt];
+                if (!tgt_flags->tgt_exists)
                         continue;
                 seq_printf(m, "\
-  %2d    %5d %5d %5d    %5d %5d %5d        %5d %5d %5d\n", TargetID, TargetStatistics[TargetID].CommandAbortsRequested, TargetStatistics[TargetID].CommandAbortsAttempted, TargetStatistics[TargetID].CommandAbortsCompleted, TargetStatistics[TargetID].BusDeviceResetsRequested, TargetStatistics[TargetID].BusDeviceResetsAttempted, TargetStatistics[TargetID].BusDeviceResetsCompleted, TargetStatistics[TargetID].HostAdapterResetsRequested, TargetStatistics[TargetID].HostAdapterResetsAttempted, TargetStatistics[TargetID].HostAdapterResetsCompleted);
+  %2d    %5d %5d %5d    %5d %5d %5d        %5d %5d %5d\n", tgt, tgt_stats[tgt].aborts_request, tgt_stats[tgt].aborts_tried, tgt_stats[tgt].aborts_done, tgt_stats[tgt].bdr_request, tgt_stats[tgt].bdr_tried, tgt_stats[tgt].bdr_done, tgt_stats[tgt].adatper_reset_req, tgt_stats[tgt].adapter_reset_attempt, tgt_stats[tgt].adapter_reset_done);
         }
-        seq_printf(m, "\nExternal Host Adapter Resets: %d\n", HostAdapter->ExternalHostAdapterResets);
-        seq_printf(m, "Host Adapter Internal Errors: %d\n", HostAdapter->HostAdapterInternalErrors);
+        seq_printf(m, "\nExternal Host Adapter Resets: %d\n", adapter->ext_resets);
+        seq_printf(m, "Host Adapter Internal Errors: %d\n", adapter->adapter_intern_errors);
         return 0;
 }
 
 
 /*
-  BusLogic_Message prints Driver Messages.
+  blogic_msg prints Driver Messages.
 */
 
-static void BusLogic_Message(enum BusLogic_MessageLevel MessageLevel, char *Format, struct BusLogic_HostAdapter *HostAdapter, ...)
+static void blogic_msg(enum blogic_msglevel msglevel, char *fmt,
+                        struct blogic_adapter *adapter, ...)
 {
-        static char Buffer[BusLogic_LineBufferSize];
-        static bool BeginningOfLine = true;
-        va_list Arguments;
-        int Length = 0;
-        va_start(Arguments, HostAdapter);
-        Length = vsprintf(Buffer, Format, Arguments);
-        va_end(Arguments);
-        if (MessageLevel == BusLogic_AnnounceLevel) {
-                static int AnnouncementLines = 0;
-                strcpy(&HostAdapter->MessageBuffer[HostAdapter->MessageBufferLength], Buffer);
-                HostAdapter->MessageBufferLength += Length;
-                if (++AnnouncementLines <= 2)
-                        printk("%sscsi: %s", BusLogic_MessageLevelMap[MessageLevel], Buffer);
-        } else if (MessageLevel == BusLogic_InfoLevel) {
-                strcpy(&HostAdapter->MessageBuffer[HostAdapter->MessageBufferLength], Buffer);
-                HostAdapter->MessageBufferLength += Length;
-                if (BeginningOfLine) {
-                        if (Buffer[0] != '\n' || Length > 1)
-                                printk("%sscsi%d: %s", BusLogic_MessageLevelMap[MessageLevel], HostAdapter->HostNumber, Buffer);
+        static char buf[BLOGIC_LINEBUF_SIZE];
+        static bool begin = true;
+        va_list args;
+        int len = 0;
+
+        va_start(args, adapter);
+        len = vsprintf(buf, fmt, args);
+        va_end(args);
+        if (msglevel == BLOGIC_ANNOUNCE_LEVEL) {
+                static int msglines = 0;
+                strcpy(&adapter->msgbuf[adapter->msgbuflen], buf);
+                adapter->msgbuflen += len;
+                if (++msglines <= 2)
+                        printk("%sscsi: %s", blogic_msglevelmap[msglevel], buf);
+        } else if (msglevel == BLOGIC_INFO_LEVEL) {
+                strcpy(&adapter->msgbuf[adapter->msgbuflen], buf);
+                adapter->msgbuflen += len;
+                if (begin) {
+                        if (buf[0] != '\n' || len > 1)
+                                printk("%sscsi%d: %s", blogic_msglevelmap[msglevel], adapter->host_no, buf);
                 } else
-                        printk("%s", Buffer);
+                        printk("%s", buf);
         } else {
-                if (BeginningOfLine) {
-                        if (HostAdapter != NULL && HostAdapter->HostAdapterInitialized)
-                                printk("%sscsi%d: %s", BusLogic_MessageLevelMap[MessageLevel], HostAdapter->HostNumber, Buffer);
+                if (begin) {
+                        if (adapter != NULL && adapter->adapter_initd)
+                                printk("%sscsi%d: %s", blogic_msglevelmap[msglevel], adapter->host_no, buf);
                         else
-                                printk("%s%s", BusLogic_MessageLevelMap[MessageLevel], Buffer);
+                                printk("%s%s", blogic_msglevelmap[msglevel], buf);
                 } else
-                        printk("%s", Buffer);
+                        printk("%s", buf);
         }
-        BeginningOfLine = (Buffer[Length - 1] == '\n');
+        begin = (buf[len - 1] == '\n');
 }
 
 
 /*
-  BusLogic_ParseKeyword parses an individual option keyword.  It returns true
+  blogic_parse parses an individual option keyword.  It returns true
   and updates the pointer if the keyword is recognized and false otherwise.
 */
 
-static bool __init BusLogic_ParseKeyword(char **StringPointer, char *Keyword)
+static bool __init blogic_parse(char **str, char *keyword)
 {
-        char *Pointer = *StringPointer;
-        while (*Keyword != '\0') {
-                char StringChar = *Pointer++;
-                char KeywordChar = *Keyword++;
-                if (StringChar >= 'A' && StringChar <= 'Z')
-                        StringChar += 'a' - 'Z';
-                if (KeywordChar >= 'A' && KeywordChar <= 'Z')
-                        KeywordChar += 'a' - 'Z';
-                if (StringChar != KeywordChar)
+        char *pointer = *str;
+        while (*keyword != '\0') {
+                char strch = *pointer++;
+                char keywordch = *keyword++;
+                if (strch >= 'A' && strch <= 'Z')
+                        strch += 'a' - 'Z';
+                if (keywordch >= 'A' && keywordch <= 'Z')
+                        keywordch += 'a' - 'Z';
+                if (strch != keywordch)
                         return false;
         }
-        *StringPointer = Pointer;
+        *str = pointer;
         return true;
 }
 
 
 /*
-  BusLogic_ParseDriverOptions handles processing of BusLogic Driver Options
+  blogic_parseopts handles processing of BusLogic Driver Options
   specifications.
 
   BusLogic Driver Options may be specified either via the Linux Kernel Command
@@ -3388,164 +3642,177 @@ static bool __init BusLogic_ParseKeyword(char **StringPointer, char *Keyword)
   <file:Documentation/scsi/BusLogic.txt>.
 */
 
-static int __init BusLogic_ParseDriverOptions(char *OptionsString)
+static int __init blogic_parseopts(char *options)
 {
         while (true) {
-                struct BusLogic_DriverOptions *DriverOptions = &BusLogic_DriverOptions[BusLogic_DriverOptionsCount++];
-                int TargetID;
-                memset(DriverOptions, 0, sizeof(struct BusLogic_DriverOptions));
-                while (*OptionsString != '\0' && *OptionsString != ';') {
+                struct blogic_drvr_options *drvr_opts =
+                        &blogic_drvr_options[blogic_drvr_options_count++];
+                int tgt_id;
+
+                memset(drvr_opts, 0, sizeof(struct blogic_drvr_options));
+                while (*options != '\0' && *options != ';') {
                         /* Probing Options. */
-                        if (BusLogic_ParseKeyword(&OptionsString, "IO:")) {
-                                unsigned long IO_Address = simple_strtoul(OptionsString, &OptionsString, 0);
-                                BusLogic_ProbeOptions.LimitedProbeISA = true;
-                                switch (IO_Address) {
+                        if (blogic_parse(&options, "IO:")) {
+                                unsigned long io_addr = simple_strtoul(options,
+                                                                &options, 0);
+                                blogic_probe_options.limited_isa = true;
+                                switch (io_addr) {
                                 case 0x330:
-                                        BusLogic_ProbeOptions.Probe330 = true;
+                                        blogic_probe_options.probe330 = true;
                                         break;
                                 case 0x334:
-                                        BusLogic_ProbeOptions.Probe334 = true;
+                                        blogic_probe_options.probe334 = true;
                                         break;
                                 case 0x230:
-                                        BusLogic_ProbeOptions.Probe230 = true;
+                                        blogic_probe_options.probe230 = true;
                                         break;
                                 case 0x234:
-                                        BusLogic_ProbeOptions.Probe234 = true;
+                                        blogic_probe_options.probe234 = true;
                                         break;
                                 case 0x130:
-                                        BusLogic_ProbeOptions.Probe130 = true;
+                                        blogic_probe_options.probe130 = true;
                                         break;
                                 case 0x134:
-                                        BusLogic_ProbeOptions.Probe134 = true;
+                                        blogic_probe_options.probe134 = true;
                                         break;
                                 default:
-                                        BusLogic_Error("BusLogic: Invalid Driver Options " "(invalid I/O Address 0x%X)\n", NULL, IO_Address);
+                                        blogic_err("BusLogic: Invalid Driver Options " "(invalid I/O Address 0x%X)\n", NULL, io_addr);
                                         return 0;
                                 }
-                        } else if (BusLogic_ParseKeyword(&OptionsString, "NoProbeISA"))
-                                BusLogic_ProbeOptions.NoProbeISA = true;
-                        else if (BusLogic_ParseKeyword(&OptionsString, "NoProbePCI"))
-                                BusLogic_ProbeOptions.NoProbePCI = true;
-                        else if (BusLogic_ParseKeyword(&OptionsString, "NoProbe"))
-                                BusLogic_ProbeOptions.NoProbe = true;
-                        else if (BusLogic_ParseKeyword(&OptionsString, "NoSortPCI"))
-                                BusLogic_ProbeOptions.NoSortPCI = true;
-                        else if (BusLogic_ParseKeyword(&OptionsString, "MultiMasterFirst"))
-                                BusLogic_ProbeOptions.MultiMasterFirst = true;
-                        else if (BusLogic_ParseKeyword(&OptionsString, "FlashPointFirst"))
-                                BusLogic_ProbeOptions.FlashPointFirst = true;
+                        } else if (blogic_parse(&options, "NoProbeISA"))
+                                blogic_probe_options.noprobe_isa = true;
+                        else if (blogic_parse(&options, "NoProbePCI"))
+                                blogic_probe_options.noprobe_pci = true;
+                        else if (blogic_parse(&options, "NoProbe"))
+                                blogic_probe_options.noprobe = true;
+                        else if (blogic_parse(&options, "NoSortPCI"))
+                                blogic_probe_options.nosort_pci = true;
+                        else if (blogic_parse(&options, "MultiMasterFirst"))
+                                blogic_probe_options.multimaster_first = true;
+                        else if (blogic_parse(&options, "FlashPointFirst"))
+                                blogic_probe_options.flashpoint_first = true;
                         /* Tagged Queuing Options. */
-                        else if (BusLogic_ParseKeyword(&OptionsString, "QueueDepth:[") || BusLogic_ParseKeyword(&OptionsString, "QD:[")) {
-                                for (TargetID = 0; TargetID < BusLogic_MaxTargetDevices; TargetID++) {
-                                        unsigned short QueueDepth = simple_strtoul(OptionsString, &OptionsString, 0);
-                                        if (QueueDepth > BusLogic_MaxTaggedQueueDepth) {
-                                                BusLogic_Error("BusLogic: Invalid Driver Options " "(invalid Queue Depth %d)\n", NULL, QueueDepth);
+                        else if (blogic_parse(&options, "QueueDepth:[") ||
+                                        blogic_parse(&options, "QD:[")) {
+                                for (tgt_id = 0; tgt_id < BLOGIC_MAXDEV; tgt_id++) {
+                                        unsigned short qdepth = simple_strtoul(options, &options, 0);
+                                        if (qdepth > BLOGIC_MAX_TAG_DEPTH) {
+                                                blogic_err("BusLogic: Invalid Driver Options " "(invalid Queue Depth %d)\n", NULL, qdepth);
                                                 return 0;
                                         }
-                                        DriverOptions->QueueDepth[TargetID] = QueueDepth;
-                                        if (*OptionsString == ',')
-                                                OptionsString++;
-                                        else if (*OptionsString == ']')
+                                        drvr_opts->qdepth[tgt_id] = qdepth;
+                                        if (*options == ',')
+                                                options++;
+                                        else if (*options == ']')
                                                 break;
                                         else {
-                                                BusLogic_Error("BusLogic: Invalid Driver Options " "(',' or ']' expected at '%s')\n", NULL, OptionsString);
+                                                blogic_err("BusLogic: Invalid Driver Options " "(',' or ']' expected at '%s')\n", NULL, options);
                                                 return 0;
                                         }
                                 }
-                                if (*OptionsString != ']') {
-                                        BusLogic_Error("BusLogic: Invalid Driver Options " "(']' expected at '%s')\n", NULL, OptionsString);
+                                if (*options != ']') {
+                                        blogic_err("BusLogic: Invalid Driver Options " "(']' expected at '%s')\n", NULL, options);
                                         return 0;
                                 } else
-                                        OptionsString++;
-                        } else if (BusLogic_ParseKeyword(&OptionsString, "QueueDepth:") || BusLogic_ParseKeyword(&OptionsString, "QD:")) {
-                                unsigned short QueueDepth = simple_strtoul(OptionsString, &OptionsString, 0);
-                                if (QueueDepth == 0 || QueueDepth > BusLogic_MaxTaggedQueueDepth) {
-                                        BusLogic_Error("BusLogic: Invalid Driver Options " "(invalid Queue Depth %d)\n", NULL, QueueDepth);
+                                        options++;
+                        } else if (blogic_parse(&options, "QueueDepth:") || blogic_parse(&options, "QD:")) {
+                                unsigned short qdepth = simple_strtoul(options, &options, 0);
+                                if (qdepth == 0 ||
+                                                qdepth > BLOGIC_MAX_TAG_DEPTH) {
+                                        blogic_err("BusLogic: Invalid Driver Options " "(invalid Queue Depth %d)\n", NULL, qdepth);
                                         return 0;
                                 }
-                                DriverOptions->CommonQueueDepth = QueueDepth;
-                                for (TargetID = 0; TargetID < BusLogic_MaxTargetDevices; TargetID++)
-                                        DriverOptions->QueueDepth[TargetID] = QueueDepth;
-                        } else if (BusLogic_ParseKeyword(&OptionsString, "TaggedQueuing:") || BusLogic_ParseKeyword(&OptionsString, "TQ:")) {
-                                if (BusLogic_ParseKeyword(&OptionsString, "Default")) {
-                                        DriverOptions->TaggedQueuingPermitted = 0x0000;
-                                        DriverOptions->TaggedQueuingPermittedMask = 0x0000;
-                                } else if (BusLogic_ParseKeyword(&OptionsString, "Enable")) {
-                                        DriverOptions->TaggedQueuingPermitted = 0xFFFF;
-                                        DriverOptions->TaggedQueuingPermittedMask = 0xFFFF;
-                                } else if (BusLogic_ParseKeyword(&OptionsString, "Disable")) {
-                                        DriverOptions->TaggedQueuingPermitted = 0x0000;
-                                        DriverOptions->TaggedQueuingPermittedMask = 0xFFFF;
+                                drvr_opts->common_qdepth = qdepth;
+                                for (tgt_id = 0; tgt_id < BLOGIC_MAXDEV; tgt_id++)
+                                        drvr_opts->qdepth[tgt_id] = qdepth;
+                        } else if (blogic_parse(&options, "TaggedQueuing:") ||
+                                        blogic_parse(&options, "TQ:")) {
+                                if (blogic_parse(&options, "Default")) {
+                                        drvr_opts->tagq_ok = 0x0000;
+                                        drvr_opts->tagq_ok_mask = 0x0000;
+                                } else if (blogic_parse(&options, "Enable")) {
+                                        drvr_opts->tagq_ok = 0xFFFF;
+                                        drvr_opts->tagq_ok_mask = 0xFFFF;
+                                } else if (blogic_parse(&options, "Disable")) {
+                                        drvr_opts->tagq_ok = 0x0000;
+                                        drvr_opts->tagq_ok_mask = 0xFFFF;
                                 } else {
-                                        unsigned short TargetBit;
-                                        for (TargetID = 0, TargetBit = 1; TargetID < BusLogic_MaxTargetDevices; TargetID++, TargetBit <<= 1)
-                                                switch (*OptionsString++) {
+                                        unsigned short tgt_bit;
+                                        for (tgt_id = 0, tgt_bit = 1;
+                                                tgt_id < BLOGIC_MAXDEV;
+                                                tgt_id++, tgt_bit <<= 1)
+                                                switch (*options++) {
                                                 case 'Y':
-                                                        DriverOptions->TaggedQueuingPermitted |= TargetBit;
-                                                        DriverOptions->TaggedQueuingPermittedMask |= TargetBit;
+                                                        drvr_opts->tagq_ok |= tgt_bit;
+                                                        drvr_opts->tagq_ok_mask |= tgt_bit;
                                                         break;
                                                 case 'N':
-                                                        DriverOptions->TaggedQueuingPermitted &= ~TargetBit;
-                                                        DriverOptions->TaggedQueuingPermittedMask |= TargetBit;
+                                                        drvr_opts->tagq_ok &= ~tgt_bit;
+                                                        drvr_opts->tagq_ok_mask |= tgt_bit;
                                                         break;
                                                 case 'X':
                                                         break;
                                                 default:
-                                                        OptionsString--;
-                                                        TargetID = BusLogic_MaxTargetDevices;
+                                                        options--;
+                                                        tgt_id = BLOGIC_MAXDEV;
                                                         break;
                                                 }
                                 }
                         }
                         /* Miscellaneous Options. */
-                        else if (BusLogic_ParseKeyword(&OptionsString, "BusSettleTime:") || BusLogic_ParseKeyword(&OptionsString, "BST:")) {
-                                unsigned short BusSettleTime = simple_strtoul(OptionsString, &OptionsString, 0);
-                                if (BusSettleTime > 5 * 60) {
-                                        BusLogic_Error("BusLogic: Invalid Driver Options " "(invalid Bus Settle Time %d)\n", NULL, BusSettleTime);
+                        else if (blogic_parse(&options, "BusSettleTime:") ||
+                                        blogic_parse(&options, "BST:")) {
+                                unsigned short bus_settle_time =
+                                        simple_strtoul(options, &options, 0);
+                                if (bus_settle_time > 5 * 60) {
+                                        blogic_err("BusLogic: Invalid Driver Options " "(invalid Bus Settle Time %d)\n", NULL, bus_settle_time);
                                         return 0;
                                 }
-                                DriverOptions->BusSettleTime = BusSettleTime;
-                        } else if (BusLogic_ParseKeyword(&OptionsString, "InhibitTargetInquiry"))
-                                DriverOptions->LocalOptions.InhibitTargetInquiry = true;
+                                drvr_opts->bus_settle_time = bus_settle_time;
+                        } else if (blogic_parse(&options,
+                                                "InhibitTargetInquiry"))
+                                drvr_opts->stop_tgt_inquiry = true;
                         /* Debugging Options. */
-                        else if (BusLogic_ParseKeyword(&OptionsString, "TraceProbe"))
-                                BusLogic_GlobalOptions.TraceProbe = true;
-                        else if (BusLogic_ParseKeyword(&OptionsString, "TraceHardwareReset"))
-                                BusLogic_GlobalOptions.TraceHardwareReset = true;
-                        else if (BusLogic_ParseKeyword(&OptionsString, "TraceConfiguration"))
-                                BusLogic_GlobalOptions.TraceConfiguration = true;
-                        else if (BusLogic_ParseKeyword(&OptionsString, "TraceErrors"))
-                                BusLogic_GlobalOptions.TraceErrors = true;
-                        else if (BusLogic_ParseKeyword(&OptionsString, "Debug")) {
-                                BusLogic_GlobalOptions.TraceProbe = true;
-                                BusLogic_GlobalOptions.TraceHardwareReset = true;
-                                BusLogic_GlobalOptions.TraceConfiguration = true;
-                                BusLogic_GlobalOptions.TraceErrors = true;
+                        else if (blogic_parse(&options, "TraceProbe"))
+                                blogic_global_options.trace_probe = true;
+                        else if (blogic_parse(&options, "TraceHardwareReset"))
+                                blogic_global_options.trace_hw_reset = true;
+                        else if (blogic_parse(&options, "TraceConfiguration"))
+                                blogic_global_options.trace_config = true;
+                        else if (blogic_parse(&options, "TraceErrors"))
+                                blogic_global_options.trace_err = true;
+                        else if (blogic_parse(&options, "Debug")) {
+                                blogic_global_options.trace_probe = true;
+                                blogic_global_options.trace_hw_reset = true;
+                                blogic_global_options.trace_config = true;
+                                blogic_global_options.trace_err = true;
                         }
-                        if (*OptionsString == ',')
-                                OptionsString++;
-                        else if (*OptionsString != ';' && *OptionsString != '\0') {
-                                BusLogic_Error("BusLogic: Unexpected Driver Option '%s' " "ignored\n", NULL, OptionsString);
-                                *OptionsString = '\0';
+                        if (*options == ',')
+                                options++;
+                        else if (*options != ';' && *options != '\0') {
+                                blogic_err("BusLogic: Unexpected Driver Option '%s' " "ignored\n", NULL, options);
+                                *options = '\0';
                         }
                 }
-                if (!(BusLogic_DriverOptionsCount == 0 || BusLogic_ProbeInfoCount == 0 || BusLogic_DriverOptionsCount == BusLogic_ProbeInfoCount)) {
-                        BusLogic_Error("BusLogic: Invalid Driver Options " "(all or no I/O Addresses must be specified)\n", NULL);
+                if (!(blogic_drvr_options_count == 0 ||
+                        blogic_probeinfo_count == 0 ||
+                        blogic_drvr_options_count == blogic_probeinfo_count)) {
+                        blogic_err("BusLogic: Invalid Driver Options " "(all or no I/O Addresses must be specified)\n", NULL);
                         return 0;
                 }
                 /*
                    Tagged Queuing is disabled when the Queue Depth is 1 since queuing
                    multiple commands is not possible.
                  */
-                for (TargetID = 0; TargetID < BusLogic_MaxTargetDevices; TargetID++)
-                        if (DriverOptions->QueueDepth[TargetID] == 1) {
-                                unsigned short TargetBit = 1 << TargetID;
-                                DriverOptions->TaggedQueuingPermitted &= ~TargetBit;
-                                DriverOptions->TaggedQueuingPermittedMask |= TargetBit;
+                for (tgt_id = 0; tgt_id < BLOGIC_MAXDEV; tgt_id++)
+                        if (drvr_opts->qdepth[tgt_id] == 1) {
+                                unsigned short tgt_bit = 1 << tgt_id;
+                                drvr_opts->tagq_ok &= ~tgt_bit;
+                                drvr_opts->tagq_ok_mask |= tgt_bit;
                         }
-                if (*OptionsString == ';')
-                        OptionsString++;
-                if (*OptionsString == '\0')
+                if (*options == ';')
+                        options++;
+                if (*options == '\0')
                         return 0;
         }
         return 1;
@@ -3555,19 +3822,19 @@ static int __init BusLogic_ParseDriverOptions(char *OptionsString)
   Get it all started
 */
 
-static struct scsi_host_template Bus_Logic_template = {
+static struct scsi_host_template blogic_template = {
         .module = THIS_MODULE,
         .proc_name = "BusLogic",
-        .write_info = BusLogic_write_info,
-        .show_info = BusLogic_show_info,
+        .write_info = blogic_write_info,
+        .show_info = blogic_show_info,
         .name = "BusLogic",
-        .info = BusLogic_DriverInfo,
-        .queuecommand = BusLogic_QueueCommand,
-        .slave_configure = BusLogic_SlaveConfigure,
-        .bios_param = BusLogic_BIOSDiskParameters,
-        .eh_host_reset_handler = BusLogic_host_reset,
+        .info = blogic_drvr_info,
+        .queuecommand = blogic_qcmd,
+        .slave_configure = blogic_slaveconfig,
+        .bios_param = blogic_diskparam,
+        .eh_host_reset_handler = blogic_hostreset,
 #if 0
-        .eh_abort_handler = BusLogic_AbortCommand,
+        .eh_abort_handler = blogic_abort,
 #endif
         .unchecked_isa_dma = 1,
         .max_sectors = 128,
@@ -3575,40 +3842,40 @@ static struct scsi_host_template Bus_Logic_template = {
 };
 
 /*
-  BusLogic_Setup handles processing of Kernel Command Line Arguments.
+  blogic_setup handles processing of Kernel Command Line Arguments.
 */
 
-static int __init BusLogic_Setup(char *str)
+static int __init blogic_setup(char *str)
 {
         int ints[3];
 
         (void) get_options(str, ARRAY_SIZE(ints), ints);
 
         if (ints[0] != 0) {
-                BusLogic_Error("BusLogic: Obsolete Command Line Entry " "Format Ignored\n", NULL);
+                blogic_err("BusLogic: Obsolete Command Line Entry " "Format Ignored\n", NULL);
                 return 0;
         }
         if (str == NULL || *str == '\0')
                 return 0;
-        return BusLogic_ParseDriverOptions(str);
+        return blogic_parseopts(str);
 }
 
 /*
  * Exit function.  Deletes all hosts associated with this driver.
  */
 
-static void __exit BusLogic_exit(void)
+static void __exit blogic_exit(void)
 {
-        struct BusLogic_HostAdapter *ha, *next;
+        struct blogic_adapter *ha, *next;
 
-        list_for_each_entry_safe(ha, next, &BusLogic_host_list, host_list)
-                BusLogic_ReleaseHostAdapter(ha);
+        list_for_each_entry_safe(ha, next, &blogic_host_list, host_list)
+                blogic_deladapter(ha);
 }
 
-__setup("BusLogic=", BusLogic_Setup);
+__setup("BusLogic=", blogic_setup);
 
 #ifdef MODULE
-static struct pci_device_id BusLogic_pci_tbl[] = {
+/*static struct pci_device_id blogic_pci_tbl[] = {
         { PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER,
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
         { PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER_NC,
@@ -3616,9 +3883,15 @@ static struct pci_device_id BusLogic_pci_tbl[] = {
         { PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_FLASHPOINT,
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
         { }
+};*/
+static DEFINE_PCI_DEVICE_TABLE(blogic_pci_tbl) = {
+        {PCI_DEVICE(PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER)},
+        {PCI_DEVICE(PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER_NC)},
+        {PCI_DEVICE(PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_FLASHPOINT)},
+        {0, },
 };
 #endif
-MODULE_DEVICE_TABLE(pci, BusLogic_pci_tbl);
+MODULE_DEVICE_TABLE(pci, blogic_pci_tbl);
 
-module_init(BusLogic_init);
-module_exit(BusLogic_exit);
+module_init(blogic_init);
+module_exit(blogic_exit);
diff --git a/drivers/scsi/BusLogic.h b/drivers/scsi/BusLogic.h
index 6c6c13c3be1b..8349c0f1438a 100644
--- a/drivers/scsi/BusLogic.h
+++ b/drivers/scsi/BusLogic.h
@@ -37,14 +37,14 @@
   Define the maximum number of BusLogic Host Adapters supported by this driver.
 */
 
-#define BusLogic_MaxHostAdapters                16
+#define BLOGIC_MAX_ADAPTERS             16
 
 
 /*
   Define the maximum number of Target Devices supported by this driver.
 */
 
-#define BusLogic_MaxTargetDevices               16
+#define BLOGIC_MAXDEV                   16
 
 
 /*
@@ -53,7 +53,7 @@
   large as the largest single request generated by the I/O Subsystem.
 */
 
-#define BusLogic_ScatterGatherLimit             128
+#define BLOGIC_SG_LIMIT         128
 
 
 /*
@@ -62,12 +62,12 @@
   Tagged Queuing and whether or not ISA Bounce Buffers are required.
 */
 
-#define BusLogic_MaxTaggedQueueDepth            64
-#define BusLogic_MaxAutomaticTaggedQueueDepth   28
-#define BusLogic_MinAutomaticTaggedQueueDepth   7
-#define BusLogic_TaggedQueueDepthBB             3
-#define BusLogic_UntaggedQueueDepth             3
-#define BusLogic_UntaggedQueueDepthBB           2
+#define BLOGIC_MAX_TAG_DEPTH            64
+#define BLOGIC_MAX_AUTO_TAG_DEPTH       28
+#define BLOGIC_MIN_AUTO_TAG_DEPTH       7
+#define BLOGIC_TAG_DEPTH_BB             3
+#define BLOGIC_UNTAG_DEPTH              3
+#define BLOGIC_UNTAG_DEPTH_BB           2
 
 
 /*
@@ -77,7 +77,7 @@
   a SCSI Bus Reset.
 */
 
-#define BusLogic_DefaultBusSettleTime           2
+#define BLOGIC_BUS_SETTLE_TIME          2
 
 
 /*
@@ -87,7 +87,7 @@
   does not cross an allocation block size boundary.
 */
 
-#define BusLogic_MaxMailboxes                   211
+#define BLOGIC_MAX_MAILBOX              211
 
 
 /*
@@ -95,50 +95,50 @@
   Kernel memory allocation.
 */
 
-#define BusLogic_CCB_AllocationGroupSize        7
+#define BLOGIC_CCB_GRP_ALLOCSIZE        7
 
 
 /*
   Define the Host Adapter Line and Message Buffer Sizes.
 */
 
-#define BusLogic_LineBufferSize                 100
-#define BusLogic_MessageBufferSize              9700
+#define BLOGIC_LINEBUF_SIZE             100
+#define BLOGIC_MSGBUF_SIZE              9700
 
 
 /*
   Define the Driver Message Levels.
 */
 
-enum BusLogic_MessageLevel {
-        BusLogic_AnnounceLevel = 0,
-        BusLogic_InfoLevel = 1,
-        BusLogic_NoticeLevel = 2,
-        BusLogic_WarningLevel = 3,
-        BusLogic_ErrorLevel = 4
+enum blogic_msglevel {
+        BLOGIC_ANNOUNCE_LEVEL = 0,
+        BLOGIC_INFO_LEVEL = 1,
+        BLOGIC_NOTICE_LEVEL = 2,
+        BLOGIC_WARN_LEVEL = 3,
+        BLOGIC_ERR_LEVEL = 4
 };
 
-static char *BusLogic_MessageLevelMap[] = { KERN_NOTICE, KERN_NOTICE, KERN_NOTICE, KERN_WARNING, KERN_ERR };
+static char *blogic_msglevelmap[] = { KERN_NOTICE, KERN_NOTICE, KERN_NOTICE, KERN_WARNING, KERN_ERR };
 
 
 /*
   Define Driver Message macros.
 */
 
-#define BusLogic_Announce(Format, Arguments...) \
-  BusLogic_Message(BusLogic_AnnounceLevel, Format, ##Arguments)
+#define blogic_announce(format, args...) \
+        blogic_msg(BLOGIC_ANNOUNCE_LEVEL, format, ##args)
 
-#define BusLogic_Info(Format, Arguments...) \
-  BusLogic_Message(BusLogic_InfoLevel, Format, ##Arguments)
+#define blogic_info(format, args...) \
+        blogic_msg(BLOGIC_INFO_LEVEL, format, ##args)
 
-#define BusLogic_Notice(Format, Arguments...) \
-  BusLogic_Message(BusLogic_NoticeLevel, Format, ##Arguments)
+#define blogic_notice(format, args...) \
+        blogic_msg(BLOGIC_NOTICE_LEVEL, format, ##args)
 
-#define BusLogic_Warning(Format, Arguments...) \
-  BusLogic_Message(BusLogic_WarningLevel, Format, ##Arguments)
+#define blogic_warn(format, args...) \
+        blogic_msg(BLOGIC_WARN_LEVEL, format, ##args)
 
-#define BusLogic_Error(Format, Arguments...) \
-  BusLogic_Message(BusLogic_ErrorLevel, Format, ##Arguments)
+#define blogic_err(format, args...) \
+        blogic_msg(BLOGIC_ERR_LEVEL, format, ##args)
 
 
 /*
@@ -146,15 +146,15 @@ static char *BusLogic_MessageLevelMap[] = { KERN_NOTICE, KERN_NOTICE, KERN_NOTIC
   of I/O Addresses required by each type.
 */
 
-enum BusLogic_HostAdapterType {
-        BusLogic_MultiMaster = 1,
-        BusLogic_FlashPoint = 2
+enum blogic_adapter_type {
+        BLOGIC_MULTIMASTER = 1,
+        BLOGIC_FLASHPOINT = 2
 } PACKED;
 
-#define BusLogic_MultiMasterAddressCount        4
-#define BusLogic_FlashPointAddressCount         256
+#define BLOGIC_MULTIMASTER_ADDR_COUNT   4
+#define BLOGIC_FLASHPOINT_ADDR_COUNT    256
 
-static int BusLogic_HostAdapterAddressCount[3] = { 0, BusLogic_MultiMasterAddressCount, BusLogic_FlashPointAddressCount };
+static int blogic_adapter_addr_count[3] = { 0, BLOGIC_MULTIMASTER_ADDR_COUNT, BLOGIC_FLASHPOINT_ADDR_COUNT };
 
 
 /*
@@ -163,19 +163,16 @@ static int BusLogic_HostAdapterAddressCount[3] = { 0, BusLogic_MultiMasterAddres
 
 #ifdef CONFIG_SCSI_FLASHPOINT
 
-#define BusLogic_MultiMasterHostAdapterP(HostAdapter) \
-  (HostAdapter->HostAdapterType == BusLogic_MultiMaster)
+#define blogic_multimaster_type(adapter) \
+        (adapter->adapter_type == BLOGIC_MULTIMASTER)
 
-#define BusLogic_FlashPointHostAdapterP(HostAdapter) \
-  (HostAdapter->HostAdapterType == BusLogic_FlashPoint)
+#define blogic_flashpoint_type(adapter) \
+        (adapter->adapter_type == BLOGIC_FLASHPOINT)
 
 #else
 
-#define BusLogic_MultiMasterHostAdapterP(HostAdapter) \
-  (true)
-
-#define BusLogic_FlashPointHostAdapterP(HostAdapter) \
-  (false)
+#define blogic_multimaster_type(adapter)        (true)
+#define blogic_flashpoint_type(adapter)         (false)
 
 #endif
 
@@ -184,35 +181,35 @@ static int BusLogic_HostAdapterAddressCount[3] = { 0, BusLogic_MultiMasterAddres
   Define the possible Host Adapter Bus Types.
 */
 
-enum BusLogic_HostAdapterBusType {
-        BusLogic_Unknown_Bus = 0,
-        BusLogic_ISA_Bus = 1,
-        BusLogic_EISA_Bus = 2,
-        BusLogic_PCI_Bus = 3,
-        BusLogic_VESA_Bus = 4,
-        BusLogic_MCA_Bus = 5
+enum blogic_adapter_bus_type {
+        BLOGIC_UNKNOWN_BUS = 0,
+        BLOGIC_ISA_BUS = 1,
+        BLOGIC_EISA_BUS = 2,
+        BLOGIC_PCI_BUS = 3,
+        BLOGIC_VESA_BUS = 4,
+        BLOGIC_MCA_BUS = 5
 } PACKED;
 
-static char *BusLogic_HostAdapterBusNames[] = { "Unknown", "ISA", "EISA", "PCI", "VESA", "MCA" };
+static char *blogic_adapter_busnames[] = { "Unknown", "ISA", "EISA", "PCI", "VESA", "MCA" };
 
-static enum BusLogic_HostAdapterBusType BusLogic_HostAdapterBusTypes[] = {
-        BusLogic_VESA_Bus,      /* BT-4xx */
-        BusLogic_ISA_Bus,       /* BT-5xx */
-        BusLogic_MCA_Bus,       /* BT-6xx */
-        BusLogic_EISA_Bus,      /* BT-7xx */
-        BusLogic_Unknown_Bus,   /* BT-8xx */
-        BusLogic_PCI_Bus        /* BT-9xx */
+static enum blogic_adapter_bus_type blogic_adater_bus_types[] = {
+        BLOGIC_VESA_BUS,        /* BT-4xx */
+        BLOGIC_ISA_BUS,         /* BT-5xx */
+        BLOGIC_MCA_BUS,         /* BT-6xx */
+        BLOGIC_EISA_BUS,        /* BT-7xx */
+        BLOGIC_UNKNOWN_BUS,     /* BT-8xx */
+        BLOGIC_PCI_BUS          /* BT-9xx */
 };
 
 /*
   Define the possible Host Adapter BIOS Disk Geometry Translations.
 */
 
-enum BusLogic_BIOS_DiskGeometryTranslation {
-        BusLogic_BIOS_Disk_Not_Installed = 0,
-        BusLogic_BIOS_Disk_Installed_64x32 = 1,
-        BusLogic_BIOS_Disk_Installed_128x32 = 2,
-        BusLogic_BIOS_Disk_Installed_255x63 = 3
+enum blogic_bios_diskgeometry {
+        BLOGIC_BIOS_NODISK = 0,
+        BLOGIC_BIOS_DISK64x32 = 1,
+        BLOGIC_BIOS_DISK128x32 = 2,
+        BLOGIC_BIOS_DISK255x63 = 3
 } PACKED;
 
 
@@ -220,9 +217,9 @@ enum BusLogic_BIOS_DiskGeometryTranslation {
   Define a 10^18 Statistics Byte Counter data type.
 */
 
-struct BusLogic_ByteCounter {
-        unsigned int Units;
-        unsigned int Billions;
+struct blogic_byte_count {
+        unsigned int units;
+        unsigned int billions;
 };
 
 
@@ -230,79 +227,71 @@ struct BusLogic_ByteCounter {
   Define the structure for I/O Address and Bus Probing Information.
 */
 
-struct BusLogic_ProbeInfo {
-        enum BusLogic_HostAdapterType HostAdapterType;
-        enum BusLogic_HostAdapterBusType HostAdapterBusType;
-        unsigned long IO_Address;
-        unsigned long PCI_Address;
-        struct pci_dev *PCI_Device;
-        unsigned char Bus;
-        unsigned char Device;
-        unsigned char IRQ_Channel;
+struct blogic_probeinfo {
+        enum blogic_adapter_type adapter_type;
+        enum blogic_adapter_bus_type adapter_bus_type;
+        unsigned long io_addr;
+        unsigned long pci_addr;
+        struct pci_dev *pci_device;
+        unsigned char bus;
+        unsigned char dev;
+        unsigned char irq_ch;
 };
 
 /*
   Define the Probe Options.
 */
 
-struct BusLogic_ProbeOptions {
-        bool NoProbe:1;         /* Bit 0 */
-        bool NoProbeISA:1;      /* Bit 1 */
-        bool NoProbePCI:1;      /* Bit 2 */
-        bool NoSortPCI:1;       /* Bit 3 */
-        bool MultiMasterFirst:1;/* Bit 4 */
-        bool FlashPointFirst:1; /* Bit 5 */
-        bool LimitedProbeISA:1; /* Bit 6 */
-        bool Probe330:1;        /* Bit 7 */
-        bool Probe334:1;        /* Bit 8 */
-        bool Probe230:1;        /* Bit 9 */
-        bool Probe234:1;        /* Bit 10 */
-        bool Probe130:1;        /* Bit 11 */
-        bool Probe134:1;        /* Bit 12 */
+struct blogic_probe_options {
+        bool noprobe:1;                 /* Bit 0 */
+        bool noprobe_isa:1;             /* Bit 1 */
+        bool noprobe_pci:1;             /* Bit 2 */
+        bool nosort_pci:1;              /* Bit 3 */
+        bool multimaster_first:1;       /* Bit 4 */
+        bool flashpoint_first:1;        /* Bit 5 */
+        bool limited_isa:1;             /* Bit 6 */
+        bool probe330:1;                /* Bit 7 */
+        bool probe334:1;                /* Bit 8 */
+        bool probe230:1;                /* Bit 9 */
+        bool probe234:1;                /* Bit 10 */
+        bool probe130:1;                /* Bit 11 */
+        bool probe134:1;                /* Bit 12 */
 };
 
 /*
   Define the Global Options.
 */
 
-struct BusLogic_GlobalOptions {
-        bool TraceProbe:1;      /* Bit 0 */
-        bool TraceHardwareReset:1;      /* Bit 1 */
-        bool TraceConfiguration:1;      /* Bit 2 */
-        bool TraceErrors:1;     /* Bit 3 */
-};
-
-/*
-  Define the Local Options.
-*/
-
-struct BusLogic_LocalOptions {
-        bool InhibitTargetInquiry:1;    /* Bit 0 */
+struct blogic_global_options {
+        bool trace_probe:1;     /* Bit 0 */
+        bool trace_hw_reset:1;  /* Bit 1 */
+        bool trace_config:1;    /* Bit 2 */
+        bool trace_err:1;       /* Bit 3 */
 };
 
 /*
   Define the BusLogic SCSI Host Adapter I/O Register Offsets.
 */
 
-#define BusLogic_ControlRegisterOffset          0       /* WO register */
-#define BusLogic_StatusRegisterOffset           0       /* RO register */
-#define BusLogic_CommandParameterRegisterOffset 1       /* WO register */
-#define BusLogic_DataInRegisterOffset           1       /* RO register */
-#define BusLogic_InterruptRegisterOffset        2       /* RO register */
-#define BusLogic_GeometryRegisterOffset         3       /* RO register */
+#define BLOGIC_CNTRL_REG        0       /* WO register */
+#define BLOGIC_STATUS_REG       0       /* RO register */
+#define BLOGIC_CMD_PARM_REG     1       /* WO register */
+#define BLOGIC_DATAIN_REG       1       /* RO register */
+#define BLOGIC_INT_REG          2       /* RO register */
+#define BLOGIC_GEOMETRY_REG     3       /* RO register */
 
 /*
   Define the structure of the write-only Control Register.
 */
 
-union BusLogic_ControlRegister {
-        unsigned char All;
+union blogic_cntrl_reg {
+        unsigned char all;
         struct {
                 unsigned char:4;        /* Bits 0-3 */
-                bool SCSIBusReset:1;    /* Bit 4 */
-                bool InterruptReset:1;  /* Bit 5 */
-                bool SoftReset:1;       /* Bit 6 */
-                bool HardReset:1;       /* Bit 7 */
+                bool bus_reset:1;       /* Bit 4 */
+                bool int_reset:1;       /* Bit 5 */
+                bool soft_reset:1;      /* Bit 6 */
+                bool hard_reset:1;      /* Bit 7 */
         } cr;
 };
 
@@ -310,17 +299,17 @@ union BusLogic_ControlRegister {
   Define the structure of the read-only Status Register.
 */
 
-union BusLogic_StatusRegister {
-        unsigned char All;
+union blogic_stat_reg {
+        unsigned char all;
         struct {
-                bool CommandInvalid:1;          /* Bit 0 */
-                bool Reserved:1;                /* Bit 1 */
-                bool DataInRegisterReady:1;     /* Bit 2 */
-                bool CommandParameterRegisterBusy:1;    /* Bit 3 */
-                bool HostAdapterReady:1;        /* Bit 4 */
-                bool InitializationRequired:1;  /* Bit 5 */
-                bool DiagnosticFailure:1;       /* Bit 6 */
-                bool DiagnosticActive:1;        /* Bit 7 */
+                bool cmd_invalid:1;     /* Bit 0 */
+                bool rsvd:1;            /* Bit 1 */
+                bool datain_ready:1;    /* Bit 2 */
+                bool cmd_param_busy:1;  /* Bit 3 */
+                bool adapter_ready:1;   /* Bit 4 */
+                bool init_reqd:1;       /* Bit 5 */
+                bool diag_failed:1;     /* Bit 6 */
+                bool diag_active:1;     /* Bit 7 */
         } sr;
 };
 
@@ -328,15 +317,15 @@ union BusLogic_StatusRegister {
   Define the structure of the read-only Interrupt Register.
 */
 
-union BusLogic_InterruptRegister {
-        unsigned char All;
+union blogic_int_reg {
+        unsigned char all;
         struct {
-                bool IncomingMailboxLoaded:1;   /* Bit 0 */
-                bool OutgoingMailboxAvailable:1;/* Bit 1 */
-                bool CommandComplete:1;         /* Bit 2 */
-                bool ExternalBusReset:1;        /* Bit 3 */
-                unsigned char Reserved:3;       /* Bits 4-6 */
-                bool InterruptValid:1;          /* Bit 7 */
+                bool mailin_loaded:1;   /* Bit 0 */
+                bool mailout_avail:1;   /* Bit 1 */
+                bool cmd_complete:1;    /* Bit 2 */
+                bool ext_busreset:1;    /* Bit 3 */
+                unsigned char rsvd:3;   /* Bits 4-6 */
+                bool int_valid:1;       /* Bit 7 */
         } ir;
 };
 
@@ -344,13 +333,13 @@ union BusLogic_InterruptRegister {
   Define the structure of the read-only Geometry Register.
 */
 
-union BusLogic_GeometryRegister {
-        unsigned char All;
+union blogic_geo_reg {
+        unsigned char all;
         struct {
-                enum BusLogic_BIOS_DiskGeometryTranslation Drive0Geometry:2;    /* Bits 0-1 */
-                enum BusLogic_BIOS_DiskGeometryTranslation Drive1Geometry:2;    /* Bits 2-3 */
+                enum blogic_bios_diskgeometry d0_geo:2; /* Bits 0-1 */
+                enum blogic_bios_diskgeometry d1_geo:2; /* Bits 2-3 */
                 unsigned char:3;        /* Bits 4-6 */
-                bool ExtendedTranslationEnabled:1;      /* Bit 7 */
+                bool ext_trans_enable:1;        /* Bit 7 */
         } gr;
 };
 
@@ -358,82 +347,82 @@ union BusLogic_GeometryRegister {
   Define the BusLogic SCSI Host Adapter Command Register Operation Codes.
 */
 
-enum BusLogic_OperationCode {
-        BusLogic_TestCommandCompleteInterrupt = 0x00,
-        BusLogic_InitializeMailbox = 0x01,
-        BusLogic_ExecuteMailboxCommand = 0x02,
-        BusLogic_ExecuteBIOSCommand = 0x03,
-        BusLogic_InquireBoardID = 0x04,
-        BusLogic_EnableOutgoingMailboxAvailableInt = 0x05,
-        BusLogic_SetSCSISelectionTimeout = 0x06,
-        BusLogic_SetPreemptTimeOnBus = 0x07,
-        BusLogic_SetTimeOffBus = 0x08,
-        BusLogic_SetBusTransferRate = 0x09,
-        BusLogic_InquireInstalledDevicesID0to7 = 0x0A,
-        BusLogic_InquireConfiguration = 0x0B,
-        BusLogic_EnableTargetMode = 0x0C,
-        BusLogic_InquireSetupInformation = 0x0D,
-        BusLogic_WriteAdapterLocalRAM = 0x1A,
-        BusLogic_ReadAdapterLocalRAM = 0x1B,
-        BusLogic_WriteBusMasterChipFIFO = 0x1C,
-        BusLogic_ReadBusMasterChipFIFO = 0x1D,
-        BusLogic_EchoCommandData = 0x1F,
-        BusLogic_HostAdapterDiagnostic = 0x20,
-        BusLogic_SetAdapterOptions = 0x21,
-        BusLogic_InquireInstalledDevicesID8to15 = 0x23,
-        BusLogic_InquireTargetDevices = 0x24,
-        BusLogic_DisableHostAdapterInterrupt = 0x25,
-        BusLogic_InitializeExtendedMailbox = 0x81,
-        BusLogic_ExecuteSCSICommand = 0x83,
-        BusLogic_InquireFirmwareVersion3rdDigit = 0x84,
-        BusLogic_InquireFirmwareVersionLetter = 0x85,
-        BusLogic_InquirePCIHostAdapterInformation = 0x86,
-        BusLogic_InquireHostAdapterModelNumber = 0x8B,
-        BusLogic_InquireSynchronousPeriod = 0x8C,
-        BusLogic_InquireExtendedSetupInformation = 0x8D,
-        BusLogic_EnableStrictRoundRobinMode = 0x8F,
-        BusLogic_StoreHostAdapterLocalRAM = 0x90,
-        BusLogic_FetchHostAdapterLocalRAM = 0x91,
-        BusLogic_StoreLocalDataInEEPROM = 0x92,
-        BusLogic_UploadAutoSCSICode = 0x94,
-        BusLogic_ModifyIOAddress = 0x95,
-        BusLogic_SetCCBFormat = 0x96,
-        BusLogic_WriteInquiryBuffer = 0x9A,
-        BusLogic_ReadInquiryBuffer = 0x9B,
-        BusLogic_FlashROMUploadDownload = 0xA7,
-        BusLogic_ReadSCAMData = 0xA8,
-        BusLogic_WriteSCAMData = 0xA9
+enum blogic_opcode {
+        BLOGIC_TEST_CMP_COMPLETE = 0x00,
+        BLOGIC_INIT_MBOX = 0x01,
+        BLOGIC_EXEC_MBOX_CMD = 0x02,
+        BLOGIC_EXEC_BIOS_CMD = 0x03,
+        BLOGIC_GET_BOARD_ID = 0x04,
+        BLOGIC_ENABLE_OUTBOX_AVAIL_INT = 0x05,
+        BLOGIC_SET_SELECT_TIMEOUT = 0x06,
+        BLOGIC_SET_PREEMPT_TIME = 0x07,
+        BLOGIC_SET_TIMEOFF_BUS = 0x08,
+        BLOGIC_SET_TXRATE = 0x09,
+        BLOGIC_INQ_DEV0TO7 = 0x0A,
+        BLOGIC_INQ_CONFIG = 0x0B,
+        BLOGIC_TGT_MODE = 0x0C,
+        BLOGIC_INQ_SETUPINFO = 0x0D,
+        BLOGIC_WRITE_LOCALRAM = 0x1A,
+        BLOGIC_READ_LOCALRAM = 0x1B,
+        BLOGIC_WRITE_BUSMASTER_FIFO = 0x1C,
+        BLOGIC_READ_BUSMASTER_FIFO = 0x1D,
+        BLOGIC_ECHO_CMDDATA = 0x1F,
+        BLOGIC_ADAPTER_DIAG = 0x20,
+        BLOGIC_SET_OPTIONS = 0x21,
+        BLOGIC_INQ_DEV8TO15 = 0x23,
+        BLOGIC_INQ_DEV = 0x24,
+        BLOGIC_DISABLE_INT = 0x25,
+        BLOGIC_INIT_EXT_MBOX = 0x81,
+        BLOGIC_EXEC_SCS_CMD = 0x83,
+        BLOGIC_INQ_FWVER_D3 = 0x84,
+        BLOGIC_INQ_FWVER_LETTER = 0x85,
+        BLOGIC_INQ_PCI_INFO = 0x86,
+        BLOGIC_INQ_MODELNO = 0x8B,
+        BLOGIC_INQ_SYNC_PERIOD = 0x8C,
+        BLOGIC_INQ_EXTSETUP = 0x8D,
+        BLOGIC_STRICT_RR = 0x8F,
+        BLOGIC_STORE_LOCALRAM = 0x90,
+        BLOGIC_FETCH_LOCALRAM = 0x91,
+        BLOGIC_STORE_TO_EEPROM = 0x92,
+        BLOGIC_LOAD_AUTOSCSICODE = 0x94,
+        BLOGIC_MOD_IOADDR = 0x95,
+        BLOGIC_SETCCB_FMT = 0x96,
+        BLOGIC_WRITE_INQBUF = 0x9A,
+        BLOGIC_READ_INQBUF = 0x9B,
+        BLOGIC_FLASH_LOAD = 0xA7,
+        BLOGIC_READ_SCAMDATA = 0xA8,
+        BLOGIC_WRITE_SCAMDATA = 0xA9
 };
 
 /*
   Define the Inquire Board ID reply structure.
 */
 
-struct BusLogic_BoardID {
-        unsigned char BoardType;        /* Byte 0 */
-        unsigned char CustomFeatures;   /* Byte 1 */
-        unsigned char FirmwareVersion1stDigit;  /* Byte 2 */
-        unsigned char FirmwareVersion2ndDigit;  /* Byte 3 */
+struct blogic_board_id {
+        unsigned char type;             /* Byte 0 */
+        unsigned char custom_features;  /* Byte 1 */
+        unsigned char fw_ver_digit1;    /* Byte 2 */
+        unsigned char fw_ver_digit2;    /* Byte 3 */
 };
 
 /*
   Define the Inquire Configuration reply structure.
 */
 
-struct BusLogic_Configuration {
+struct blogic_config {
         unsigned char:5;        /* Byte 0 Bits 0-4 */
-        bool DMA_Channel5:1;    /* Byte 0 Bit 5 */
-        bool DMA_Channel6:1;    /* Byte 0 Bit 6 */
-        bool DMA_Channel7:1;    /* Byte 0 Bit 7 */
-        bool IRQ_Channel9:1;    /* Byte 1 Bit 0 */
-        bool IRQ_Channel10:1;   /* Byte 1 Bit 1 */
-        bool IRQ_Channel11:1;   /* Byte 1 Bit 2 */
-        bool IRQ_Channel12:1;   /* Byte 1 Bit 3 */
+        bool dma_ch5:1;         /* Byte 0 Bit 5 */
+        bool dma_ch6:1;         /* Byte 0 Bit 6 */
+        bool dma_ch7:1;         /* Byte 0 Bit 7 */
+        bool irq_ch9:1;         /* Byte 1 Bit 0 */
+        bool irq_ch10:1;        /* Byte 1 Bit 1 */
+        bool irq_ch11:1;        /* Byte 1 Bit 2 */
+        bool irq_ch12:1;        /* Byte 1 Bit 3 */
         unsigned char:1;        /* Byte 1 Bit 4 */
-        bool IRQ_Channel14:1;   /* Byte 1 Bit 5 */
-        bool IRQ_Channel15:1;   /* Byte 1 Bit 6 */
+        bool irq_ch14:1;        /* Byte 1 Bit 5 */
+        bool irq_ch15:1;        /* Byte 1 Bit 6 */
         unsigned char:1;        /* Byte 1 Bit 7 */
-        unsigned char HostAdapterID:4;  /* Byte 2 Bits 0-3 */
+        unsigned char id:4;     /* Byte 2 Bits 0-3 */
         unsigned char:4;        /* Byte 2 Bits 4-7 */
 };
 
@@ -441,42 +430,42 @@ struct BusLogic_Configuration {
   Define the Inquire Setup Information reply structure.
 */
 
-struct BusLogic_SynchronousValue {
-        unsigned char Offset:4; /* Bits 0-3 */
-        unsigned char TransferPeriod:3; /* Bits 4-6 */
-        bool Synchronous:1;     /* Bit 7 */
+struct blogic_syncval {
+        unsigned char offset:4;         /* Bits 0-3 */
+        unsigned char tx_period:3;      /* Bits 4-6 */
+        bool sync:1;                    /* Bit 7 */
 };
 
-struct BusLogic_SetupInformation {
-        bool SynchronousInitiationEnabled:1;    /* Byte 0 Bit 0 */
-        bool ParityCheckingEnabled:1;           /* Byte 0 Bit 1 */
-        unsigned char:6;        /* Byte 0 Bits 2-7 */
-        unsigned char BusTransferRate;  /* Byte 1 */
-        unsigned char PreemptTimeOnBus; /* Byte 2 */
-        unsigned char TimeOffBus;       /* Byte 3 */
-        unsigned char MailboxCount;     /* Byte 4 */
-        unsigned char MailboxAddress[3];        /* Bytes 5-7 */
-        struct BusLogic_SynchronousValue SynchronousValuesID0to7[8];    /* Bytes 8-15 */
-        unsigned char DisconnectPermittedID0to7;        /* Byte 16 */
-        unsigned char Signature;        /* Byte 17 */
-        unsigned char CharacterD;       /* Byte 18 */
-        unsigned char HostBusType;      /* Byte 19 */
-        unsigned char WideTransfersPermittedID0to7;     /* Byte 20 */
-        unsigned char WideTransfersActiveID0to7;        /* Byte 21 */
-        struct BusLogic_SynchronousValue SynchronousValuesID8to15[8];   /* Bytes 22-29 */
-        unsigned char DisconnectPermittedID8to15;       /* Byte 30 */
-        unsigned char:8;        /* Byte 31 */
-        unsigned char WideTransfersPermittedID8to15;    /* Byte 32 */
-        unsigned char WideTransfersActiveID8to15;       /* Byte 33 */
+struct blogic_setup_info {
+        bool sync:1;                            /* Byte 0 Bit 0 */
+        bool parity:1;                          /* Byte 0 Bit 1 */
+        unsigned char:6;                        /* Byte 0 Bits 2-7 */
+        unsigned char tx_rate;                  /* Byte 1 */
+        unsigned char preempt_time;             /* Byte 2 */
+        unsigned char timeoff_bus;              /* Byte 3 */
+        unsigned char mbox_count;               /* Byte 4 */
+        unsigned char mbox_addr[3];             /* Bytes 5-7 */
+        struct blogic_syncval sync0to7[8];      /* Bytes 8-15 */
+        unsigned char disconnect_ok0to7;        /* Byte 16 */
+        unsigned char sig;                      /* Byte 17 */
+        unsigned char char_d;                   /* Byte 18 */
+        unsigned char bus_type;                 /* Byte 19 */
+        unsigned char wide_tx_ok0to7;           /* Byte 20 */
+        unsigned char wide_tx_active0to7;       /* Byte 21 */
+        struct blogic_syncval sync8to15[8];     /* Bytes 22-29 */
+        unsigned char disconnect_ok8to15;       /* Byte 30 */
+        unsigned char:8;                        /* Byte 31 */
+        unsigned char wide_tx_ok8to15;          /* Byte 32 */
+        unsigned char wide_tx_active8to15;      /* Byte 33 */
 };
 
 /*
   Define the Initialize Extended Mailbox request structure.
 */
 
-struct BusLogic_ExtendedMailboxRequest {
-        unsigned char MailboxCount;     /* Byte 0 */
-        u32 BaseMailboxAddress; /* Bytes 1-4 */
+struct blogic_extmbox_req {
+        unsigned char mbox_count;       /* Byte 0 */
+        u32 base_mbox_addr;             /* Bytes 1-4 */
 } PACKED;
 
 
@@ -486,63 +475,63 @@ struct BusLogic_ExtendedMailboxRequest {
   the Modify I/O Address command.
 */
 
-enum BusLogic_ISACompatibleIOPort {
-        BusLogic_IO_330 = 0,
-        BusLogic_IO_334 = 1,
-        BusLogic_IO_230 = 2,
-        BusLogic_IO_234 = 3,
-        BusLogic_IO_130 = 4,
-        BusLogic_IO_134 = 5,
-        BusLogic_IO_Disable = 6,
-        BusLogic_IO_Disable2 = 7
+enum blogic_isa_ioport {
+        BLOGIC_IO_330 = 0,
+        BLOGIC_IO_334 = 1,
+        BLOGIC_IO_230 = 2,
+        BLOGIC_IO_234 = 3,
+        BLOGIC_IO_130 = 4,
+        BLOGIC_IO_134 = 5,
+        BLOGIC_IO_DISABLE = 6,
+        BLOGIC_IO_DISABLE2 = 7
 } PACKED;
 
-struct BusLogic_PCIHostAdapterInformation {
-        enum BusLogic_ISACompatibleIOPort ISACompatibleIOPort;  /* Byte 0 */
-        unsigned char PCIAssignedIRQChannel;    /* Byte 1 */
-        bool LowByteTerminated:1;       /* Byte 2 Bit 0 */
-        bool HighByteTerminated:1;      /* Byte 2 Bit 1 */
-        unsigned char:2;        /* Byte 2 Bits 2-3 */
-        bool JP1:1;             /* Byte 2 Bit 4 */
-        bool JP2:1;             /* Byte 2 Bit 5 */
-        bool JP3:1;             /* Byte 2 Bit 6 */
-        bool GenericInfoValid:1;/* Byte 2 Bit 7 */
-        unsigned char:8;        /* Byte 3 */
+struct blogic_adapter_info {
+        enum blogic_isa_ioport isa_port;        /* Byte 0 */
+        unsigned char irq_ch;           /* Byte 1 */
+        bool low_term:1;                /* Byte 2 Bit 0 */
+        bool high_term:1;               /* Byte 2 Bit 1 */
+        unsigned char:2;                /* Byte 2 Bits 2-3 */
+        bool JP1:1;                     /* Byte 2 Bit 4 */
+        bool JP2:1;                     /* Byte 2 Bit 5 */
+        bool JP3:1;                     /* Byte 2 Bit 6 */
+        bool genericinfo_valid:1;       /* Byte 2 Bit 7 */
+        unsigned char:8;                /* Byte 3 */
 };
 
 /*
   Define the Inquire Extended Setup Information reply structure.
 */
 
-struct BusLogic_ExtendedSetupInformation {
-        unsigned char BusType;  /* Byte 0 */
-        unsigned char BIOS_Address;     /* Byte 1 */
-        unsigned short ScatterGatherLimit;      /* Bytes 2-3 */
-        unsigned char MailboxCount;     /* Byte 4 */
-        u32 BaseMailboxAddress; /* Bytes 5-8 */
+struct blogic_ext_setup {
+        unsigned char bus_type;         /* Byte 0 */
+        unsigned char bios_addr;        /* Byte 1 */
+        unsigned short sg_limit;        /* Bytes 2-3 */
+        unsigned char mbox_count;       /* Byte 4 */
+        u32 base_mbox_addr;             /* Bytes 5-8 */
         struct {
                 unsigned char:2;        /* Byte 9 Bits 0-1 */
-                bool FastOnEISA:1;      /* Byte 9 Bit 2 */
+                bool fast_on_eisa:1;    /* Byte 9 Bit 2 */
                 unsigned char:3;        /* Byte 9 Bits 3-5 */
-                bool LevelSensitiveInterrupt:1; /* Byte 9 Bit 6 */
+                bool level_int:1;       /* Byte 9 Bit 6 */
                 unsigned char:1;        /* Byte 9 Bit 7 */
-        } Misc;
-        unsigned char FirmwareRevision[3];      /* Bytes 10-12 */
-        bool HostWideSCSI:1;            /* Byte 13 Bit 0 */
-        bool HostDifferentialSCSI:1;    /* Byte 13 Bit 1 */
-        bool HostSupportsSCAM:1;        /* Byte 13 Bit 2 */
-        bool HostUltraSCSI:1;           /* Byte 13 Bit 3 */
-        bool HostSmartTermination:1;    /* Byte 13 Bit 4 */
-        unsigned char:3;        /* Byte 13 Bits 5-7 */
+        } misc;
+        unsigned char fw_rev[3];        /* Bytes 10-12 */
+        bool wide:1;                    /* Byte 13 Bit 0 */
+        bool differential:1;            /* Byte 13 Bit 1 */
+        bool scam:1;                    /* Byte 13 Bit 2 */
+        bool ultra:1;                   /* Byte 13 Bit 3 */
+        bool smart_term:1;              /* Byte 13 Bit 4 */
+        unsigned char:3;                /* Byte 13 Bits 5-7 */
 } PACKED;
 
 /*
   Define the Enable Strict Round Robin Mode request type.
 */
 
-enum BusLogic_RoundRobinModeRequest {
-        BusLogic_AggressiveRoundRobinMode = 0,
-        BusLogic_StrictRoundRobinMode = 1
+enum blogic_rr_req {
+        BLOGIC_AGGRESSIVE_RR = 0,
+        BLOGIC_STRICT_RR_MODE = 1
 } PACKED;
 
 
@@ -550,95 +539,95 @@ enum BusLogic_RoundRobinModeRequest {
   Define the Fetch Host Adapter Local RAM request type.
 */
 
-#define BusLogic_BIOS_BaseOffset                0
-#define BusLogic_AutoSCSI_BaseOffset            64
+#define BLOGIC_BIOS_BASE                0
+#define BLOGIC_AUTOSCSI_BASE            64
 
-struct BusLogic_FetchHostAdapterLocalRAMRequest {
-        unsigned char ByteOffset;       /* Byte 0 */
-        unsigned char ByteCount;        /* Byte 1 */
+struct blogic_fetch_localram {
+        unsigned char offset;   /* Byte 0 */
+        unsigned char count;    /* Byte 1 */
 };
 
 /*
   Define the Host Adapter Local RAM AutoSCSI structure.
 */
 
-struct BusLogic_AutoSCSIData {
-        unsigned char InternalFactorySignature[2];      /* Bytes 0-1 */
-        unsigned char InformationByteCount;     /* Byte 2 */
-        unsigned char HostAdapterType[6];       /* Bytes 3-8 */
-        unsigned char:8;        /* Byte 9 */
-        bool FloppyEnabled:1;           /* Byte 10 Bit 0 */
-        bool FloppySecondary:1;         /* Byte 10 Bit 1 */
-        bool LevelSensitiveInterrupt:1; /* Byte 10 Bit 2 */
-        unsigned char:2;        /* Byte 10 Bits 3-4 */
-        unsigned char SystemRAMAreaForBIOS:3;   /* Byte 10 Bits 5-7 */
-        unsigned char DMA_Channel:7;    /* Byte 11 Bits 0-6 */
-        bool DMA_AutoConfiguration:1;   /* Byte 11 Bit 7 */
-        unsigned char IRQ_Channel:7;    /* Byte 12 Bits 0-6 */
-        bool IRQ_AutoConfiguration:1;   /* Byte 12 Bit 7 */
-        unsigned char DMA_TransferRate; /* Byte 13 */
-        unsigned char SCSI_ID;  /* Byte 14 */
-        bool LowByteTerminated:1;       /* Byte 15 Bit 0 */
-        bool ParityCheckingEnabled:1;   /* Byte 15 Bit 1 */
-        bool HighByteTerminated:1;      /* Byte 15 Bit 2 */
-        bool NoisyCablingEnvironment:1; /* Byte 15 Bit 3 */
-        bool FastSynchronousNegotiation:1;      /* Byte 15 Bit 4 */
-        bool BusResetEnabled:1;         /* Byte 15 Bit 5 */
-         bool:1;                /* Byte 15 Bit 6 */
-        bool ActiveNegationEnabled:1;   /* Byte 15 Bit 7 */
-        unsigned char BusOnDelay;       /* Byte 16 */
-        unsigned char BusOffDelay;      /* Byte 17 */
-        bool HostAdapterBIOSEnabled:1;          /* Byte 18 Bit 0 */
-        bool BIOSRedirectionOfINT19Enabled:1;   /* Byte 18 Bit 1 */
-        bool ExtendedTranslationEnabled:1;      /* Byte 18 Bit 2 */
-        bool MapRemovableAsFixedEnabled:1;      /* Byte 18 Bit 3 */
-         bool:1;                /* Byte 18 Bit 4 */
-        bool BIOSSupportsMoreThan2DrivesEnabled:1;      /* Byte 18 Bit 5 */
-        bool BIOSInterruptModeEnabled:1;        /* Byte 18 Bit 6 */
-        bool FlopticalSupportEnabled:1;         /* Byte 19 Bit 7 */
-        unsigned short DeviceEnabled;   /* Bytes 19-20 */
-        unsigned short WidePermitted;   /* Bytes 21-22 */
-        unsigned short FastPermitted;   /* Bytes 23-24 */
-        unsigned short SynchronousPermitted;    /* Bytes 25-26 */
-        unsigned short DisconnectPermitted;     /* Bytes 27-28 */
-        unsigned short SendStartUnitCommand;    /* Bytes 29-30 */
-        unsigned short IgnoreInBIOSScan;        /* Bytes 31-32 */
-        unsigned char PCIInterruptPin:2;        /* Byte 33 Bits 0-1 */
-        unsigned char HostAdapterIOPortAddress:2;       /* Byte 33 Bits 2-3 */
-        bool StrictRoundRobinModeEnabled:1;     /* Byte 33 Bit 4 */
-        bool VESABusSpeedGreaterThan33MHz:1;    /* Byte 33 Bit 5 */
-        bool VESABurstWriteEnabled:1;   /* Byte 33 Bit 6 */
-        bool VESABurstReadEnabled:1;    /* Byte 33 Bit 7 */
-        unsigned short UltraPermitted;  /* Bytes 34-35 */
-        unsigned int:32;        /* Bytes 36-39 */
-        unsigned char:8;        /* Byte 40 */
-        unsigned char AutoSCSIMaximumLUN;       /* Byte 41 */
-         bool:1;                /* Byte 42 Bit 0 */
-        bool SCAM_Dominant:1;   /* Byte 42 Bit 1 */
-        bool SCAM_Enabled:1;    /* Byte 42 Bit 2 */
-        bool SCAM_Level2:1;     /* Byte 42 Bit 3 */
-        unsigned char:4;        /* Byte 42 Bits 4-7 */
-        bool INT13ExtensionEnabled:1;   /* Byte 43 Bit 0 */
-         bool:1;                /* Byte 43 Bit 1 */
-        bool CDROMBootEnabled:1;        /* Byte 43 Bit 2 */
-        unsigned char:5;        /* Byte 43 Bits 3-7 */
-        unsigned char BootTargetID:4;   /* Byte 44 Bits 0-3 */
-        unsigned char BootChannel:4;    /* Byte 44 Bits 4-7 */
-        unsigned char ForceBusDeviceScanningOrder:1;    /* Byte 45 Bit 0 */
-        unsigned char:7;        /* Byte 45 Bits 1-7 */
-        unsigned short NonTaggedToAlternateLUNPermitted;        /* Bytes 46-47 */
-        unsigned short RenegotiateSyncAfterCheckCondition;      /* Bytes 48-49 */
-        unsigned char Reserved[10];     /* Bytes 50-59 */
-        unsigned char ManufacturingDiagnostic[2];       /* Bytes 60-61 */
-        unsigned short Checksum;        /* Bytes 62-63 */
+struct blogic_autoscsi {
+        unsigned char factory_sig[2];           /* Bytes 0-1 */
+        unsigned char info_bytes;               /* Byte 2 */
+        unsigned char adapter_type[6];          /* Bytes 3-8 */
+        unsigned char:8;                        /* Byte 9 */
+        bool floppy:1;                          /* Byte 10 Bit 0 */
+        bool floppy_sec:1;                      /* Byte 10 Bit 1 */
+        bool level_int:1;                       /* Byte 10 Bit 2 */
+        unsigned char:2;                        /* Byte 10 Bits 3-4 */
+        unsigned char systemram_bios:3;         /* Byte 10 Bits 5-7 */
+        unsigned char dma_ch:7;                 /* Byte 11 Bits 0-6 */
+        bool dma_autoconf:1;                    /* Byte 11 Bit 7 */
+        unsigned char irq_ch:7;                 /* Byte 12 Bits 0-6 */
+        bool irq_autoconf:1;                    /* Byte 12 Bit 7 */
+        unsigned char dma_tx_rate;              /* Byte 13 */
+        unsigned char scsi_id;                  /* Byte 14 */
+        bool low_term:1;                        /* Byte 15 Bit 0 */
+        bool parity:1;                          /* Byte 15 Bit 1 */
+        bool high_term:1;                       /* Byte 15 Bit 2 */
+        bool noisy_cable:1;                     /* Byte 15 Bit 3 */
+        bool fast_sync_neg:1;                   /* Byte 15 Bit 4 */
+        bool reset_enabled:1;                   /* Byte 15 Bit 5 */
+        bool:1;                                 /* Byte 15 Bit 6 */
+        bool active_negation:1;                 /* Byte 15 Bit 7 */
+        unsigned char bus_on_delay;             /* Byte 16 */
+        unsigned char bus_off_delay;            /* Byte 17 */
+        bool bios_enabled:1;                    /* Byte 18 Bit 0 */
+        bool int19_redir_enabled:1;             /* Byte 18 Bit 1 */
+        bool ext_trans_enable:1;                /* Byte 18 Bit 2 */
+        bool removable_as_fixed:1;              /* Byte 18 Bit 3 */
+        bool:1;                                 /* Byte 18 Bit 4 */
+        bool morethan2_drives:1;                /* Byte 18 Bit 5 */
+        bool bios_int:1;                        /* Byte 18 Bit 6 */
+        bool floptical:1;                       /* Byte 19 Bit 7 */
+        unsigned short dev_enabled;             /* Bytes 19-20 */
+        unsigned short wide_ok;                 /* Bytes 21-22 */
+        unsigned short fast_ok;                 /* Bytes 23-24 */
+        unsigned short sync_ok;                 /* Bytes 25-26 */
+        unsigned short discon_ok;               /* Bytes 27-28 */
+        unsigned short send_start_unit;         /* Bytes 29-30 */
+        unsigned short ignore_bios_scan;        /* Bytes 31-32 */
+        unsigned char pci_int_pin:2;            /* Byte 33 Bits 0-1 */
+        unsigned char adapter_ioport:2;         /* Byte 33 Bits 2-3 */
+        bool strict_rr_enabled:1;               /* Byte 33 Bit 4 */
+        bool vesabus_33mhzplus:1;               /* Byte 33 Bit 5 */
+        bool vesa_burst_write:1;                /* Byte 33 Bit 6 */
+        bool vesa_burst_read:1;                 /* Byte 33 Bit 7 */
+        unsigned short ultra_ok;                /* Bytes 34-35 */
+        unsigned int:32;                        /* Bytes 36-39 */
+        unsigned char:8;                        /* Byte 40 */
+        unsigned char autoscsi_maxlun;          /* Byte 41 */
+        bool:1;                                 /* Byte 42 Bit 0 */
+        bool scam_dominant:1;                   /* Byte 42 Bit 1 */
+        bool scam_enabled:1;                    /* Byte 42 Bit 2 */
+        bool scam_lev2:1;                       /* Byte 42 Bit 3 */
+        unsigned char:4;                        /* Byte 42 Bits 4-7 */
+        bool int13_exten:1;                     /* Byte 43 Bit 0 */
+        bool:1;                                 /* Byte 43 Bit 1 */
+        bool cd_boot:1;                         /* Byte 43 Bit 2 */
+        unsigned char:5;                        /* Byte 43 Bits 3-7 */
+        unsigned char boot_id:4;                /* Byte 44 Bits 0-3 */
+        unsigned char boot_ch:4;                /* Byte 44 Bits 4-7 */
+        unsigned char force_scan_order:1;       /* Byte 45 Bit 0 */
+        unsigned char:7;                        /* Byte 45 Bits 1-7 */
+        unsigned short nontagged_to_alt_ok;     /* Bytes 46-47 */
+        unsigned short reneg_sync_on_check;     /* Bytes 48-49 */
+        unsigned char rsvd[10];                 /* Bytes 50-59 */
+        unsigned char manuf_diag[2];            /* Bytes 60-61 */
+        unsigned short cksum;                   /* Bytes 62-63 */
 } PACKED;
 
 /*
   Define the Host Adapter Local RAM Auto SCSI Byte 45 structure.
 */
 
-struct BusLogic_AutoSCSIByte45 {
-        unsigned char ForceBusDeviceScanningOrder:1;    /* Bit 0 */
+struct blogic_autoscsi_byte45 {
+        unsigned char force_scan_order:1;       /* Bit 0 */
         unsigned char:7;        /* Bits 1-7 */
 };
 
@@ -646,13 +635,13 @@ struct BusLogic_AutoSCSIByte45 {
   Define the Host Adapter Local RAM BIOS Drive Map Byte structure.
 */
 
-#define BusLogic_BIOS_DriveMapOffset            17
+#define BLOGIC_BIOS_DRVMAP              17
 
-struct BusLogic_BIOSDriveMapByte {
-        unsigned char TargetIDBit3:1;   /* Bit 0 */
-        unsigned char:2;        /* Bits 1-2 */
-        enum BusLogic_BIOS_DiskGeometryTranslation DiskGeometry:2;      /* Bits 3-4 */
-        unsigned char TargetID:3;       /* Bits 5-7 */
+struct blogic_bios_drvmap {
+        unsigned char tgt_idbit3:1;                     /* Bit 0 */
+        unsigned char:2;                                /* Bits 1-2 */
+        enum blogic_bios_diskgeometry diskgeom:2;       /* Bits 3-4 */
+        unsigned char tgt_id:3;                         /* Bits 5-7 */
 };
 
 /*
@@ -660,19 +649,19 @@ struct BusLogic_BIOSDriveMapByte {
   necessary to support more than 8 Logical Units per Target Device.
 */
 
-enum BusLogic_SetCCBFormatRequest {
-        BusLogic_LegacyLUNFormatCCB = 0,
-        BusLogic_ExtendedLUNFormatCCB = 1
+enum blogic_setccb_fmt {
+        BLOGIC_LEGACY_LUN_CCB = 0,
+        BLOGIC_EXT_LUN_CCB = 1
 } PACKED;
 
 /*
   Define the Outgoing Mailbox Action Codes.
 */
 
-enum BusLogic_ActionCode {
-        BusLogic_OutgoingMailboxFree = 0x00,
-        BusLogic_MailboxStartCommand = 0x01,
-        BusLogic_MailboxAbortCommand = 0x02
+enum blogic_action {
+        BLOGIC_OUTBOX_FREE = 0x00,
+        BLOGIC_MBOX_START = 0x01,
+        BLOGIC_MBOX_ABORT = 0x02
 } PACKED;
 
 
@@ -682,26 +671,26 @@ enum BusLogic_ActionCode {
   completion codes are stored in the CCB; it only uses codes 1, 2, 4, and 5.
 */
 
-enum BusLogic_CompletionCode {
-        BusLogic_IncomingMailboxFree = 0x00,
-        BusLogic_CommandCompletedWithoutError = 0x01,
-        BusLogic_CommandAbortedAtHostRequest = 0x02,
-        BusLogic_AbortedCommandNotFound = 0x03,
-        BusLogic_CommandCompletedWithError = 0x04,
-        BusLogic_InvalidCCB = 0x05
+enum blogic_cmplt_code {
+        BLOGIC_INBOX_FREE = 0x00,
+        BLOGIC_CMD_COMPLETE_GOOD = 0x01,
+        BLOGIC_CMD_ABORT_BY_HOST = 0x02,
+        BLOGIC_CMD_NOTFOUND = 0x03,
+        BLOGIC_CMD_COMPLETE_ERROR = 0x04,
+        BLOGIC_INVALID_CCB = 0x05
 } PACKED;
 
 /*
   Define the Command Control Block (CCB) Opcodes.
 */
 
-enum BusLogic_CCB_Opcode {
-        BusLogic_InitiatorCCB = 0x00,
-        BusLogic_TargetCCB = 0x01,
-        BusLogic_InitiatorCCB_ScatterGather = 0x02,
-        BusLogic_InitiatorCCB_ResidualDataLength = 0x03,
-        BusLogic_InitiatorCCB_ScatterGatherResidual = 0x04,
-        BusLogic_BusDeviceReset = 0x81
+enum blogic_ccb_opcode {
+        BLOGIC_INITIATOR_CCB = 0x00,
+        BLOGIC_TGT_CCB = 0x01,
+        BLOGIC_INITIATOR_CCB_SG = 0x02,
+        BLOGIC_INITIATOR_CCBB_RESIDUAL = 0x03,
+        BLOGIC_INITIATOR_CCB_SG_RESIDUAL = 0x04,
+        BLOGIC_BDR = 0x81
 } PACKED;
 
 
@@ -709,11 +698,11 @@ enum BusLogic_CCB_Opcode {
   Define the CCB Data Direction Codes.
 */
 
-enum BusLogic_DataDirection {
-        BusLogic_UncheckedDataTransfer = 0,
-        BusLogic_DataInLengthChecked = 1,
-        BusLogic_DataOutLengthChecked = 2,
-        BusLogic_NoDataTransfer = 3
+enum blogic_datadir {
+        BLOGIC_UNCHECKED_TX = 0,
+        BLOGIC_DATAIN_CHECKED = 1,
+        BLOGIC_DATAOUT_CHECKED = 2,
+        BLOGIC_NOTX = 3
 };
 
 
@@ -722,32 +711,32 @@ enum BusLogic_DataDirection {
   return status code 0x0C; it uses 0x12 for both overruns and underruns.
 */
 
-enum BusLogic_HostAdapterStatus {
-        BusLogic_CommandCompletedNormally = 0x00,
-        BusLogic_LinkedCommandCompleted = 0x0A,
-        BusLogic_LinkedCommandCompletedWithFlag = 0x0B,
-        BusLogic_DataUnderRun = 0x0C,
-        BusLogic_SCSISelectionTimeout = 0x11,
-        BusLogic_DataOverRun = 0x12,
-        BusLogic_UnexpectedBusFree = 0x13,
-        BusLogic_InvalidBusPhaseRequested = 0x14,
-        BusLogic_InvalidOutgoingMailboxActionCode = 0x15,
-        BusLogic_InvalidCommandOperationCode = 0x16,
-        BusLogic_LinkedCCBhasInvalidLUN = 0x17,
-        BusLogic_InvalidCommandParameter = 0x1A,
-        BusLogic_AutoRequestSenseFailed = 0x1B,
-        BusLogic_TaggedQueuingMessageRejected = 0x1C,
-        BusLogic_UnsupportedMessageReceived = 0x1D,
-        BusLogic_HostAdapterHardwareFailed = 0x20,
-        BusLogic_TargetFailedResponseToATN = 0x21,
-        BusLogic_HostAdapterAssertedRST = 0x22,
-        BusLogic_OtherDeviceAssertedRST = 0x23,
-        BusLogic_TargetDeviceReconnectedImproperly = 0x24,
-        BusLogic_HostAdapterAssertedBusDeviceReset = 0x25,
-        BusLogic_AbortQueueGenerated = 0x26,
-        BusLogic_HostAdapterSoftwareError = 0x27,
-        BusLogic_HostAdapterHardwareTimeoutError = 0x30,
-        BusLogic_SCSIParityErrorDetected = 0x34
+enum blogic_adapter_status {
+        BLOGIC_CMD_CMPLT_NORMAL = 0x00,
+        BLOGIC_LINK_CMD_CMPLT = 0x0A,
+        BLOGIC_LINK_CMD_CMPLT_FLAG = 0x0B,
+        BLOGIC_DATA_UNDERRUN = 0x0C,
+        BLOGIC_SELECT_TIMEOUT = 0x11,
+        BLOGIC_DATA_OVERRUN = 0x12,
+        BLOGIC_NOEXPECT_BUSFREE = 0x13,
+        BLOGIC_INVALID_BUSPHASE = 0x14,
+        BLOGIC_INVALID_OUTBOX_CODE = 0x15,
+        BLOGIC_INVALID_CMD_CODE = 0x16,
+        BLOGIC_LINKCCB_BADLUN = 0x17,
+        BLOGIC_BAD_CMD_PARAM = 0x1A,
+        BLOGIC_AUTOREQSENSE_FAIL = 0x1B,
+        BLOGIC_TAGQUEUE_REJECT = 0x1C,
+        BLOGIC_BAD_MSG_RCVD = 0x1D,
+        BLOGIC_HW_FAIL = 0x20,
+        BLOGIC_NORESPONSE_TO_ATN = 0x21,
+        BLOGIC_HW_RESET = 0x22,
+        BLOGIC_RST_FROM_OTHERDEV = 0x23,
+        BLOGIC_BAD_RECONNECT = 0x24,
+        BLOGIC_HW_BDR = 0x25,
+        BLOGIC_ABRT_QUEUE = 0x26,
+        BLOGIC_ADAPTER_SW_ERROR = 0x27,
+        BLOGIC_HW_TIMEOUT = 0x30,
+        BLOGIC_PARITY_ERR = 0x34
 } PACKED;
 
 
@@ -755,30 +744,28 @@ enum BusLogic_HostAdapterStatus {
   Define the SCSI Target Device Status Codes.
 */
 
-enum BusLogic_TargetDeviceStatus {
-        BusLogic_OperationGood = 0x00,
-        BusLogic_CheckCondition = 0x02,
-        BusLogic_DeviceBusy = 0x08
+enum blogic_tgt_status {
+        BLOGIC_OP_GOOD = 0x00,
+        BLOGIC_CHECKCONDITION = 0x02,
+        BLOGIC_DEVBUSY = 0x08
 } PACKED;
 
 /*
   Define the Queue Tag Codes.
 */
 
-enum BusLogic_QueueTag {
-        BusLogic_SimpleQueueTag = 0,
-        BusLogic_HeadOfQueueTag = 1,
-        BusLogic_OrderedQueueTag = 2,
-        BusLogic_ReservedQT = 3
+enum blogic_queuetag {
+        BLOGIC_SIMPLETAG = 0,
+        BLOGIC_HEADTAG = 1,
+        BLOGIC_ORDEREDTAG = 2,
+        BLOGIC_RSVDTAG = 3
 };
 
 /*
   Define the SCSI Command Descriptor Block (CDB).
 */
 
-#define BusLogic_CDB_MaxLength                  12
-
-typedef unsigned char SCSI_CDB_T[BusLogic_CDB_MaxLength];
+#define BLOGIC_CDB_MAXLEN                       12
 
 
 /*
@@ -786,20 +773,20 @@ typedef unsigned char SCSI_CDB_T[BusLogic_CDB_MaxLength];
   Firmware Interface and the FlashPoint SCCB Manager.
 */
 
-struct BusLogic_ScatterGatherSegment {
-        u32 SegmentByteCount;   /* Bytes 0-3 */
-        u32 SegmentDataPointer; /* Bytes 4-7 */
+struct blogic_sg_seg {
+        u32 segbytes;   /* Bytes 0-3 */
+        u32 segdata;    /* Bytes 4-7 */
 };
 
 /*
   Define the Driver CCB Status Codes.
 */
 
-enum BusLogic_CCB_Status {
-        BusLogic_CCB_Free = 0,
-        BusLogic_CCB_Active = 1,
-        BusLogic_CCB_Completed = 2,
-        BusLogic_CCB_Reset = 3
+enum blogic_ccb_status {
+        BLOGIC_CCB_FREE = 0,
+        BLOGIC_CCB_ACTIVE = 1,
+        BLOGIC_CCB_COMPLETE = 2,
+        BLOGIC_CCB_RESET = 3
 } PACKED;
 
 
@@ -822,79 +809,78 @@ enum BusLogic_CCB_Status {
   32 Logical Units per Target Device.
 */
 
-struct BusLogic_CCB {
+struct blogic_ccb {
         /*
            MultiMaster Firmware and FlashPoint SCCB Manager Common Portion.
          */
-        enum BusLogic_CCB_Opcode Opcode;        /* Byte 0 */
-        unsigned char:3;        /* Byte 1 Bits 0-2 */
-        enum BusLogic_DataDirection DataDirection:2;    /* Byte 1 Bits 3-4 */
-        bool TagEnable:1;       /* Byte 1 Bit 5 */
-        enum BusLogic_QueueTag QueueTag:2;      /* Byte 1 Bits 6-7 */
-        unsigned char CDB_Length;       /* Byte 2 */
-        unsigned char SenseDataLength;  /* Byte 3 */
-        u32 DataLength;         /* Bytes 4-7 */
-        u32 DataPointer;        /* Bytes 8-11 */
-        unsigned char:8;        /* Byte 12 */
-        unsigned char:8;        /* Byte 13 */
-        enum BusLogic_HostAdapterStatus HostAdapterStatus;      /* Byte 14 */
-        enum BusLogic_TargetDeviceStatus TargetDeviceStatus;    /* Byte 15 */
-        unsigned char TargetID; /* Byte 16 */
-        unsigned char LogicalUnit:5;    /* Byte 17 Bits 0-4 */
-        bool LegacyTagEnable:1; /* Byte 17 Bit 5 */
-        enum BusLogic_QueueTag LegacyQueueTag:2;        /* Byte 17 Bits 6-7 */
-        SCSI_CDB_T CDB;         /* Bytes 18-29 */
-        unsigned char:8;        /* Byte 30 */
-        unsigned char:8;        /* Byte 31 */
-        unsigned int:32;        /* Bytes 32-35 */
-        u32 SenseDataPointer;   /* Bytes 36-39 */
+        enum blogic_ccb_opcode opcode;                  /* Byte 0 */
+        unsigned char:3;                                /* Byte 1 Bits 0-2 */
+        enum blogic_datadir datadir:2;                  /* Byte 1 Bits 3-4 */
+        bool tag_enable:1;                              /* Byte 1 Bit 5 */
+        enum blogic_queuetag queuetag:2;                /* Byte 1 Bits 6-7 */
+        unsigned char cdblen;                           /* Byte 2 */
+        unsigned char sense_datalen;                    /* Byte 3 */
+        u32 datalen;                                    /* Bytes 4-7 */
+        u32 data;                                       /* Bytes 8-11 */
+        unsigned char:8;                                /* Byte 12 */
+        unsigned char:8;                                /* Byte 13 */
+        enum blogic_adapter_status adapter_status;      /* Byte 14 */
+        enum blogic_tgt_status tgt_status;              /* Byte 15 */
+        unsigned char tgt_id;                           /* Byte 16 */
+        unsigned char lun:5;                            /* Byte 17 Bits 0-4 */
+        bool legacytag_enable:1;                        /* Byte 17 Bit 5 */
+        enum blogic_queuetag legacy_tag:2;              /* Byte 17 Bits 6-7 */
+        unsigned char cdb[BLOGIC_CDB_MAXLEN];           /* Bytes 18-29 */
+        unsigned char:8;                                /* Byte 30 */
+        unsigned char:8;                                /* Byte 31 */
+        unsigned int:32;                                /* Bytes 32-35 */
+        u32 sensedata;                                  /* Bytes 36-39 */
         /*
            FlashPoint SCCB Manager Defined Portion.
          */
-        void (*CallbackFunction) (struct BusLogic_CCB *);       /* Bytes 40-43 */
-        u32 BaseAddress;        /* Bytes 44-47 */
-        enum BusLogic_CompletionCode CompletionCode;    /* Byte 48 */
+        void (*callback) (struct blogic_ccb *);         /* Bytes 40-43 */
+        u32 base_addr;                                  /* Bytes 44-47 */
+        enum blogic_cmplt_code comp_code;               /* Byte 48 */
 #ifdef CONFIG_SCSI_FLASHPOINT
-        unsigned char:8;        /* Byte 49 */
-        unsigned short OS_Flags;        /* Bytes 50-51 */
-        unsigned char Private[48];      /* Bytes 52-99 */
+        unsigned char:8;                                /* Byte 49 */
+        unsigned short os_flags;                        /* Bytes 50-51 */
+        unsigned char private[48];                      /* Bytes 52-99 */
 #endif
         /*
            BusLogic Linux Driver Defined Portion.
          */
-        dma_addr_t AllocationGroupHead;
-        unsigned int AllocationGroupSize;
-        u32 DMA_Handle;
-        enum BusLogic_CCB_Status Status;
-        unsigned long SerialNumber;
-        struct scsi_cmnd *Command;
-        struct BusLogic_HostAdapter *HostAdapter;
-        struct BusLogic_CCB *Next;
-        struct BusLogic_CCB *NextAll;
-        struct BusLogic_ScatterGatherSegment
-         ScatterGatherList[BusLogic_ScatterGatherLimit];
+        dma_addr_t allocgrp_head;
+        unsigned int allocgrp_size;
+        u32 dma_handle;
+        enum blogic_ccb_status status;
+        unsigned long serial;
+        struct scsi_cmnd *command;
+        struct blogic_adapter *adapter;
+        struct blogic_ccb *next;
+        struct blogic_ccb *next_all;
+        struct blogic_sg_seg sglist[BLOGIC_SG_LIMIT];
 };
 
 /*
   Define the 32 Bit Mode Outgoing Mailbox structure.
 */
 
-struct BusLogic_OutgoingMailbox {
-        u32 CCB;                /* Bytes 0-3 */
-        unsigned int:24;        /* Bytes 4-6 */
-        enum BusLogic_ActionCode ActionCode;    /* Byte 7 */
+struct blogic_outbox {
+        u32 ccb;                        /* Bytes 0-3 */
+        unsigned int:24;                /* Bytes 4-6 */
+        enum blogic_action action;      /* Byte 7 */
 };
 
 /*
   Define the 32 Bit Mode Incoming Mailbox structure.
 */
 
-struct BusLogic_IncomingMailbox {
-        u32 CCB;                /* Bytes 0-3 */
-        enum BusLogic_HostAdapterStatus HostAdapterStatus;      /* Byte 4 */
-        enum BusLogic_TargetDeviceStatus TargetDeviceStatus;    /* Byte 5 */
+struct blogic_inbox {
+        u32 ccb;                /* Bytes 0-3 */
+        enum blogic_adapter_status adapter_status;      /* Byte 4 */
+        enum blogic_tgt_status tgt_status;      /* Byte 5 */
         unsigned char:8;        /* Byte 6 */
-        enum BusLogic_CompletionCode CompletionCode;    /* Byte 7 */
+        enum blogic_cmplt_code comp_code;       /* Byte 7 */
 };
 
 
@@ -902,64 +888,60 @@ struct BusLogic_IncomingMailbox {
   Define the BusLogic Driver Options structure.
 */
 
-struct BusLogic_DriverOptions {
-        unsigned short TaggedQueuingPermitted;
-        unsigned short TaggedQueuingPermittedMask;
-        unsigned short BusSettleTime;
-        struct BusLogic_LocalOptions LocalOptions;
-        unsigned char CommonQueueDepth;
-        unsigned char QueueDepth[BusLogic_MaxTargetDevices];
+struct blogic_drvr_options {
+        unsigned short tagq_ok;
+        unsigned short tagq_ok_mask;
+        unsigned short bus_settle_time;
+        unsigned short stop_tgt_inquiry;
+        unsigned char common_qdepth;
+        unsigned char qdepth[BLOGIC_MAXDEV];
 };
 
 /*
   Define the Host Adapter Target Flags structure.
 */
 
-struct BusLogic_TargetFlags {
-        bool TargetExists:1;
-        bool TaggedQueuingSupported:1;
-        bool WideTransfersSupported:1;
-        bool TaggedQueuingActive:1;
-        bool WideTransfersActive:1;
-        bool CommandSuccessfulFlag:1;
-        bool TargetInfoReported:1;
+struct blogic_tgt_flags {
+        bool tgt_exists:1;
+        bool tagq_ok:1;
+        bool wide_ok:1;
+        bool tagq_active:1;
+        bool wide_active:1;
+        bool cmd_good:1;
+        bool tgt_info_in:1;
 };
 
 /*
   Define the Host Adapter Target Statistics structure.
 */
 
-#define BusLogic_SizeBuckets                    10
-
-typedef unsigned int BusLogic_CommandSizeBuckets_T[BusLogic_SizeBuckets];
-
-struct BusLogic_TargetStatistics {
-        unsigned int CommandsAttempted;
-        unsigned int CommandsCompleted;
-        unsigned int ReadCommands;
-        unsigned int WriteCommands;
-        struct BusLogic_ByteCounter TotalBytesRead;
-        struct BusLogic_ByteCounter TotalBytesWritten;
-        BusLogic_CommandSizeBuckets_T ReadCommandSizeBuckets;
-        BusLogic_CommandSizeBuckets_T WriteCommandSizeBuckets;
-        unsigned short CommandAbortsRequested;
-        unsigned short CommandAbortsAttempted;
-        unsigned short CommandAbortsCompleted;
-        unsigned short BusDeviceResetsRequested;
-        unsigned short BusDeviceResetsAttempted;
-        unsigned short BusDeviceResetsCompleted;
-        unsigned short HostAdapterResetsRequested;
-        unsigned short HostAdapterResetsAttempted;
-        unsigned short HostAdapterResetsCompleted;
+#define BLOGIC_SZ_BUCKETS                       10
+
+struct blogic_tgt_stats {
+        unsigned int cmds_tried;
+        unsigned int cmds_complete;
+        unsigned int read_cmds;
+        unsigned int write_cmds;
+        struct blogic_byte_count bytesread;
+        struct blogic_byte_count byteswritten;
+        unsigned int read_sz_buckets[BLOGIC_SZ_BUCKETS];
+        unsigned int write_sz_buckets[BLOGIC_SZ_BUCKETS];
+        unsigned short aborts_request;
+        unsigned short aborts_tried;
+        unsigned short aborts_done;
+        unsigned short bdr_request;
+        unsigned short bdr_tried;
+        unsigned short bdr_done;
+        unsigned short adatper_reset_req;
+        unsigned short adapter_reset_attempt;
+        unsigned short adapter_reset_done;
 };
 
 /*
   Define the FlashPoint Card Handle data type.
 */
 
-#define FlashPoint_BadCardHandle                0xFFFFFFFF
-
-typedef unsigned int FlashPoint_CardHandle_T;
+#define FPOINT_BADCARD_HANDLE           0xFFFFFFFF
 
 
 /*
@@ -967,179 +949,179 @@ typedef unsigned int FlashPoint_CardHandle_T;
   by the FlashPoint SCCB Manager.
 */
 
-struct FlashPoint_Info {
-        u32 BaseAddress;        /* Bytes 0-3 */
-        bool Present;           /* Byte 4 */
-        unsigned char IRQ_Channel;      /* Byte 5 */
-        unsigned char SCSI_ID;  /* Byte 6 */
-        unsigned char SCSI_LUN; /* Byte 7 */
-        unsigned short FirmwareRevision;        /* Bytes 8-9 */
-        unsigned short SynchronousPermitted;    /* Bytes 10-11 */
-        unsigned short FastPermitted;   /* Bytes 12-13 */
-        unsigned short UltraPermitted;  /* Bytes 14-15 */
-        unsigned short DisconnectPermitted;     /* Bytes 16-17 */
-        unsigned short WidePermitted;   /* Bytes 18-19 */
-        bool ParityCheckingEnabled:1;   /* Byte 20 Bit 0 */
-        bool HostWideSCSI:1;            /* Byte 20 Bit 1 */
-        bool HostSoftReset:1;           /* Byte 20 Bit 2 */
-        bool ExtendedTranslationEnabled:1;      /* Byte 20 Bit 3 */
-        bool LowByteTerminated:1;       /* Byte 20 Bit 4 */
-        bool HighByteTerminated:1;      /* Byte 20 Bit 5 */
-        bool ReportDataUnderrun:1;      /* Byte 20 Bit 6 */
-        bool SCAM_Enabled:1;    /* Byte 20 Bit 7 */
-        bool SCAM_Level2:1;     /* Byte 21 Bit 0 */
-        unsigned char:7;        /* Byte 21 Bits 1-7 */
-        unsigned char Family;   /* Byte 22 */
-        unsigned char BusType;  /* Byte 23 */
-        unsigned char ModelNumber[3];   /* Bytes 24-26 */
-        unsigned char RelativeCardNumber;       /* Byte 27 */
-        unsigned char Reserved[4];      /* Bytes 28-31 */
-        unsigned int OS_Reserved;       /* Bytes 32-35 */
-        unsigned char TranslationInfo[4];       /* Bytes 36-39 */
-        unsigned int Reserved2[5];      /* Bytes 40-59 */
-        unsigned int SecondaryRange;    /* Bytes 60-63 */
+struct fpoint_info {
+        u32 base_addr;                          /* Bytes 0-3 */
+        bool present;                           /* Byte 4 */
+        unsigned char irq_ch;                   /* Byte 5 */
+        unsigned char scsi_id;                  /* Byte 6 */
+        unsigned char scsi_lun;                 /* Byte 7 */
+        unsigned short fw_rev;                  /* Bytes 8-9 */
+        unsigned short sync_ok;                 /* Bytes 10-11 */
+        unsigned short fast_ok;                 /* Bytes 12-13 */
+        unsigned short ultra_ok;                /* Bytes 14-15 */
+        unsigned short discon_ok;               /* Bytes 16-17 */
+        unsigned short wide_ok;                 /* Bytes 18-19 */
+        bool parity:1;                          /* Byte 20 Bit 0 */
+        bool wide:1;                            /* Byte 20 Bit 1 */
+        bool softreset:1;                       /* Byte 20 Bit 2 */
+        bool ext_trans_enable:1;                /* Byte 20 Bit 3 */
+        bool low_term:1;                        /* Byte 20 Bit 4 */
+        bool high_term:1;                       /* Byte 20 Bit 5 */
+        bool report_underrun:1;                 /* Byte 20 Bit 6 */
+        bool scam_enabled:1;                    /* Byte 20 Bit 7 */
+        bool scam_lev2:1;                       /* Byte 21 Bit 0 */
+        unsigned char:7;                        /* Byte 21 Bits 1-7 */
+        unsigned char family;                   /* Byte 22 */
+        unsigned char bus_type;                 /* Byte 23 */
+        unsigned char model[3];                 /* Bytes 24-26 */
+        unsigned char relative_cardnum;         /* Byte 27 */
+        unsigned char rsvd[4];                  /* Bytes 28-31 */
+        unsigned int os_rsvd;                   /* Bytes 32-35 */
+        unsigned char translation_info[4];      /* Bytes 36-39 */
+        unsigned int rsvd2[5];                  /* Bytes 40-59 */
+        unsigned int sec_range;                 /* Bytes 60-63 */
 };
 
 /*
   Define the BusLogic Driver Host Adapter structure.
 */
 
-struct BusLogic_HostAdapter {
-        struct Scsi_Host *SCSI_Host;
-        struct pci_dev *PCI_Device;
-        enum BusLogic_HostAdapterType HostAdapterType;
-        enum BusLogic_HostAdapterBusType HostAdapterBusType;
-        unsigned long IO_Address;
-        unsigned long PCI_Address;
-        unsigned short AddressCount;
-        unsigned char HostNumber;
-        unsigned char ModelName[9];
-        unsigned char FirmwareVersion[6];
-        unsigned char FullModelName[18];
-        unsigned char Bus;
-        unsigned char Device;
-        unsigned char IRQ_Channel;
-        unsigned char DMA_Channel;
-        unsigned char SCSI_ID;
-        bool IRQ_ChannelAcquired:1;
-        bool DMA_ChannelAcquired:1;
-        bool ExtendedTranslationEnabled:1;
-        bool ParityCheckingEnabled:1;
-        bool BusResetEnabled:1;
-        bool LevelSensitiveInterrupt:1;
-        bool HostWideSCSI:1;
-        bool HostDifferentialSCSI:1;
-        bool HostSupportsSCAM:1;
-        bool HostUltraSCSI:1;
-        bool ExtendedLUNSupport:1;
-        bool TerminationInfoValid:1;
-        bool LowByteTerminated:1;
-        bool HighByteTerminated:1;
-        bool BounceBuffersRequired:1;
-        bool StrictRoundRobinModeSupport:1;
-        bool SCAM_Enabled:1;
-        bool SCAM_Level2:1;
-        bool HostAdapterInitialized:1;
-        bool HostAdapterExternalReset:1;
-        bool HostAdapterInternalError:1;
-        bool ProcessCompletedCCBsActive;
-        volatile bool HostAdapterCommandCompleted;
-        unsigned short HostAdapterScatterGatherLimit;
-        unsigned short DriverScatterGatherLimit;
-        unsigned short MaxTargetDevices;
-        unsigned short MaxLogicalUnits;
-        unsigned short MailboxCount;
-        unsigned short InitialCCBs;
-        unsigned short IncrementalCCBs;
-        unsigned short AllocatedCCBs;
-        unsigned short DriverQueueDepth;
-        unsigned short HostAdapterQueueDepth;
-        unsigned short UntaggedQueueDepth;
-        unsigned short CommonQueueDepth;
-        unsigned short BusSettleTime;
-        unsigned short SynchronousPermitted;
-        unsigned short FastPermitted;
-        unsigned short UltraPermitted;
-        unsigned short WidePermitted;
-        unsigned short DisconnectPermitted;
-        unsigned short TaggedQueuingPermitted;
-        unsigned short ExternalHostAdapterResets;
-        unsigned short HostAdapterInternalErrors;
-        unsigned short TargetDeviceCount;
-        unsigned short MessageBufferLength;
-        u32 BIOS_Address;
-        struct BusLogic_DriverOptions *DriverOptions;
-        struct FlashPoint_Info FlashPointInfo;
-        FlashPoint_CardHandle_T CardHandle;
+struct blogic_adapter {
+        struct Scsi_Host *scsi_host;
+        struct pci_dev *pci_device;
+        enum blogic_adapter_type adapter_type;
+        enum blogic_adapter_bus_type adapter_bus_type;
+        unsigned long io_addr;
+        unsigned long pci_addr;
+        unsigned short addr_count;
+        unsigned char host_no;
+        unsigned char model[9];
+        unsigned char fw_ver[6];
+        unsigned char full_model[18];
+        unsigned char bus;
+        unsigned char dev;
+        unsigned char irq_ch;
+        unsigned char dma_ch;
+        unsigned char scsi_id;
+        bool irq_acquired:1;
+        bool dma_chan_acquired:1;
+        bool ext_trans_enable:1;
+        bool parity:1;
+        bool reset_enabled:1;
+        bool level_int:1;
+        bool wide:1;
+        bool differential:1;
+        bool scam:1;
+        bool ultra:1;
+        bool ext_lun:1;
+        bool terminfo_valid:1;
+        bool low_term:1;
+        bool high_term:1;
+        bool need_bouncebuf:1;
+        bool strict_rr:1;
+        bool scam_enabled:1;
+        bool scam_lev2:1;
+        bool adapter_initd:1;
+        bool adapter_extreset:1;
+        bool adapter_intern_err:1;
+        bool processing_ccbs;
+        volatile bool adapter_cmd_complete;
+        unsigned short adapter_sglimit;
+        unsigned short drvr_sglimit;
+        unsigned short maxdev;
+        unsigned short maxlun;
+        unsigned short mbox_count;
+        unsigned short initccbs;
+        unsigned short inc_ccbs;
+        unsigned short alloc_ccbs;
+        unsigned short drvr_qdepth;
+        unsigned short adapter_qdepth;
+        unsigned short untag_qdepth;
+        unsigned short common_qdepth;
+        unsigned short bus_settle_time;
+        unsigned short sync_ok;
+        unsigned short fast_ok;
+        unsigned short ultra_ok;
+        unsigned short wide_ok;
+        unsigned short discon_ok;
+        unsigned short tagq_ok;
+        unsigned short ext_resets;
+        unsigned short adapter_intern_errors;
+        unsigned short tgt_count;
+        unsigned short msgbuflen;
+        u32 bios_addr;
+        struct blogic_drvr_options *drvr_opts;
+        struct fpoint_info fpinfo;
+        unsigned int cardhandle;
         struct list_head host_list;
-        struct BusLogic_CCB *All_CCBs;
-        struct BusLogic_CCB *Free_CCBs;
-        struct BusLogic_CCB *FirstCompletedCCB;
-        struct BusLogic_CCB *LastCompletedCCB;
-        struct BusLogic_CCB *BusDeviceResetPendingCCB[BusLogic_MaxTargetDevices];
-        struct BusLogic_TargetFlags TargetFlags[BusLogic_MaxTargetDevices];
-        unsigned char QueueDepth[BusLogic_MaxTargetDevices];
-        unsigned char SynchronousPeriod[BusLogic_MaxTargetDevices];
-        unsigned char SynchronousOffset[BusLogic_MaxTargetDevices];
-        unsigned char ActiveCommands[BusLogic_MaxTargetDevices];
-        unsigned int CommandsSinceReset[BusLogic_MaxTargetDevices];
-        unsigned long LastSequencePoint[BusLogic_MaxTargetDevices];
-        unsigned long LastResetAttempted[BusLogic_MaxTargetDevices];
-        unsigned long LastResetCompleted[BusLogic_MaxTargetDevices];
-        struct BusLogic_OutgoingMailbox *FirstOutgoingMailbox;
-        struct BusLogic_OutgoingMailbox *LastOutgoingMailbox;
-        struct BusLogic_OutgoingMailbox *NextOutgoingMailbox;
-        struct BusLogic_IncomingMailbox *FirstIncomingMailbox;
-        struct BusLogic_IncomingMailbox *LastIncomingMailbox;
-        struct BusLogic_IncomingMailbox *NextIncomingMailbox;
-        struct BusLogic_TargetStatistics TargetStatistics[BusLogic_MaxTargetDevices];
-        unsigned char *MailboxSpace;
-        dma_addr_t MailboxSpaceHandle;
-        unsigned int MailboxSize;
-        unsigned long CCB_Offset;
-        char MessageBuffer[BusLogic_MessageBufferSize];
+        struct blogic_ccb *all_ccbs;
+        struct blogic_ccb *free_ccbs;
+        struct blogic_ccb *firstccb;
+        struct blogic_ccb *lastccb;
+        struct blogic_ccb *bdr_pend[BLOGIC_MAXDEV];
+        struct blogic_tgt_flags tgt_flags[BLOGIC_MAXDEV];
+        unsigned char qdepth[BLOGIC_MAXDEV];
+        unsigned char sync_period[BLOGIC_MAXDEV];
+        unsigned char sync_offset[BLOGIC_MAXDEV];
+        unsigned char active_cmds[BLOGIC_MAXDEV];
+        unsigned int cmds_since_rst[BLOGIC_MAXDEV];
+        unsigned long last_seqpoint[BLOGIC_MAXDEV];
+        unsigned long last_resettried[BLOGIC_MAXDEV];
+        unsigned long last_resetdone[BLOGIC_MAXDEV];
+        struct blogic_outbox *first_outbox;
+        struct blogic_outbox *last_outbox;
+        struct blogic_outbox *next_outbox;
+        struct blogic_inbox *first_inbox;
+        struct blogic_inbox *last_inbox;
+        struct blogic_inbox *next_inbox;
+        struct blogic_tgt_stats tgt_stats[BLOGIC_MAXDEV];
+        unsigned char *mbox_space;
+        dma_addr_t mbox_space_handle;
+        unsigned int mbox_sz;
+        unsigned long ccb_offset;
+        char msgbuf[BLOGIC_MSGBUF_SIZE];
 };
 
 /*
   Define a structure for the BIOS Disk Parameters.
 */
 
-struct BIOS_DiskParameters {
-        int Heads;
-        int Sectors;
-        int Cylinders;
+struct bios_diskparam {
+        int heads;
+        int sectors;
+        int cylinders;
 };
 
 /*
   Define a structure for the SCSI Inquiry command results.
 */
 
-struct SCSI_Inquiry {
-        unsigned char PeripheralDeviceType:5;   /* Byte 0 Bits 0-4 */
-        unsigned char PeripheralQualifier:3;    /* Byte 0 Bits 5-7 */
-        unsigned char DeviceTypeModifier:7;     /* Byte 1 Bits 0-6 */
-        bool RMB:1;             /* Byte 1 Bit 7 */
-        unsigned char ANSI_ApprovedVersion:3;   /* Byte 2 Bits 0-2 */
-        unsigned char ECMA_Version:3;   /* Byte 2 Bits 3-5 */
-        unsigned char ISO_Version:2;    /* Byte 2 Bits 6-7 */
-        unsigned char ResponseDataFormat:4;     /* Byte 3 Bits 0-3 */
-        unsigned char:2;        /* Byte 3 Bits 4-5 */
-        bool TrmIOP:1;          /* Byte 3 Bit 6 */
-        bool AENC:1;            /* Byte 3 Bit 7 */
-        unsigned char AdditionalLength; /* Byte 4 */
-        unsigned char:8;        /* Byte 5 */
-        unsigned char:8;        /* Byte 6 */
-        bool SftRe:1;           /* Byte 7 Bit 0 */
-        bool CmdQue:1;          /* Byte 7 Bit 1 */
-         bool:1;                /* Byte 7 Bit 2 */
-        bool Linked:1;          /* Byte 7 Bit 3 */
-        bool Sync:1;            /* Byte 7 Bit 4 */
-        bool WBus16:1;          /* Byte 7 Bit 5 */
-        bool WBus32:1;          /* Byte 7 Bit 6 */
-        bool RelAdr:1;          /* Byte 7 Bit 7 */
-        unsigned char VendorIdentification[8];  /* Bytes 8-15 */
-        unsigned char ProductIdentification[16];        /* Bytes 16-31 */
-        unsigned char ProductRevisionLevel[4];  /* Bytes 32-35 */
+struct scsi_inquiry {
+        unsigned char devtype:5;        /* Byte 0 Bits 0-4 */
+        unsigned char dev_qual:3;       /* Byte 0 Bits 5-7 */
+        unsigned char dev_modifier:7;   /* Byte 1 Bits 0-6 */
+        bool rmb:1;                     /* Byte 1 Bit 7 */
+        unsigned char ansi_ver:3;       /* Byte 2 Bits 0-2 */
+        unsigned char ecma_ver:3;       /* Byte 2 Bits 3-5 */
+        unsigned char iso_ver:2;        /* Byte 2 Bits 6-7 */
+        unsigned char resp_fmt:4;       /* Byte 3 Bits 0-3 */
+        unsigned char:2;                /* Byte 3 Bits 4-5 */
+        bool TrmIOP:1;                  /* Byte 3 Bit 6 */
+        bool AENC:1;                    /* Byte 3 Bit 7 */
+        unsigned char addl_len;         /* Byte 4 */
+        unsigned char:8;                /* Byte 5 */
+        unsigned char:8;                /* Byte 6 */
+        bool SftRe:1;                   /* Byte 7 Bit 0 */
+        bool CmdQue:1;                  /* Byte 7 Bit 1 */
+        bool:1;                         /* Byte 7 Bit 2 */
+        bool linked:1;                  /* Byte 7 Bit 3 */
+        bool sync:1;                    /* Byte 7 Bit 4 */
+        bool WBus16:1;                  /* Byte 7 Bit 5 */
+        bool WBus32:1;                  /* Byte 7 Bit 6 */
+        bool RelAdr:1;                  /* Byte 7 Bit 7 */
+        unsigned char vendor[8];        /* Bytes 8-15 */
+        unsigned char product[16];      /* Bytes 16-31 */
+        unsigned char product_rev[4];   /* Bytes 32-35 */
 };
 
 
@@ -1148,184 +1130,170 @@ struct SCSI_Inquiry {
   Host Adapter I/O Registers.
 */
 
-static inline void BusLogic_SCSIBusReset(struct BusLogic_HostAdapter *HostAdapter)
+static inline void blogic_busreset(struct blogic_adapter *adapter)
 {
-        union BusLogic_ControlRegister ControlRegister;
-        ControlRegister.All = 0;
-        ControlRegister.cr.SCSIBusReset = true;
-        outb(ControlRegister.All, HostAdapter->IO_Address + BusLogic_ControlRegisterOffset);
+        union blogic_cntrl_reg cr;
+        cr.all = 0;
+        cr.cr.bus_reset = true;
+        outb(cr.all, adapter->io_addr + BLOGIC_CNTRL_REG);
 }
 
-static inline void BusLogic_InterruptReset(struct BusLogic_HostAdapter *HostAdapter)
+static inline void blogic_intreset(struct blogic_adapter *adapter)
 {
-        union BusLogic_ControlRegister ControlRegister;
-        ControlRegister.All = 0;
-        ControlRegister.cr.InterruptReset = true;
-        outb(ControlRegister.All, HostAdapter->IO_Address + BusLogic_ControlRegisterOffset);
+        union blogic_cntrl_reg cr;
+        cr.all = 0;
+        cr.cr.int_reset = true;
+        outb(cr.all, adapter->io_addr + BLOGIC_CNTRL_REG);
 }
 
-static inline void BusLogic_SoftReset(struct BusLogic_HostAdapter *HostAdapter)
+static inline void blogic_softreset(struct blogic_adapter *adapter)
 {
-        union BusLogic_ControlRegister ControlRegister;
-        ControlRegister.All = 0;
-        ControlRegister.cr.SoftReset = true;
-        outb(ControlRegister.All, HostAdapter->IO_Address + BusLogic_ControlRegisterOffset);
+        union blogic_cntrl_reg cr;
+        cr.all = 0;
+        cr.cr.soft_reset = true;
+        outb(cr.all, adapter->io_addr + BLOGIC_CNTRL_REG);
 }
 
-static inline void BusLogic_HardReset(struct BusLogic_HostAdapter *HostAdapter)
+static inline void blogic_hardreset(struct blogic_adapter *adapter)
 {
-        union BusLogic_ControlRegister ControlRegister;
-        ControlRegister.All = 0;
-        ControlRegister.cr.HardReset = true;
-        outb(ControlRegister.All, HostAdapter->IO_Address + BusLogic_ControlRegisterOffset);
+        union blogic_cntrl_reg cr;
+        cr.all = 0;
+        cr.cr.hard_reset = true;
+        outb(cr.all, adapter->io_addr + BLOGIC_CNTRL_REG);
 }
 
-static inline unsigned char BusLogic_ReadStatusRegister(struct BusLogic_HostAdapter *HostAdapter)
+static inline unsigned char blogic_rdstatus(struct blogic_adapter *adapter)
 {
-        return inb(HostAdapter->IO_Address + BusLogic_StatusRegisterOffset);
+        return inb(adapter->io_addr + BLOGIC_STATUS_REG);
 }
 
-static inline void BusLogic_WriteCommandParameterRegister(struct BusLogic_HostAdapter
-                                                          *HostAdapter, unsigned char Value)
+static inline void blogic_setcmdparam(struct blogic_adapter *adapter,
+                                        unsigned char value)
 {
-        outb(Value, HostAdapter->IO_Address + BusLogic_CommandParameterRegisterOffset);
+        outb(value, adapter->io_addr + BLOGIC_CMD_PARM_REG);
 }
 
-static inline unsigned char BusLogic_ReadDataInRegister(struct BusLogic_HostAdapter *HostAdapter)
+static inline unsigned char blogic_rddatain(struct blogic_adapter *adapter)
 {
-        return inb(HostAdapter->IO_Address + BusLogic_DataInRegisterOffset);
+        return inb(adapter->io_addr + BLOGIC_DATAIN_REG);
 }
 
-static inline unsigned char BusLogic_ReadInterruptRegister(struct BusLogic_HostAdapter *HostAdapter)
+static inline unsigned char blogic_rdint(struct blogic_adapter *adapter)
 {
-        return inb(HostAdapter->IO_Address + BusLogic_InterruptRegisterOffset);
+        return inb(adapter->io_addr + BLOGIC_INT_REG);
 }
 
-static inline unsigned char BusLogic_ReadGeometryRegister(struct BusLogic_HostAdapter *HostAdapter)
+static inline unsigned char blogic_rdgeom(struct blogic_adapter *adapter)
 {
-        return inb(HostAdapter->IO_Address + BusLogic_GeometryRegisterOffset);
+        return inb(adapter->io_addr + BLOGIC_GEOMETRY_REG);
 }
 
 /*
-  BusLogic_StartMailboxCommand issues an Execute Mailbox Command, which
+  blogic_execmbox issues an Execute Mailbox Command, which
   notifies the Host Adapter that an entry has been made in an Outgoing
   Mailbox.
 */
 
-static inline void BusLogic_StartMailboxCommand(struct BusLogic_HostAdapter *HostAdapter)
+static inline void blogic_execmbox(struct blogic_adapter *adapter)
 {
-        BusLogic_WriteCommandParameterRegister(HostAdapter, BusLogic_ExecuteMailboxCommand);
+        blogic_setcmdparam(adapter, BLOGIC_EXEC_MBOX_CMD);
 }
 
 /*
-  BusLogic_Delay waits for Seconds to elapse.
+  blogic_delay waits for Seconds to elapse.
 */
 
-static inline void BusLogic_Delay(int Seconds)
-{
-        mdelay(1000 * Seconds);
-}
-
-/*
-  Virtual_to_Bus and Bus_to_Virtual map between Kernel Virtual Addresses
-  and PCI/VLB/EISA/ISA Bus Addresses.
-*/
-
-static inline u32 Virtual_to_Bus(void *VirtualAddress)
-{
-        return (u32) virt_to_bus(VirtualAddress);
-}
-
-static inline void *Bus_to_Virtual(u32 BusAddress)
+static inline void blogic_delay(int seconds)
 {
-        return (void *) bus_to_virt(BusAddress);
+        mdelay(1000 * seconds);
 }
 
 /*
-  Virtual_to_32Bit_Virtual maps between Kernel Virtual Addresses and
+  virt_to_32bit_virt maps between Kernel Virtual Addresses and
   32 bit Kernel Virtual Addresses.  This avoids compilation warnings
   on 64 bit architectures.
 */
 
-static inline u32 Virtual_to_32Bit_Virtual(void *VirtualAddress)
+static inline u32 virt_to_32bit_virt(void *virt_addr)
 {
-        return (u32) (unsigned long) VirtualAddress;
+        return (u32) (unsigned long) virt_addr;
 }
 
 /*
-  BusLogic_IncrementErrorCounter increments Error Counter by 1, stopping at
+  blogic_inc_count increments counter by 1, stopping at
   65535 rather than wrapping around to 0.
 */
 
-static inline void BusLogic_IncrementErrorCounter(unsigned short *ErrorCounter)
+static inline void blogic_inc_count(unsigned short *count)
 {
-        if (*ErrorCounter < 65535)
-                (*ErrorCounter)++;
+        if (*count < 65535)
+                (*count)++;
 }
 
 /*
-  BusLogic_IncrementByteCounter increments Byte Counter by Amount.
+  blogic_addcount increments Byte Counter by Amount.
 */
 
-static inline void BusLogic_IncrementByteCounter(struct BusLogic_ByteCounter
-                                                 *ByteCounter, unsigned int Amount)
+static inline void blogic_addcount(struct blogic_byte_count *bytecount,
+                                        unsigned int amount)
 {
-        ByteCounter->Units += Amount;
-        if (ByteCounter->Units > 999999999) {
-                ByteCounter->Units -= 1000000000;
-                ByteCounter->Billions++;
+        bytecount->units += amount;
+        if (bytecount->units > 999999999) {
+                bytecount->units -= 1000000000;
+                bytecount->billions++;
         }
 }
 
 /*
-  BusLogic_IncrementSizeBucket increments the Bucket for Amount.
+  blogic_incszbucket increments the Bucket for Amount.
 */
 
-static inline void BusLogic_IncrementSizeBucket(BusLogic_CommandSizeBuckets_T CommandSizeBuckets, unsigned int Amount)
+static inline void blogic_incszbucket(unsigned int *cmdsz_buckets,
+                                        unsigned int amount)
 {
-        int Index = 0;
-        if (Amount < 8 * 1024) {
-                if (Amount < 2 * 1024)
-                        Index = (Amount < 1 * 1024 ? 0 : 1);
+        int index = 0;
+        if (amount < 8 * 1024) {
+                if (amount < 2 * 1024)
+                        index = (amount < 1 * 1024 ? 0 : 1);
                 else
-                        Index = (Amount < 4 * 1024 ? 2 : 3);
-        } else if (Amount < 128 * 1024) {
-                if (Amount < 32 * 1024)
-                        Index = (Amount < 16 * 1024 ? 4 : 5);
+                        index = (amount < 4 * 1024 ? 2 : 3);
+        } else if (amount < 128 * 1024) {
+                if (amount < 32 * 1024)
+                        index = (amount < 16 * 1024 ? 4 : 5);
                 else
-                        Index = (Amount < 64 * 1024 ? 6 : 7);
+                        index = (amount < 64 * 1024 ? 6 : 7);
         } else
-                Index = (Amount < 256 * 1024 ? 8 : 9);
-        CommandSizeBuckets[Index]++;
+                index = (amount < 256 * 1024 ? 8 : 9);
+        cmdsz_buckets[index]++;
 }
 
 /*
   Define the version number of the FlashPoint Firmware (SCCB Manager).
 */
 
-#define FlashPoint_FirmwareVersion              "5.02"
+#define FLASHPOINT_FW_VER               "5.02"
 
 /*
   Define the possible return values from FlashPoint_HandleInterrupt.
 */
 
-#define FlashPoint_NormalInterrupt              0x00
-#define FlashPoint_InternalError                0xFE
-#define FlashPoint_ExternalBusReset             0xFF
+#define FPOINT_NORMAL_INT               0x00
+#define FPOINT_INTERN_ERR               0xFE
+#define FPOINT_EXT_RESET                0xFF
 
 /*
   Define prototypes for the forward referenced BusLogic Driver
   Internal Functions.
 */
 
-static const char *BusLogic_DriverInfo(struct Scsi_Host *);
-static int BusLogic_QueueCommand(struct Scsi_Host *h, struct scsi_cmnd *);
-static int BusLogic_BIOSDiskParameters(struct scsi_device *, struct block_device *, sector_t, int *);
-static int BusLogic_SlaveConfigure(struct scsi_device *);
-static void BusLogic_QueueCompletedCCB(struct BusLogic_CCB *);
-static irqreturn_t BusLogic_InterruptHandler(int, void *);
-static int BusLogic_ResetHostAdapter(struct BusLogic_HostAdapter *, bool HardReset);
-static void BusLogic_Message(enum BusLogic_MessageLevel, char *, struct BusLogic_HostAdapter *, ...);
-static int __init BusLogic_Setup(char *);
+static const char *blogic_drvr_info(struct Scsi_Host *);
+static int blogic_qcmd(struct Scsi_Host *h, struct scsi_cmnd *);
+static int blogic_diskparam(struct scsi_device *, struct block_device *, sector_t, int *);
+static int blogic_slaveconfig(struct scsi_device *);
+static void blogic_qcompleted_ccb(struct blogic_ccb *);
+static irqreturn_t blogic_inthandler(int, void *);
+static int blogic_resetadapter(struct blogic_adapter *, bool hard_reset);
+static void blogic_msg(enum blogic_msglevel, char *, struct blogic_adapter *, ...);
+static int __init blogic_setup(char *);
 
 #endif                          /* _BUSLOGIC_H */
diff --git a/drivers/scsi/FlashPoint.c b/drivers/scsi/FlashPoint.c
index dcd716d68600..902972050063 100644
--- a/drivers/scsi/FlashPoint.c
+++ b/drivers/scsi/FlashPoint.c
@@ -7573,47 +7573,47 @@ static unsigned char FPT_CalcLrc(unsigned char buffer[])
 */
 
 static inline unsigned char
-FlashPoint__ProbeHostAdapter(struct FlashPoint_Info *FlashPointInfo)
+FlashPoint__ProbeHostAdapter(struct fpoint_info *FlashPointInfo)
 {
         return FlashPoint_ProbeHostAdapter((struct sccb_mgr_info *)
                                            FlashPointInfo);
 }
 
-static inline FlashPoint_CardHandle_T
-FlashPoint__HardwareResetHostAdapter(struct FlashPoint_Info *FlashPointInfo)
+static inline unsigned int
+FlashPoint__HardwareResetHostAdapter(struct fpoint_info *FlashPointInfo)
 {
         return FlashPoint_HardwareResetHostAdapter((struct sccb_mgr_info *)
                                                    FlashPointInfo);
 }
 
 static inline void
-FlashPoint__ReleaseHostAdapter(FlashPoint_CardHandle_T CardHandle)
+FlashPoint__ReleaseHostAdapter(unsigned int CardHandle)
 {
         FlashPoint_ReleaseHostAdapter(CardHandle);
 }
 
 static inline void
-FlashPoint__StartCCB(FlashPoint_CardHandle_T CardHandle,
-                     struct BusLogic_CCB *CCB)
+FlashPoint__StartCCB(unsigned int CardHandle,
+                     struct blogic_ccb *CCB)
 {
         FlashPoint_StartCCB(CardHandle, (struct sccb *)CCB);
 }
 
 static inline void
-FlashPoint__AbortCCB(FlashPoint_CardHandle_T CardHandle,
-                     struct BusLogic_CCB *CCB)
+FlashPoint__AbortCCB(unsigned int CardHandle,
+                     struct blogic_ccb *CCB)
 {
         FlashPoint_AbortCCB(CardHandle, (struct sccb *)CCB);
 }
 
 static inline bool
-FlashPoint__InterruptPending(FlashPoint_CardHandle_T CardHandle)
+FlashPoint__InterruptPending(unsigned int CardHandle)
 {
         return FlashPoint_InterruptPending(CardHandle);
 }
 
 static inline int
-FlashPoint__HandleInterrupt(FlashPoint_CardHandle_T CardHandle)
+FlashPoint__HandleInterrupt(unsigned int CardHandle)
 {
         return FlashPoint_HandleInterrupt(CardHandle);
 }
@@ -7632,13 +7632,12 @@ FlashPoint__HandleInterrupt(FlashPoint_CardHandle_T CardHandle)
   Define prototypes for the FlashPoint SCCB Manager Functions.
 */
 
-extern unsigned char FlashPoint_ProbeHostAdapter(struct FlashPoint_Info *);
-extern FlashPoint_CardHandle_T
-FlashPoint_HardwareResetHostAdapter(struct FlashPoint_Info *);
-extern void FlashPoint_StartCCB(FlashPoint_CardHandle_T, struct BusLogic_CCB *);
-extern int FlashPoint_AbortCCB(FlashPoint_CardHandle_T, struct BusLogic_CCB *);
-extern bool FlashPoint_InterruptPending(FlashPoint_CardHandle_T);
-extern int FlashPoint_HandleInterrupt(FlashPoint_CardHandle_T);
-extern void FlashPoint_ReleaseHostAdapter(FlashPoint_CardHandle_T);
+extern unsigned char FlashPoint_ProbeHostAdapter(struct fpoint_info *);
+extern unsigned int FlashPoint_HardwareResetHostAdapter(struct fpoint_info *);
+extern void FlashPoint_StartCCB(unsigned int, struct blogic_ccb *);
+extern int FlashPoint_AbortCCB(unsigned int, struct blogic_ccb *);
+extern bool FlashPoint_InterruptPending(unsigned int);
+extern int FlashPoint_HandleInterrupt(unsigned int);
+extern void FlashPoint_ReleaseHostAdapter(unsigned int);
 
 #endif                          /* CONFIG_SCSI_FLASHPOINT */