windows-nt-4.0/private/ntos/miniport/buslogic/buslogic.c

/*++

Copyright (c) 1992  BusLogic, Inc.

Module Name:

    Buslogic.c

Abstract:

    This is the port driver for the BusLogic SCSI ISA/EISA/MCA Adapters.

Environment:

    kernel mode only

Notes:

Revision History:

--*/

#include "miniport.h"
#include "buslogic.h"               // includes scsi.h

//
// The following table specifies the ports to be checked when searching for
// an adapter.  A zero entry terminates the search.
//

ULONG AdapterAddresses[] = {0X330, 0X334, 0X234, 0X134, 0X130, 0X230, 0};
ULONG PciAdapterAddresses[] = {0Xfff,0xfff,0xfff,0xfff,0xfff,0xfff,0}; /* dummy entry for PCI */

UCHAR VendorId[4]={'1','0','4','b'};
UCHAR NewDeviceId[4]={'1','0','4','0'};

ULONG InittedEISABoards = 0;
//
// Function declarations
//
// Functions that start with 'BLogic' are entry points
// for the OS port driver.
//

ULONG
DriverEntry(
    IN PVOID DriverObject,
    IN PVOID Argument2
    );

ULONG
BLogicEntry(
    IN PVOID DriverObject,
    IN PVOID Argument2
    );

ULONG
BLogicDetermineInstalled(
    IN PCARD_STRUC CardPtr,
    IN OUT PPORT_CONFIGURATION_INFORMATION ConfigInfo,
    IN OUT PBL_CONTEXT CurrContextPtr,
    OUT PBOOLEAN Again
    );

ULONG
BLogicFindAdapter (
    IN PCARD_STRUC CardPtr,
    IN PVOID Context,
    IN PVOID BusInformation,
    IN PCHAR ArgumentString,
    IN OUT PPORT_CONFIGURATION_INFORMATION ConfigInfo,
    OUT PBOOLEAN Again
    );

BOOLEAN
BLogicAdapterState(
    IN PCARD_STRUC CardPtr,
    IN PVOID Context,
    IN BOOLEAN SaveState
    );

BOOLEAN
BLogicHwInitialize(
    IN PCARD_STRUC CardPtr
    );

BOOLEAN
BLogicStartIo(
    IN PCARD_STRUC CardPtr,
    IN PSCSI_REQUEST_BLOCK Srb
    );

BOOLEAN
BLogicInterrupt(
    IN PCARD_STRUC CardPtr
    );

BOOLEAN
BLogicResetBus(
    IN PCARD_STRUC CardPtr,
    IN ULONG PathId
    );

BOOLEAN
ResetBus(
    IN PCARD_STRUC CardPtr,
    IN ULONG PathId
    );

// Add the following function back in!

BOOLEAN
ReInitializeHBA(
    IN PCARD_STRUC CardPtr,
    IN ULONG PathId
    );
//
// This function is called from BLogicStartIo.
//

VOID
BuildCcb(
    IN PCARD_STRUC CardPtr,
    IN PSCSI_REQUEST_BLOCK Srb
    );

//
// This function is called from BuildCcb.
//

VOID
BuildSdl(
    IN PCARD_STRUC CardPtr,
    IN PSCSI_REQUEST_BLOCK Srb
    );

//
// This function is called from BLogicInitialize.
//

BOOLEAN
AdapterPresent(
    IN PCARD_STRUC CardPtr
    );

//
// This function is called from BLogicInterrupt.
//

UCHAR
MapError(
    IN PCARD_STRUC CardPtr,
    IN PSCSI_REQUEST_BLOCK Srb,
    IN PCCB Ccb
    );

BOOLEAN
ReadCommandRegister(
    IN PCARD_STRUC CardPtr,
    OUT PUCHAR DataByte
    );

BOOLEAN
WriteCommandRegister(
    IN PCARD_STRUC CardPtr,
    IN UCHAR AdapterCommand
    );

BOOLEAN
AdjustCCBqueue(
    PCCB ccbp,
    IN PDEV_STRUC devptr
    );

PMBI
DoneMbox(
    IN PCARD_STRUC CardPtr
    );

BOOLEAN
SendCCB(
    IN PSCSI_REQUEST_BLOCK Srb,
    IN PCARD_STRUC CardPtr,
    IN PDEV_STRUC DevStruc
    );

BOOLEAN
FinishHBACmd(
    IN PCARD_STRUC CardPtr
    );

BOOLEAN
CheckInvalid(
    IN PCARD_STRUC CardPtr
    );

ULONG
FindOurEISAId(
    IN PCARD_STRUC CardPtr,
    IN OUT PPORT_CONFIGURATION_INFORMATION ConfigInfo,
    PBASE_REGISTER baseIoAddress
    );

ULONG
DriverEntry (
    IN PVOID DriverObject,
    IN PVOID Argument2
    )

/*++

Routine Description:

    Installable driver initialization entry point for system.

Arguments:

    Driver Object

Return Value:

    Status from ScsiPortInitialize()

--*/

{
    return BLogicEntry(DriverObject, Argument2);

} // end DriverEntry()


ULONG
BLogicEntry(
    IN PVOID DriverObject,
    IN PVOID Argument2
    )

/*++

Routine Description:

    This routine is called from DriverEntry if this driver is installable
    or directly from the system if the driver is built into the kernel.
    It calls the OS dependent driver which controls the initialization.

Arguments:

    Driver Object

Return Value:

    Status return by scsi port intialize.

--*/

{
    HW_INITIALIZATION_DATA hwInitializationData;
    BL_CONTEXT CurrContext;
    PBL_CONTEXT CurrContextPtr = &CurrContext;
    ULONG isaStatus;
    ULONG mcaStatus;
    ULONG EisaStatus;
    ULONG i,PCIStatus,LowStatus1,LowStatus2;

    DebugPrint((1,"\n\nBusLogic SCSI MiniPort Driver\n"));

    //
    // Zero out structure.
    //

    for (i=0; i<sizeof(HW_INITIALIZATION_DATA); i++) {
        ((PUCHAR)&hwInitializationData)[i] = 0;
    }

    //
    // Set size of hwInitializationData.
    //

    hwInitializationData.HwInitializationDataSize = sizeof(HW_INITIALIZATION_DATA);

    //
    // Set entry points.
    //

    hwInitializationData.HwInitialize = (PHW_INITIALIZE) BLogicHwInitialize;
    hwInitializationData.HwResetBus = (PHW_RESET_BUS) BLogicResetBus;
    hwInitializationData.HwStartIo = (PHW_STARTIO) BLogicStartIo;
    hwInitializationData.HwInterrupt = (PHW_INTERRUPT) BLogicInterrupt;
    hwInitializationData.HwFindAdapter = (PHW_FIND_ADAPTER) BLogicFindAdapter;
    hwInitializationData.HwAdapterState = BLogicAdapterState;

    //
    // Indicate no buffer mapping but will need physical addresses.
    //

     hwInitializationData.NeedPhysicalAddresses = TRUE;
     hwInitializationData.AutoRequestSense = TRUE;
     hwInitializationData.TaggedQueuing = TRUE;
     hwInitializationData.MultipleRequestPerLu = TRUE;

    //
    // Specify size of extensions.
    //

    hwInitializationData.DeviceExtensionSize = sizeof(CARD_STRUC);
    hwInitializationData.SpecificLuExtensionSize = sizeof(DEV_STRUC);
    hwInitializationData.NumberOfAccessRanges = 1;

    //
    // Ask for SRB extensions for CCBs.
    //

    hwInitializationData.SrbExtensionSize = sizeof(CCB);

    //
    // The adapter count is used by the find adapter routine to track how
    // which adapter addresses have been tested.
    //

    CurrContextPtr->AdapterCount = 0;
    CurrContextPtr->PCIDevId = 0x1040;

    //
    // try to configure for the PCI bus, fully-compliant HBA.
    // Specify the bus type.
    //
    hwInitializationData.AdapterInterfaceType = PCIBus;
    hwInitializationData.VendorId = VendorId;
    hwInitializationData.VendorIdLength = 4;
    hwInitializationData.DeviceId = NewDeviceId;
    hwInitializationData.DeviceIdLength = 4;
         PCIStatus = ScsiPortInitialize(DriverObject, Argument2, &hwInitializationData, CurrContextPtr);

    //
    // Now try to configure for the EISA bus.
    // Specify the bus type.
    //

    hwInitializationData.AdapterInterfaceType = Eisa;
    
    CurrContextPtr->AdapterCount = 0;
    CurrContextPtr->PCIDevId = 0;
    EisaStatus = ScsiPortInitialize(DriverObject, Argument2, &hwInitializationData, CurrContextPtr);


    //
    // Now try to configure for the Mca bus.
    // Specifiy the bus type.
    //

    hwInitializationData.AdapterInterfaceType = MicroChannel;
    
    CurrContextPtr->AdapterCount = 0;
    CurrContextPtr->PCIDevId = 0;
    mcaStatus = ScsiPortInitialize(DriverObject, Argument2, &hwInitializationData, CurrContextPtr);

    //
    // Now try to configure for the ISA bus.
    // Specifiy the bus type.
    //

    hwInitializationData.AdapterInterfaceType = Isa;
    
    CurrContextPtr->AdapterCount = 0;
    CurrContextPtr->PCIDevId = 0;
    isaStatus = ScsiPortInitialize(DriverObject, Argument2, &hwInitializationData, CurrContextPtr);

    //
    // Return the smallest status.
    //

    LowStatus1 = (PCIStatus < EisaStatus ? PCIStatus : EisaStatus);
    LowStatus2 = (mcaStatus < isaStatus ? mcaStatus : isaStatus);

    return(LowStatus1 < LowStatus2 ? LowStatus1 : LowStatus2);

} // end BLogicEntry()


ULONG
BLogicFindAdapter (
    IN  PCARD_STRUC CardPtr,
    IN PVOID Context,
    IN PVOID BusInformation,
    IN PCHAR ArgumentString,
    IN OUT PPORT_CONFIGURATION_INFORMATION ConfigInfo,
    OUT PBOOLEAN Again
    )
/*++

Routine Description:

    This function is called by the OS-specific port driver after
    the necessary storage has been allocated, to gather information
    about the adapter's configuration.

Arguments:

    CardPtr - HBA miniport driver's adapter data storage
    Context - Register base address
    ConfigInfo - Configuration information structure describing HBA
        This structure is defined in PORT.H.

Return Value:

    ULONG

--*/

{
    ULONG length;
    ULONG status;
    ULONG i;
    UCHAR adapterTid;
    UCHAR dmaChannel;
    UCHAR irq;
    UCHAR bit;
    UCHAR VesaCard = 0;
    UCHAR  ThrowAway;
    PBASE_REGISTER baseIoAddress;
    BOOLEAN NoErrorOnWide = TRUE;
    PBL_CONTEXT CurrContextPtr = (PBL_CONTEXT)Context;

    //
    // Determine if there are any adapters installed.  Determine installed
    // will initialize the BaseIoAddress if an adapter is found.
    //

    status = BLogicDetermineInstalled(CardPtr,
                                      ConfigInfo,
                                      (PBL_CONTEXT)CurrContextPtr,
                                      Again);

    //
    // If there are not adapter's found then return.
    //

    if ((status != SP_RETURN_FOUND) && (status != RETURN_FOUND_VESA)) {
        return(status);
    }

                                baseIoAddress = CardPtr->BaseIoAddress;

    if (status == RETURN_FOUND_VESA) {
        VesaCard = 1;
    }

    //
    // Issue adapter command to get IRQ.
    //
    // Returns 3 data bytes:
    //
    // Byte 0   Dma Channel
    //
    // Byte 1   Interrupt Channel
    //
    // Byte 2   Adapter SCSI ID
    //

    if (!WriteCommandRegister(CardPtr, AC_RET_CONFIGURATION_DATA)) {
        DebugPrint((1,"BLogicFindAdapter: Get configuration data command failed\n"));
        return SP_RETURN_ERROR;
    }

    //
    // Determine DMA channel.
    //

    if (!ReadCommandRegister(CardPtr,&dmaChannel)) {
        DebugPrint((1,"BLogicFindAdapter: Couldn't read dma channel\n"));
        return SP_RETURN_ERROR;
    }

    /* EISA may have DMA channel disabled  or MCA byte is not valid */
    /* also, vesa card always returns DMA channel 5 */

    if ((dmaChannel != 0) && (!VesaCard) 
                          && (ConfigInfo->AdapterInterfaceType != PCIBus)){
        WHICH_BIT(dmaChannel,bit);
        ConfigInfo->DmaChannel = bit;
    }

    DebugPrint((2,"BLogicFindAdapter: DMA channel is %x\n",
        ConfigInfo->DmaChannel));

    //
    // Determine hardware interrupt vector.
    //

    if (!ReadCommandRegister(CardPtr,&irq)) {
        DebugPrint((1,"BLogicFindAdapter: Couldn't read adapter irq\n"));
        return SP_RETURN_ERROR;
    }

    WHICH_BIT(irq, bit);

    // 
    // BusInterruptLevel is already provided for us in the ConfigInfo
    // structure on the fully-compliant 946C boards - otherwise, 
    // IRQ assignment from the 0Bh HBA command
    //

    if (!((ConfigInfo->AdapterInterfaceType == PCIBus) &&
              (CurrContextPtr->PCIDevId == 0x1040)))
    {
       ConfigInfo->BusInterruptLevel = (UCHAR) 9 + bit;
    }
    //
    // Determine what SCSI bus id the adapter is on.
    //

    if (!ReadCommandRegister(CardPtr,&adapterTid)) {
        DebugPrint((1,"BLogicFindAdapter: Couldn't read adapter SCSI id\n"));
        return SP_RETURN_ERROR;
    }

    if (!FinishHBACmd(CardPtr)) {
        DebugPrint((1,"BLogicFindAdapter: Setup info cmd failed\n"));
        return FALSE;
    }

    //
    // Set number of buses.
    //

    ConfigInfo->NumberOfBuses = 1;
    ConfigInfo->InitiatorBusId[0] = adapterTid;
    CardPtr->HostTargetId = adapterTid;

    // ConfigInfo->MaximumTransferLength = MAX_TRANSFER_SIZE;
    ConfigInfo->ScatterGather = TRUE;
    ConfigInfo->Master = TRUE;
    ConfigInfo->NumberOfPhysicalBreaks = MAX_SG_DESCRIPTORS - 1;
    CardPtr->MailBoxArray = ScsiPortGetUncachedExtension(
                                CardPtr,
                                ConfigInfo,
                                sizeof(NONCACHED_EXTENSION));

    if (CardPtr->MailBoxArray == NULL) {

        //
        // Log error.
        //

        ScsiPortLogError(
            CardPtr,
            NULL,
            0,
            0,
            0,
            SP_INTERNAL_ADAPTER_ERROR,
            6 << 16
            );

        return(SP_RETURN_ERROR);
    }

    //
    // Convert virtual to physical mailbox address.
    //

    CardPtr->MailBoxArray->MailboxPA =
           ScsiPortConvertPhysicalAddressToUlong(
            ScsiPortGetPhysicalAddress(CardPtr,
                                       NULL,
                                       CardPtr->MailBoxArray->Mbo,
                                       &length));

    //
    // Assume that physical address is below 16M
    //

    ASSERT(CardPtr->MailBoxArray->MailboxPA < 0x1000000);

     // check for wide support ONLY if on NT 3.5 platform */

    if (ConfigInfo->Length == CONFIG_INFO_VERSION_2)
    {
        CardPtr->Flags |= OS_SUPPORTS_WIDE;

        // default to non-wide support

        ConfigInfo->MaximumNumberOfTargets = 8;

        // turn on wide support if available 
        
        NoErrorOnWide = TRUE;    

        if (!WriteCommandRegister(CardPtr, AC_WIDE_SUPPORT)) {
                CardPtr->Flags &= ~WIDE_ENABLED;
                NoErrorOnWide = FALSE;
        }
        else if (!CheckInvalid(CardPtr)) {
                CardPtr->Flags &= ~WIDE_ENABLED;
               // DebugPrint((0,"BLogicFindAdapter: check invalid failed \n"));
               NoErrorOnWide = FALSE;
        }
        else if (!WriteCommandRegister(CardPtr, 0x01)) {
                CardPtr->Flags &= ~WIDE_ENABLED;
                NoErrorOnWide = FALSE;
        }

        if (!FinishHBACmd(CardPtr)) {
                CardPtr->Flags &= ~WIDE_ENABLED;
                NoErrorOnWide = FALSE;
        }
        else if (NoErrorOnWide) {
                CardPtr->Flags |= WIDE_ENABLED;
                ConfigInfo->MaximumNumberOfTargets = 16;

        }
    } /* end if NT 3.5, then check for wide support */

    DebugPrint((3,"BLogicFindAdapter: Configuration completed\n"));


    //
    // enable generation on interrupts to the host on HBAs that support
    // the 0x25 command used previously to disable generation of ints
    // during this routine's call to DetermineInstalled
    //


    if (!WriteCommandRegister(CardPtr,AC_INT_GENERATION_STATE)){
       DebugPrint((1,"BLogicFindAdapter: ints enable/disable cmd failed\n"));
       }
    else if (!CheckInvalid(CardPtr)) {
       DebugPrint((1,"BLogicDetInstalled: ints enable/disable cmd failed\n"));     DebugPrint((1,"BLogicDetermineInstalled: ISA Compatible Support Mode cmd failed\n"));
        
    }  
    else{
       ThrowAway = ENABLE_INTS;   
       if (!WriteCommandRegister(CardPtr,ThrowAway)){
          DebugPrint((1,"BLogicFindAdapter: ints enable/disable cmd failed\n"));   
       }  
    }

    if (!FinishHBACmd(CardPtr)) {

    // this cmd DOES NOT generate an interrupt - so
    // just check for command complete!

      if (!(ScsiPortReadPortUchar(&baseIoAddress->StatusRegister) 
                       & (IOP_SCSI_HBA_IDLE))) {
            DebugPrint((1,"BLogicFindAdapter: ints enable/disable cmd failed\n"));
      }
    } 

    //
    // Set up DMA type based on bus type
    //

    ConfigInfo->Dma32BitAddresses =
                        (ConfigInfo->AdapterInterfaceType == Isa) ? FALSE : TRUE;
    return SP_RETURN_FOUND;

} // end BLogicFindAdapter()


BOOLEAN
BLogicAdapterState(
    IN PCARD_STRUC CardPtr,
    IN PVOID Context,
    IN BOOLEAN SaveState
    )

/*++

Routine Description:

    The Buslogic adapters will take advantage of work done in the past to
    support Novell networks.  This means any MSDOS mode driver will be set
    up to run without using mailboxes.  This will save the work of having
    to save/restore mailbox locations for the MSDOS driver in this routine.

Arguments:

    CardPtr - HBA miniport driver's adapter data storage
    Context - Register base address
    SaveState - TRUE == Save real mode state ; FALSE == Restore real mode state

Return Value:

    TRUE - Save/Restore operation was successful.

--*/

{
    return TRUE;
} // end BLogicAdapterState()



BOOLEAN
BLIsCloneIDByte(
    IN PCARD_STRUC CardPtr
    )

/*++

Routine Description:

    This routine performs the adapter ID command and determines if the
    adapter is potentially a BusLogic adapter.

Arguments:

    CardPtr - HBA miniport data storage

Return Value:

    TRUE if it looks like the adapter is a clone or if the command fails.
    FALSE otherwise.

--*/

{
    UCHAR byte;
    UCHAR specialOptions;
    PBASE_REGISTER baseIoAddress = CardPtr->BaseIoAddress;

    ScsiPortWritePortUchar(&baseIoAddress->StatusRegister,
                           IOP_INTERRUPT_RESET);

    if (!WriteCommandRegister(CardPtr, AC_ADAPTER_INQUIRY)) {
        return TRUE;
    }

    //
    // Byte 0.
    //

    if ((ReadCommandRegister(CardPtr, &byte)) == FALSE) {
        return TRUE;
    }

    //
    // Get the special options byte.
    //

    if ((ReadCommandRegister(CardPtr, &specialOptions)) == FALSE) {
        return TRUE;
    }

    //
    // Get the last two bytes and clear the interrupt.
    //

    if ((ReadCommandRegister(CardPtr, &byte)) == FALSE) {
        return TRUE;
    }

    if ((ReadCommandRegister(CardPtr, &byte)) == FALSE) {
        return TRUE;
    }

    if (!FinishHBACmd(CardPtr)) {
        DebugPrint((1,"BLogicIsClone: Setup info cmd failed\n"));
        return FALSE;
    }

    if ((specialOptions == 0x30) || (specialOptions == 0x42)) {

        //
        // This is an adaptec or AMI adapter.
        //

        return TRUE;
    }

    return FALSE;
} // end BLIsCloneIDByte()


ULONG
BLogicDetermineInstalled(
    IN PCARD_STRUC CardPtr,
    IN OUT PPORT_CONFIGURATION_INFORMATION ConfigInfo,
    IN OUT PBL_CONTEXT CurrContextPtr,
    OUT PBOOLEAN Again
    )

/*++

Routine Description:

    Determine if BusLogic SCSI adapter is installed in system
    by reading the status register as each base I/O address
    and looking for a pattern.  If an adapter is found, the BaseIoAddres is
    initialized.

Arguments:

    CardPtr - HBA miniport driver's adapter data storage

    ConfigInfo - Supplies the known configuraiton information.

    CurrContextPtr - Supplies the count of adapter slots which have been 
                                                  tested and, in the case of PCI, the Device ID.

    Again - Returns whehter the  OS specific driver should call again.

Return Value:

    Returns a status indicating whether a driver is present or not.

--*/

{
    PBASE_REGISTER baseIoAddress;
    PUCHAR ioSpace;
    UCHAR  ThrowAway,TaggedQueueSupport,EISAConfigReg;
    UCHAR i;
    BOOLEAN configProvided = FALSE;
    UCHAR FoundVesaCard = 0;
    ULONG *AdapterAddrPtr;    
    ULONG length;
    SCSI_PHYSICAL_ADDRESS PhysAddr;
    

    if (ConfigInfo->AdapterInterfaceType == Eisa)
        InittedEISABoards = 1;

    //
    // Get the system physical address for this card.  The card uses I/O space.
    //

     AdapterAddrPtr = (ConfigInfo->AdapterInterfaceType == PCIBus) ? 
                                                  PciAdapterAddresses : AdapterAddresses;

    //
    // Scan though the adapter address looking for adapters.
    //

    ioSpace = NULL;
    while (AdapterAddrPtr[CurrContextPtr->AdapterCount] != 0) {

        //
        // Free any previously allocated ioSpace.
        //

        if (ioSpace) {
            ScsiPortFreeDeviceBase(
                CardPtr,
                ioSpace
                );
        }

        //
        // If the calling operating system has configuration information
        // already established for the driver then the RangeLength will be
        // set to zero instead of SP_UNINITIALIZED_VALUE.  This is used
        // to indicate the condition and this routine will search for an
        // adapter based on the information provided.
        //

        configProvided = ((*ConfigInfo->AccessRanges)[0].RangeLength == 0) ? FALSE : TRUE;
        if (configProvided) {
            ioSpace = ScsiPortGetDeviceBase(
                CardPtr,                              // CardPtr
                ConfigInfo->AdapterInterfaceType,   // AdapterInterfaceType
                ConfigInfo->SystemIoBusNumber,      // SystemIoBusNumber
                (*ConfigInfo->AccessRanges)[0].RangeStart,
                0x16,                              // NumberOfBytes
                TRUE                                // InIoSpace
                );

            if (!ioSpace) {
                return SP_RETURN_NOT_FOUND;
            }
        } else {
            ioSpace = ScsiPortGetDeviceBase(
                CardPtr,                              // CardPtr
                ConfigInfo->AdapterInterfaceType,   // AdapterInterfaceType
                ConfigInfo->SystemIoBusNumber,      // SystemIoBusNumber
                ScsiPortConvertUlongToPhysicalAddress(AdapterAddrPtr[CurrContextPtr->AdapterCount]),
                0x16,                              // NumberOfBytes
                TRUE                                // InIoSpace
                );
            if (!ioSpace) {
                continue;
            }
        }
        baseIoAddress = (PBASE_REGISTER)ioSpace;

        //
        // Check to see if adapter present in system.
        //

        CardPtr->BaseIoAddress = baseIoAddress;
        DebugPrint((1,"BLogic: Base IO address is %x\n", baseIoAddress));

        //
        // Update the adapter count.
        //

        (CurrContextPtr->AdapterCount)++;



        //
        // Check to make sure the I/O range is not already in use 
        //
        PhysAddr = ScsiPortConvertUlongToPhysicalAddress((ULONG)baseIoAddress);

        if (!(ScsiPortValidateRange(
                CardPtr,                              // CardPtr
                ConfigInfo->AdapterInterfaceType,   // AdapterInterfaceType
                ConfigInfo->SystemIoBusNumber,      // SystemIoBusNumber
                PhysAddr,
                4,                                  // NumberOfBytes
                TRUE                                // InIoSpace
                ))) {
        
                   continue;
         }
        

        if (((ScsiPortReadPortUchar((PUCHAR)baseIoAddress)) & (~0x2C)) == 0x10) {


            //
            // Before sending any other host adapter commands, try to disable 
            // generation of interrupts to the host (HBA command 0x25).
            // On f.w. that support this command, we will be able
            // to initialize an HBA that is sharing an IRQ level with a 
            // previously-initialized HBA on the same IRQ without winding up
            // in the ISR for the first HBA in an endless "not our interrupt"
            // loop due to level-triggered int generated by second HBA (not yet
            // registered by the OS for any ISR). This should allow us to share
            // interrupts on critical platforms such as PCI.
            //


            if (!WriteCommandRegister(CardPtr,AC_INT_GENERATION_STATE)){
               DebugPrint((1,"BLogicDetInstalled: ints enable/disable cmd failed\n"));
            }
            else if (!CheckInvalid(CardPtr)) {
               DebugPrint((1,"BLogicDetInstalled: ints enable/disable cmd failed\n"));     DebugPrint((1,"BLogicDetermineInstalled: ISA Compatible Support Mode cmd failed\n"));
            }  
            else{
               ThrowAway = DISABLE_INTS;   
               if (!WriteCommandRegister(CardPtr,ThrowAway)){
                  DebugPrint((1,"BLogicDetInstalled: ints enable/disable cmd failed\n"));   
               }  
            }

            if (!FinishHBACmd(CardPtr)) {

               // this cmd DOES NOT generate an interrupt - so
               // just check for command complete!

               if (!(ScsiPortReadPortUchar(&baseIoAddress->StatusRegister) 
                          & (IOP_SCSI_HBA_IDLE))) {
                  DebugPrint((1,"BLogicDetInstalled: ints enable/disable cmd failed\n"));
               }
            } 


            //
            // Check adapter inquiry to get rid of clones.
            //

            if (BLIsCloneIDByte(CardPtr)) {
                DebugPrint((1, "BLogicDetermineInstalled: Clone byte not BusLogic\n"));
                continue;
            }

            //
            // Send BusLogic Internal cmd (84h) to distinguish from clones
            //

            if (!WriteCommandRegister(CardPtr,AC_EXTENDED_FWREV)) {
                DebugPrint((1,"BLogicDetermineInstalled: Extended FW Rev command failed\n"));
                continue;
            }

            if (!ReadCommandRegister(CardPtr,&ThrowAway)) {
                DebugPrint((1,"BLogicDetermineInstalled: Extended FW Rev cmd failed\n"));
                continue;
            }

            if (!FinishHBACmd(CardPtr)) {
                DebugPrint((1,"BLogicDetermineInstalled: Extended FW Rev cmd failed\n"));
                continue;
            }

            //
            // Send Extended Setup Info cmd (8dh)
            //

            if (!WriteCommandRegister(CardPtr,
                AC_EXTENDED_SETUP_INFO)) {
                DebugPrint((1,"BLogicDetermineInstalled: Get Extended Setup Info cmd failed\n"));
                continue;
            }
            if (!WriteCommandRegister(CardPtr,
                11)) {                      /* ask for 11 bytes */
                DebugPrint((1,"BLogicDetermineInstalled: Get Extended Setup Info cmd failed\n"));
                continue;
            }

            if (!ReadCommandRegister(CardPtr,&CardPtr->BusType)) {
                 DebugPrint((1,"BLogicDetermineInstalled: Couldn't read parameter byte\n"));
                 continue;
            }

            //
            // Throw away next 8 bytes
            //

            for (i = 0; i < 8; i ++)
            {
                if (!ReadCommandRegister(CardPtr,&ThrowAway)) {
                    DebugPrint((1,"BLogicDetermineInstalled: Couldn't read parameter byte\n"));
                    break;
                }
            }
            if (i != 8)
                continue;

                                /* read EISA config reg - throw away byte for ISA and MCA */

            if (!ReadCommandRegister(CardPtr,&EISAConfigReg)) {
                DebugPrint((1,"BLogicDetermineInstalled: Couldn't read parameter byte\n"));
                continue;
            }

            if (!ReadCommandRegister(CardPtr,&TaggedQueueSupport)) {
                DebugPrint((1,"BLogicDetermineInstalled: Couldn't read parameter byte\n"));
                continue;
            }

            if (!FinishHBACmd(CardPtr)) {
                DebugPrint((1,"BLogicDetermineInstalled: Extended Setup info cmd failed\n"));
                continue;
            }

            if (TaggedQueueSupport != 0) {
                CardPtr->Flags |= TAGGED_QUEUING;
            }

            switch (CardPtr->BusType) {
            case ISA_HBA:
                if (ConfigInfo->AdapterInterfaceType != Isa)
                    continue;
                break;

            case EISA_HBA:

            // EISA, VESA, and PCI HBAs all , reporting back as bus type
            // EISA, will always reflect accurate edge\level info in
            // in "EISAConfigReg" below - I checked with FW group on this       

                ConfigInfo->InterruptMode = EISAConfigReg & LEVEL_TRIG ? LevelSensitive : Latched;

                if (ConfigInfo->AdapterInterfaceType == Eisa)
                {
                    if (!(FindOurEISAId(CardPtr,ConfigInfo,baseIoAddress)))
                    {
                        FoundVesaCard = 1;
                    }
                    break;
                }
                else if (ConfigInfo->AdapterInterfaceType == Isa)
                {
                /* if we already reported this HBA as an EISA board    */
                /* don't double report. Otherwise, this must be a VESA */
                /* board on an ISA-VESA motherboard.                   */

                    if (InittedEISABoards)
                        continue;
                    else
                    {
                        FoundVesaCard = 1;
                        break;
                    }
                }
                else if (ConfigInfo->AdapterInterfaceType == PCIBus)
                   break; 

            case MCA_HBA:
                if (ConfigInfo->AdapterInterfaceType != MicroChannel)
                    continue;
                break;

            } /* end switch */

       //
       // turn off ISA-compatible I/O mapping on compliant PCI HBAs.
       //

       if (ConfigInfo->AdapterInterfaceType == PCIBus)
                 {
              //
              // Turn off ISA-compatible I/O mapping for this HBA
              //

              if (!WriteCommandRegister(CardPtr,AC_ISA_COMPATIBLE_SUPPORT)) {
                DebugPrint((1,"BLogicDetermineInstalled: ISA Compatible Support Mode cmd failed\n"));
                continue;
              }
              else if (!CheckInvalid(CardPtr)) {
                DebugPrint((1,"BLogicDetermineInstalled: ISA Compatible Support Mode cmd failed\n"));
                continue;
              }  
              else{
                ThrowAway = DISABLE_ISA_MAPPING;   
           if (!WriteCommandRegister(CardPtr,ThrowAway)){
                  DebugPrint((1,"BLogicDetermineInstalled: ISA Compatible Support Mode cmd failed\n"));
                       continue;
           }
              }

              if (!FinishHBACmd(CardPtr)) {

               // this cmd DOES NOT generate an interrupt - so
               // just check for command complete!

                if (!(ScsiPortReadPortUchar(&baseIoAddress->StatusRegister) 
                          & (IOP_SCSI_HBA_IDLE))) {
                       DebugPrint((1,"BLogicDetermineInstalled: ISA Compatible Support Mode cmd failed\n"));
                       continue;
                }
              }
                 } // turn off ISA- compatible I/O mapping on PCI-compliant 946C cards

       //
       // An adapter has been found.  Set the base address in the device
       // extension, and request another call.
       //

       *Again = TRUE;

        //
        // Fill in the access array information.
        //

        if (!configProvided) {
            (*ConfigInfo->AccessRanges)[0].RangeStart =
                ScsiPortConvertUlongToPhysicalAddress(
                    AdapterAddresses[(CurrContextPtr->AdapterCount) - 1]);
        }
        (*ConfigInfo->AccessRanges)[0].RangeLength = 4;
        (*ConfigInfo->AccessRanges)[0].RangeInMemory = FALSE;


     return(FoundVesaCard ? RETURN_FOUND_VESA : SP_RETURN_FOUND);

     } /* end if ((baseIoAddress) & (~0x2C)) == 0x10)  */
   } /* end adapter count loop */

    //
    // The entire table has been searched and no adapters have been found.
    // There is no need to call again and the device base can now be freed.
    // Clear the adapter count for the next bus.
    //

    *Again = FALSE;
    CurrContextPtr->AdapterCount = 0;

     return(SP_RETURN_NOT_FOUND);

} // end BLogicDetermineInstalled()

ULONG
FindOurEISAId(
    IN PCARD_STRUC CardPtr,
    IN OUT PPORT_CONFIGURATION_INFORMATION ConfigInfo,
    PBASE_REGISTER baseIoAddress
    )

/*++

Routine Description:

    Determine if BusLogic HBA is an EISA or VESA board. Try to match both
    our EISA ID and the base port of the board in question. If both match
    this is an EISA board. If not, this must be our VESA board.

Arguments:

    CardPtr - HBA miniport driver's adapter data storage

    ConfigInfo - Supplies the known configuration information.

    baseIoAddress - Base IO port address for this HBA

Return Value:

    Returns one if successful - means the card in question is an EISA card.
    Returns zero if unsuccessful - means the card in question is a VESA card.

--*/

{
    PEISA_ID eisaID;
    ULONG eisaSlotNumber;
    PVOID eisaAddress;
    UCHAR Port;

    //
    // Clear any high order base address bits.
    //

    baseIoAddress = (PBASE_REGISTER)((ULONG) baseIoAddress & 0xFFF);

    //
    // Check to see if adapter EISA ID can be found
    //

    for (eisaSlotNumber= 1; eisaSlotNumber<MAXIMUM_EISA_SLOTS; eisaSlotNumber++)
    {

        //
        // Get the system address for this card.
        // The card uses I/O space.
        //

        eisaAddress = ScsiPortGetDeviceBase(CardPtr,
                                               ConfigInfo->AdapterInterfaceType,
                                               ConfigInfo->SystemIoBusNumber,
                                               ScsiPortConvertUlongToPhysicalAddress(0x1000 * eisaSlotNumber),
                                               0x1000,
                                               TRUE);

        eisaID =
            (PEISA_ID)((PUCHAR)eisaAddress + EISA_ADDRESS_BASE);

        if ((ScsiPortReadPortUchar(&eisaID->BoardId[0]) == 0x0A) &&
            (ScsiPortReadPortUchar(&eisaID->BoardId[1]) == 0xB3) &&
            ((ScsiPortReadPortUchar(&eisaID->BoardId[2]) == 0x42) ||
            (ScsiPortReadPortUchar(&eisaID->BoardId[2]) == 0x47)))
        {

            /* still need to look for IO port match because we could */
            /* have VESA and EISA BusLogic cards in same machine */

            Port = (ScsiPortReadPortUchar(&eisaID->IOPort[0]) & PORTMASK);

            switch (Port) {
            case 0:
                if ((ULONG)baseIoAddress == 0x330)
                {
                    DebugPrint((1,"BusLogic: EISA Adapter found at slot %d,port %x \n",
                                eisaSlotNumber,baseIoAddress));
                    return(1);
                }
                break;
            case 1:
                if ((ULONG)baseIoAddress == 0x334)
                {
                    DebugPrint((1,"BusLogic: EISA Adapter found at slot %d,port %x \n",
                                eisaSlotNumber,baseIoAddress));
                    return(1);
                }
                break;
            case 2:
                if ((ULONG)baseIoAddress == 0x230)
                {
                    DebugPrint((1,"BusLogic: EISA Adapter found at slot %d,port %x \n",
                                eisaSlotNumber,baseIoAddress));
                    return(1);
                }
                break;
            case 3:
                if ((ULONG)baseIoAddress == 0x234)
                {
                    DebugPrint((1,"BusLogic: EISA Adapter found at slot %d,port %x \n",
                                eisaSlotNumber,baseIoAddress));
                    return(1);
                }
                break;
            case 4:
                if ((ULONG)baseIoAddress == 0x130)
                {
                    DebugPrint((1,"BusLogic: EISA Adapter found at slot %d,port %x \n",
                                eisaSlotNumber,baseIoAddress));
                    return(1);
                }
                break;
            case 5:
                if ((ULONG)baseIoAddress == 0x134)
                {
                    DebugPrint((1,"BusLogic: EISA Adapter found at slot %d,port %x \n",
                                eisaSlotNumber,baseIoAddress));
                    return(1);
                }
                break;
            default:
                break;
            } /* end switch */

        } /* end if found BusLogic ID */
    } /* end for loop */

    DebugPrint((1,"BusLogic: VESA Adapter found at port %x\n",baseIoAddress));
    return(0);
}

BOOLEAN
BLogicHwInitialize(
    IN PCARD_STRUC CardPtr
    )

/*++

Routine Description:

    This routine is a required entry point.

Arguments:

    CardPtr - HBA miniport driver's adapter data storage

Return Value:

    TRUE - if initialization successful.
    FALSE - if initialization unsuccessful.

--*/

{
    PNONCACHED_EXTENSION MailBoxArray =
        CardPtr->MailBoxArray;
    PBASE_REGISTER baseIoAddress = CardPtr->BaseIoAddress;
    UCHAR status;
    ULONG i;
    PDEV_STRUC DevStruc;
    UCHAR TargID;
    UCHAR Lun;

    DebugPrint((2,"BLogicHwInitialize: Reset BusLogic HBA and SCSI bus\n"));

    //
    // Reset HBA.
    //

    ScsiPortWritePortUchar(&baseIoAddress->StatusRegister, IOP_SOFT_RESET);

    ScsiPortStallExecution(500*1000);

    //
    // Wait up to 500 microseconds for adapter to initialize.
    //

    for (i = 0; i < 500; i++) {

        ScsiPortStallExecution(1);

        status = ScsiPortReadPortUchar(&CardPtr->BaseIoAddress->StatusRegister);

        if (status & IOP_SCSI_HBA_IDLE) {
            break;
        }
    }

    //
    // Check if reset failed or succeeded.
    //

    if (!(status & IOP_SCSI_HBA_IDLE) || !(status & IOP_MAILBOX_INIT_REQUIRED))
    {

        DebugPrint((0, "BLogicHwInitialize:  Soft reset failed.\n"));

        //
        // If the soft reset does not work, try a hard reset.
        //

        if (!BLogicResetBus(CardPtr, 0)) {
            DebugPrint((1,"BLogicHwInitialize: Reset SCSI bus failed\n"));
            return FALSE;
        }

        //
        // Inform the port driver that the bus has been reset.
        //


        ScsiPortNotification(ResetDetected, CardPtr, 0);

        DebugPrint((1,"BLogicHwInitialize: Reset completed\n"));

    }
    else   /* soft reset succeeded */
    {

    //
    // Complete all outstanding requests with SRB_STATUS_BUS_RESET.
    //

    ScsiPortCompleteRequest(CardPtr,
                            CardPtr->BusNum,
                            (UCHAR) -1,
                            (UCHAR) -1,
                            SRB_STATUS_BUS_RESET);
    //
    // Reinitialize Active CCBS pointer and counter in LUN extensions
    //

    for (TargID= 0; TargID < 8; TargID++)
        for (Lun = 0; Lun < 8; Lun++)
        {
          if (DevStruc= (PDEV_STRUC) (ScsiPortGetLogicalUnit(CardPtr,0,TargID,Lun)))
          {
             DevStruc->CurrentCCB = 0;
             DevStruc->NumActive = 0;
          }
        }

    }

    //
    // Zero out mailboxes.
    //

    for (i=0; i<MB_COUNT; i++) {

        PMBO mailboxOut;
        PMBI mailboxIn;

        mailboxIn = &MailBoxArray->Mbi[i];
        mailboxOut = &MailBoxArray->Mbo[i];

        mailboxOut->Command = mailboxIn->Status = 0;
    }

    CardPtr->StartMBO = (PMBO)(&MailBoxArray->Mbo);
    CardPtr->CurrMBO = (PMBO)(&MailBoxArray->Mbo);
    CardPtr->LastMBO = ((PMBO)(&MailBoxArray->Mbo) + (MB_COUNT - 1));
    CardPtr->StartMBI =(PMBI)( &MailBoxArray->Mbi);
    CardPtr->CurrMBI = (PMBI)(&MailBoxArray->Mbi);
    CardPtr->LastMBI = ((PMBI)(&MailBoxArray->Mbi) + (MB_COUNT - 1));


    DebugPrint((3,"BLogicHwInitialize: Initialize mailbox\n"));

    if (!WriteCommandRegister(CardPtr,AC_MBOX_EXTENDED_INIT)) {
        DebugPrint((1,"BLogicHWInitialize: Couldn't initialize mailboxes\n"));
        return FALSE;
    }

    //
    // Send Adapter number of mailbox locations.
    //

    if (!WriteCommandRegister(CardPtr,MB_COUNT)) {
        DebugPrint((1,"BLogicHWInitialize: Extended InitMboxes failed\n"));
        return FALSE;
    }
    if (!WriteCommandRegister(CardPtr,
        ((PFOUR_BYTE)&MailBoxArray->MailboxPA)->Byte0)) {
        DebugPrint((1,"BLogicHWInitialize: Extended InitMboxes failed\n"));
        return FALSE;
    }
    if (!WriteCommandRegister(CardPtr,
        ((PFOUR_BYTE)&MailBoxArray->MailboxPA)->Byte1)) {
        DebugPrint((1,"BLogicHWInitialize: Extended InitMboxes failed\n"));
        return FALSE;
    }
    if (!WriteCommandRegister(CardPtr,
        ((PFOUR_BYTE)&MailBoxArray->MailboxPA)->Byte2)) {
        DebugPrint((1,"BLogicHWInitialize: Extended InitMboxes failed\n"));
        return FALSE;
    }
    if (!WriteCommandRegister(CardPtr,
        ((PFOUR_BYTE)&MailBoxArray->MailboxPA)->Byte3)) {
        DebugPrint((1,"BLogicHWInitialize: Extended InitMboxes failed\n"));
        return FALSE;
    }
    if (!FinishHBACmd(CardPtr)) {
        DebugPrint((1,"BLogicHWInitialize: Extended InitMboxes failed\n"));
        return FALSE;
    }


    //
    // Override default setting for bus on time. This makes floppy
    // drives work better with this adapter.
    //

    if (!WriteCommandRegister(CardPtr, AC_SET_BUS_ON_TIME)) {

        DebugPrint((1,"BlogicHWInitialize:Can't set bus on time\n"));
        return FALSE;

    } else if (!WriteCommandRegister(CardPtr, 0x05)) {

        DebugPrint((1,"BlogicHWInitialize:Can't set bus on time\n"));
        return FALSE;
    }

    if (!FinishHBACmd(CardPtr)) {
        DebugPrint((1,"BLogicHWInitialize: Set BUS On time failed\n"));
        return FALSE;
    }

    /* turn on wide support if available */
    if (CardPtr->Flags & OS_SUPPORTS_WIDE)
    {
        // DebugPrint((0,"BLogicHwInitialize: about to send wide cmd\n"));
        
        if (!WriteCommandRegister(CardPtr, AC_WIDE_SUPPORT)) {
                CardPtr->Flags &= ~WIDE_ENABLED;
        }
        else if (!CheckInvalid(CardPtr)) {
                CardPtr->Flags &= ~WIDE_ENABLED;
        }
        else if (!WriteCommandRegister(CardPtr, 0x01)) {
                CardPtr->Flags &= ~WIDE_ENABLED;
        }
        if (!FinishHBACmd(CardPtr)) {
                CardPtr->Flags &= ~WIDE_ENABLED;
        }
        else {
                CardPtr->Flags |= WIDE_ENABLED;
        }
    } /* end if OS_SUPPORTS_WIDE */

    return TRUE;

} // end BLogicHwInitialize()


BOOLEAN
BLogicStartIo(
    IN PCARD_STRUC CardPtr,
    IN PSCSI_REQUEST_BLOCK Srb
    )

/*++

Routine Description:

    This routine is called from the SCSI port driver synchronized
    with the kernel. The mailboxes are scanned for an empty one and
    the CCB is written to it. Then the doorbell is rung and the
    OS port driver is notified that the adapter can take
    another request, if any are available.

Arguments:

    CardPtr - HBA miniport driver's adapter data storage
    Srb - IO request packet

Return Value:

    TRUE

--*/

{
    PNONCACHED_EXTENSION MailBoxArray =
        CardPtr->MailBoxArray;
    PCCB ccb;
    PDEV_STRUC DevStruc;
    PCCB ActiveCCB;
    ULONG i = 0;
         UCHAR MaxActive = 0;
    UCHAR j;

    DebugPrint((3,"BLogicStartIo: Enter routine\n"));

    if (CardPtr->Flags & REINIT_REQUIRED)
    {
       if (!ReInitializeHBA(CardPtr,Srb->PathId)) 
                 {
           DebugPrint((1,"BLogicStartIo: HBA reinitialization failed\n"));
           return FALSE;
       }
       CardPtr->Flags &= (~REINIT_REQUIRED);
         }

    //
    // Check if command is an ABORT request.
    //

    if (Srb->Function == SRB_FUNCTION_ABORT_COMMAND) {

        //
        // Get CCB to abort.
        //

        ccb = Srb->NextSrb->SrbExtension;
        MaxActive =(Srb->NextSrb->SrbFlags & SRB_FLAGS_QUEUE_ACTION_ENABLE) ?
                     MAXACTIVE_TAGGED : MAXACTIVE;

        //
        // Verify that CCB to abort is still outstanding.
        //

        DevStruc =
                ScsiPortGetLogicalUnit(CardPtr,
                                       Srb->PathId,
                                       Srb->TargetId,
                                       Srb->Lun);

        for (j=DevStruc->NumActive, ActiveCCB = DevStruc->CurrentCCB;
             j > 0; j--)
        {
            if (ActiveCCB != ccb)
                ActiveCCB = ActiveCCB->NxtActiveCCB;
            else
                break;

        }

        if (j == 0)
        {

            DebugPrint((1, "BLogicStartIo: SRB to abort already completed\n"));

            //
            // Complete abort SRB.
            //

            Srb->SrbStatus = SRB_STATUS_ABORT_FAILED;

            ScsiPortNotification(RequestComplete,
                                 CardPtr,
                                 Srb);
            //
            // Adapter ready for next request.
            //
             if (DevStruc->NumActive < MaxActive)
                    ScsiPortNotification(NextLuRequest,CardPtr,Srb->PathId,
                                    Srb->TargetId,Srb->Lun);
             else
                  ScsiPortNotification(NextRequest,CardPtr,NULL);
             return TRUE;
        }


        //
        // Set abort SRB for completion.
        //

        ccb->AbortSrb = Srb;
        SendCCB(Srb,CardPtr,DevStruc);

        if (DevStruc->NumActive < MaxActive)
                 ScsiPortNotification(NextLuRequest,CardPtr,Srb->PathId,
                                      Srb->TargetId,Srb->Lun);
        else
                 ScsiPortNotification(NextRequest,CardPtr,NULL);

        return TRUE;

    } /* end ABORT request handling */


    ccb = Srb->SrbExtension;

    ccb->SrbAddress = Srb;                  /* Save SRB back ptr in CCB */
    MaxActive = (Srb->SrbFlags & SRB_FLAGS_QUEUE_ACTION_ENABLE) ?
                     MAXACTIVE_TAGGED : MAXACTIVE;

    DevStruc = ScsiPortGetLogicalUnit(CardPtr,Srb->PathId,Srb->TargetId,
                                       Srb->Lun);

    switch (Srb->Function) {

        case SRB_FUNCTION_EXECUTE_SCSI:

            //
            // Get logical unit extension.
            //


            DevStruc->NumActive++;

            //
            // Build CCB.
            //

            BuildCcb(CardPtr, Srb);
            SendCCB(Srb,CardPtr,DevStruc);
            break;

        case SRB_FUNCTION_RESET_BUS:

            //
            // Reset Adapter and SCSI bus.
            //

            DebugPrint((1, "BLogicStartIo: Reset bus request received\n"));

            if (!BLogicResetBus(CardPtr,Srb->PathId)) {
                DebugPrint((1,"BLogicStartIo: Reset bus failed\n"));
                Srb->SrbStatus = SRB_STATUS_ERROR;
            } else {

                Srb->SrbStatus = SRB_STATUS_SUCCESS;
            }

            ScsiPortNotification(RequestComplete,
                         CardPtr,
                         Srb);
            break;


        case SRB_FUNCTION_RESET_DEVICE:

            DevStruc->NumActive++;

            ccb->OperationCode = RESET_COMMAND;
            ccb->TargID = Srb->TargetId;
            ccb->Lun = Srb->Lun;

            SendCCB(Srb,CardPtr,DevStruc);

            ScsiPortNotification(RequestComplete,
                                 CardPtr,
                                 Srb);

            break;

            //
            // Drop through to default.
            //

        default:

            //
            // Set error, complete request
            //

            Srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;

            ScsiPortNotification(RequestComplete,CardPtr,Srb);

    } // end switch

    //
    // Adapter ready for next request.
    //

    if (DevStruc->NumActive < MaxActive)
            ScsiPortNotification(NextLuRequest,CardPtr,Srb->PathId,
                                 Srb->TargetId,Srb->Lun);
    else
            ScsiPortNotification(NextRequest,CardPtr,NULL);

    return TRUE;


} // end BLogicStartIo()


BOOLEAN
BLogicInterrupt(
    IN PCARD_STRUC CardPtr
    )

/*++

Routine Description:

    This is the interrupt service routine for the  SCSI adapter.
    It reads the interrupt register to determine if the adapter is indeed
    the source of the interrupt and clears the interrupt at the device.
    If the adapter is interrupting because a mailbox is full, the CCB is
    retrieved to complete the request.

Arguments:

    CardPtr - HBA miniport driver's adapter data storage

Return Value:

    TRUE if MailboxIn full

--*/

{
    PNONCACHED_EXTENSION MailBoxArray =
        CardPtr->MailBoxArray;
    PCCB ccb;
    PSCSI_REQUEST_BLOCK srb,abortsrb;
    PBASE_REGISTER baseIoAddress = CardPtr->BaseIoAddress;
    PMBI mailboxIn;
    ULONG physicalCcb;
    PDEV_STRUC DevStruc;
    UCHAR mbox_compcode;
    UCHAR InterruptFlags;
         UCHAR MaxActive=0;
    UCHAR TargID;
    UCHAR Lun;

    InterruptFlags = ScsiPortReadPortUchar(&baseIoAddress->InterruptRegister);

    DebugPrint((3,"BLogicInterrupt: Interrupt flags %x\n", InterruptFlags));

    if (!(InterruptFlags & IOP_ANY_INTERRUPT)) {
        DebugPrint((4,"BLogicInterrupt: Not our interrupt!\n"));
        return FALSE;
    }
    else
            /*  Clear interrupt on adapter. */
        ScsiPortWritePortUchar(&baseIoAddress->StatusRegister, IOP_INTERRUPT_RESET);

    //
    // Determine cause of interrupt.
    //

    if (InterruptFlags & IOP_COMMAND_COMPLETE) {

        //
        // Adapter command completed.
        //

        DebugPrint((2,"BLogicInterrupt: Adapter Command complete\n"));
        DebugPrint((3,"BLogicInterrupt: Status %x\n",
            ScsiPortReadPortUchar(&baseIoAddress->StatusRegister)));

        return TRUE;

    }
    else if (InterruptFlags & IOP_SCSI_RESET_DETECTED) {

        DebugPrint((1,"BLogicInterrupt: SCSI Reset detected\n"));
        //
        // Notify of reset.
        //

       //
       // Reset HBA because firmware may be in confused state with
                 // respect to outstanding CCBs.
       //

       ScsiPortWritePortUchar(&baseIoAddress->StatusRegister, IOP_SOFT_RESET);

       //
       // Notify OS of SCSI bus reset.
       //

       ScsiPortNotification(ResetDetected,CardPtr,NULL);

       // Complete all active requests for specified unit

       ScsiPortCompleteRequest(CardPtr,
                            (UCHAR) 0,
                            (UCHAR) -1,
                            (UCHAR) -1,
                            SRB_STATUS_BUS_RESET);

       //
       // Reinitialize Active CCBS pointer and counter in LUN extensions
       //

       for (TargID= 0; TargID < 8; TargID++)
         for (Lun = 0; Lun < 8; Lun++)
         {
           if (DevStruc=ScsiPortGetLogicalUnit(CardPtr,0,TargID,Lun))
           {
             DevStruc->CurrentCCB = 0;
             DevStruc->NumActive = 0;
           }
         }

       //
            // Set flag indicating HBA reinitialization will be required before
       // any new requests can be serviced (due to soft reset above).
            //
            
       CardPtr->Flags |= REINIT_REQUIRED;
    }

    else if (InterruptFlags & IOP_MBI_FULL) {
        DebugPrint((3,"BLogicInterrupt: MBI Full\n"));

        while  (mailboxIn = DoneMbox(CardPtr))
        {

            physicalCcb = mailboxIn->Address;
            DebugPrint((3, "BLogicInterrupt: Physical CCB %lx\n", physicalCcb));

            /*  Check if physical CCB is zero. ( to cover for hardware errs) */

            if (!physicalCcb) {

                DebugPrint((1,"BLogicInterrupt: Physical CCB address is 0\n"));
                return TRUE;
            }

            //
            // Convert Physical CCB to Virtual.
            //

            ccb = ScsiPortGetVirtualAddress(CardPtr, ScsiPortConvertUlongToPhysicalAddress(physicalCcb));
            DebugPrint((3, "BLogicInterrupt: Virtual CCB %lx\n", ccb));

            //
            // Make sure the virtual address was found.
            //

            if (ccb == NULL) {

                //
                // A bad physcial address was return by the adapter.
                // Log it as an error.
                //

                ScsiPortLogError(
                    CardPtr,
                    NULL,
                    0,
                    CardPtr->HostTargetId,
                    0,
                    SP_INTERNAL_ADAPTER_ERROR,
                    5 << 8
                    );

               return(TRUE);

            }

            mbox_compcode = mailboxIn->Status;
            mailboxIn->Status = MBI_FREE;       /* free this In Mailbox */

            //
            // Get SRB from CCB.
            //

            srb = ccb->SrbAddress;

            //
            // Get logical unit extension.
            //

            DevStruc =
                ScsiPortGetLogicalUnit(CardPtr,
                               srb->PathId,
                               srb->TargetId,
                               srb->Lun);

            if (mbox_compcode == MBI_NOT_FOUND) {
                DebugPrint((1, "BLogicInterrupt: aborted CCB not found %lx\n", ccb));
                continue;
            }

            if (!AdjustCCBqueue (ccb,DevStruc)) {

                //
                // We have no record of the  CCB returned by the adapter.
                // Log it as an error.
                //

                ScsiPortLogError(
                CardPtr,
                NULL,
                0,
                CardPtr->HostTargetId,
                0,
                SP_INTERNAL_ADAPTER_ERROR,
                (7 << 8) | mbox_compcode
                );

               continue;

            }

            srb->ScsiStatus = ccb->TargetStatus;

            DebugPrint((2, "BLogicInterrupt: SCSI Status %x\n", srb->ScsiStatus));
            DebugPrint((2, "BLogicInterrupt: Adapter Status %x\n", ccb->HostStatus));

            //
            // Check MBI status.
            //

            switch (mbox_compcode) {

                case MBI_SUCCESS:

                    srb->SrbStatus = SRB_STATUS_SUCCESS;
                    ASSERT(DevStruc->CurrentCCB);
                    break;

                case MBI_ABORT:

                    DebugPrint((1, "BLogicInterrupt: CCB aborted\n"));

                    srb->SrbStatus = SRB_STATUS_ABORTED;

                    //
                    // Get the abort SRB (requested the abort) from CCB.
                    //

                    abortsrb = ccb->AbortSrb;

                    //
                    // Call notification routine for the aborted SRB.
                    //

                    ScsiPortNotification(RequestComplete,
                                         CardPtr,
                                         srb);

                    //
                    // Set status for completing abort request itself.
                    //

                    abortsrb->SrbStatus = SRB_STATUS_SUCCESS;
                    srb = abortsrb;
                    break;

                case MBI_ERROR:

                    DebugPrint((2, "BLogicInterrupt: Error occurred\n"));

                    srb->SrbStatus = MapError(CardPtr, srb, ccb);
                    if (ccb->TargetStatus == 2)
                        if (ccb->RequestSenseLength != 1)
                            srb->SrbStatus |= SRB_STATUS_AUTOSENSE_VALID;

                    break;

                default:

                    //
                    // Log the error.
                    //

                    ScsiPortLogError(
                            CardPtr,
                            NULL,
                            0,
                            CardPtr->HostTargetId,
                            0,
                            SP_INTERNAL_ADAPTER_ERROR,
                            (1 << 8) | mbox_compcode
                    );

                    DebugPrint((1, "BLogicInterrupt: Unrecognized mailbox status\n"));

                    continue;

            } // end switch on mailbox-in completion status

            DevStruc->NumActive--;
            MaxActive = (srb->SrbFlags & SRB_FLAGS_QUEUE_ACTION_ENABLE) ?
                     MAXACTIVE_TAGGED : MAXACTIVE;

            ScsiPortNotification(RequestComplete,CardPtr,srb);

            //
            // Notify that we are ready for another request
            //

                if (DevStruc->NumActive == (MaxActive - 1))
                   ScsiPortNotification(NextLuRequest,CardPtr,srb->PathId,
                                                   srb->TargetId,srb->Lun);
                else  /* assume we already asked for req for this LUN */
                   ScsiPortNotification(NextRequest,CardPtr,NULL);

        } /* while done MBI */

    } /* end if MBI full */
    else
    {                           /* unexpected interrupt status */
        ScsiPortLogError(
                        CardPtr,
                        NULL,
                        0,
                        CardPtr->HostTargetId,
                        0,
                        SP_INTERNAL_ADAPTER_ERROR,
                        (8 << 8)
        );

        DebugPrint((1, "BLogicInterrupt: Spurious Interrupt\n"));

    }

    return TRUE;
} // end BLogicInterrupt()


VOID
BuildCcb(
    IN PCARD_STRUC CardPtr,
    IN PSCSI_REQUEST_BLOCK Srb
    )

/*++

Routine Description:

    Build CCB

Arguments:

    DeviceExtenson
    SRB

Return Value:

    Nothing.

--*/

{
    PCCB ccb = Srb->SrbExtension;
    UCHAR *pchar;
    USHORT i;
    ULONG physReqSensePtr;
    ULONG length;

    DebugPrint((3,"BuildCcb: Enter routine\n"));

    // zero-fill the CCB

    pchar = (UCHAR *) ccb;
    for (i=0; i < sizeof(CCB); i++)
        *pchar++= 0;

    ccb->SrbAddress = Srb;                  /* Save SRB back ptr in CCB */

    //
    // Set CCB Operation Code.
    //

    if (Srb->DataTransferLength > 0)
        ccb->OperationCode = SCATTER_GATHER_COMMAND;
    else
        ccb->OperationCode = SCSI_INITIATOR_COMMAND;
    //
    // Set target id and LUN.
    //

    ccb->TargID = Srb->TargetId;
    ccb->Lun = Srb->Lun;


    if ((CardPtr->Flags & TAGGED_QUEUING) &&
       (Srb->SrbFlags & SRB_FLAGS_QUEUE_ACTION_ENABLE))
    {
                if (CardPtr->Flags & WIDE_ENABLED) 
                        ccb->ControlByte |= ENABLE_TQ;
                else
                        ccb->Lun |= ENABLE_TQ;

        switch (Srb->QueueAction) {

        case ORDERED_TAG:
            ccb->Lun |= ORDERED;
            break;
        case SIMPLE_TAG:
            ccb->Lun |= SIMPLE;
            break;
        case HEAD_OF_QUEUE:
            ccb->Lun |= QUEUEHEAD;
            break;
        } /* end switch */
    }

    //
    // Set transfer direction bit.
    //

    switch (Srb->SrbFlags & SRB_FLAGS_UNSPECIFIED_DIRECTION) {
    case SRB_FLAGS_DATA_OUT:
       ccb->ControlByte |= CCB_DATA_XFER_OUT;
       break;

    case SRB_FLAGS_DATA_IN:
       ccb->ControlByte |= CCB_DATA_XFER_IN;
       break;

    case SRB_FLAGS_NO_DATA_TRANSFER:
       ccb->ControlByte |= CCB_DATA_XFER_IN | CCB_DATA_XFER_OUT;
       break;
    }

    if (!(Srb->SrbFlags & SRB_FLAGS_DISABLE_AUTOSENSE) &&
        Srb->SenseInfoBufferLength != 0) {

        ccb->RequestSenseLength = Srb->SenseInfoBufferLength;
        physReqSensePtr = ScsiPortConvertPhysicalAddressToUlong(
                ScsiPortGetPhysicalAddress(CardPtr, Srb,
                          Srb->SenseInfoBuffer, &length));

        ccb->SensePointer = physReqSensePtr;
    }
    else


        //
        // 01h disables auto request sense.
        //

        ccb->RequestSenseLength = 1;


    //
    // Set CDB length and copy to CCB.
    //

    ccb->CdbLength = (UCHAR)Srb->CdbLength;

    ScsiPortMoveMemory(ccb->Cdb, Srb->Cdb, ccb->CdbLength);


    //
    // Build SDL in CCB if data transfer.
    //

    if (Srb->DataTransferLength > 0) {
        BuildSdl(CardPtr, Srb);
    }

    //
    // Move -1 to Target Status to indicate
    // CCB has not completed.
    //

    ccb->TargetStatus = 0xff;

    return;

} // end BuildCcb()


VOID
BuildSdl(
    IN PCARD_STRUC CardPtr,
    IN PSCSI_REQUEST_BLOCK Srb
    )

/*++

Routine Description:

    This routine builds a scatter/gather descriptor list for the CCB.

Arguments:

    CardPtr
    Srb

Return Value:

    None

--*/

{
    PVOID dataPointer = Srb->DataBuffer;
    ULONG bytesLeft = Srb->DataTransferLength;
    PCCB ccb = Srb->SrbExtension;
    PSDL sdl = &ccb->Sdl;
    PSGD sgd;
    ULONG physicalSdl;
    ULONG physicalAddress;
    ULONG length;
    ULONG i = 0;

    DebugPrint((3,"BuildSdl: Enter routine\n"));


    //
    // Get physical SDL address.
    //

    physicalSdl = ScsiPortConvertPhysicalAddressToUlong(
        ScsiPortGetPhysicalAddress(CardPtr, NULL,
        sdl, &length));

    //
    // Assume physical memory contiguous for sizeof(SDL) bytes.
    //

    ASSERT(length >= sizeof(SDL));

    sgd = sdl->Sgd;

    //
    // Create SDL segment descriptors.
    //

    do {

        DebugPrint((3, "BuildSdl: Data buffer %lx\n", dataPointer));

        //
        // Get physical address and length of contiguous
        // physical buffer.
        //

        physicalAddress =
            ScsiPortConvertPhysicalAddressToUlong(
                ScsiPortGetPhysicalAddress(CardPtr,
                                       Srb,
                                       dataPointer,
                                       &length));

        DebugPrint((3, "BuildSdl: Physical address %lx\n", physicalAddress));
        DebugPrint((3, "BuildSdl: Data length %lx\n", length));
        DebugPrint((3, "BuildSdl: Bytes left %lx\n", bytesLeft));

        //
        // If length of physical memory is more
        // than bytes left in transfer, use bytes
        // left as final length.
        //

        if  (length > bytesLeft) {
            length = bytesLeft;
        }

        sgd->Length = length;
        sgd->Address = physicalAddress;
        sgd++;
        i++;

        //
        // Adjust counts.
        //

        dataPointer = (PUCHAR)dataPointer + length;
        bytesLeft -= length;

    } while (bytesLeft);

    //
    // Write Scatter/Gather Descriptor List length to CCB.
    //

    ccb->DataLength = i * sizeof(SGD);

    DebugPrint((3,"BuildSdl: S/G list length is %d\n", ccb->DataLength));

    if (ccb->DataLength > 8)
        DebugPrint((3,"BuildSdl: Multiple elements in S/G list"));

    //
    // Write SDL address to CCB.
    //

    ccb->DataPointer = (PVOID) physicalSdl;

    DebugPrint((3,"BuildSdl: SDL address is %lx\n", sdl));

    DebugPrint((3,"BuildSdl: CCB address is %lx\n", ccb));

    return;

} // end BuildSdl()


BOOLEAN
BLogicResetBus(
    IN PCARD_STRUC CardPtr,
    IN ULONG PathId
    )

/*++

Routine Description:

    Reset BusLogic SCSI adapter and SCSI bus.
    Initialize adapter mailbox.

Arguments:

    CardPtr - HBA miniport driver's adapter data storage

Return Value:

    Nothing.


--*/

{
    UCHAR TargID,Lun;
    PDEV_STRUC DevStruc;

    DebugPrint((2,"BLogicResetBus: Reset BusLogic HBA and SCSI bus\n"));

    if (!ResetBus(CardPtr,PathId)) {
        DebugPrint((1,"BLogicResetBus: Reset bus failed\n"));
        return FALSE;
    }
    //
    // Complete all outstanding requests with SRB_STATUS_BUS_RESET.
    //

    ScsiPortCompleteRequest(CardPtr,
                            (UCHAR) PathId,
                            (UCHAR) -1,
                            (UCHAR) -1,
                            SRB_STATUS_BUS_RESET);
    //
    // Reinitialize Active CCBS pointer and counter in LUN extensions
    //

    for (TargID= 0; TargID < 8; TargID++)
        for (Lun = 0; Lun < 8; Lun++)
        {
          if (DevStruc=ScsiPortGetLogicalUnit(CardPtr,0,TargID,Lun))
          {
             DevStruc->CurrentCCB = 0;
             DevStruc->NumActive = 0;
          }
        }

  return TRUE;

} // end BLogicResetBus()


BOOLEAN
ResetBus(
    IN PCARD_STRUC CardPtr,
    IN ULONG PathId
    )

/*++

Routine Description:

    Reset BusLogic SCSI adapter and SCSI bus.
    Initialize adapter mailbox.
    Don't do callback on outstanding SRBs
Arguments:

    CardPtr - HBA miniport driver's adapter data storage

Return Value:

    Nothing.


--*/

{
    PNONCACHED_EXTENSION MailBoxArray =
        CardPtr->MailBoxArray;
    PBASE_REGISTER baseIoAddress = CardPtr->BaseIoAddress;
    ULONG i;
    PMBO mailboxOut;
    PMBI mailboxIn;
    UCHAR status;

    DebugPrint((2,"ResetBus: Reset BusLogic HBA and SCSI bus\n"));

    //
    // Reset SCSI chip.
    //

    ScsiPortWritePortUchar(&baseIoAddress->StatusRegister, IOP_HARD_RESET);

         // Separated out the previously-removed routine ReInitializeHBA
         // because it is now called by StartIO as well

    if (!ReInitializeHBA(CardPtr,PathId)) {
        DebugPrint((1,"ResetBus: Reset bus failed\n"));
        return FALSE;
    }
    return TRUE;

} // end ResetBus()


BOOLEAN
ReInitializeHBA(
    IN PCARD_STRUC CardPtr,
    IN ULONG PathId
    )

/*++

Routine Description:

    Wait for HBA to reinitialize.
    Initialize adapter mailbox.

Arguments:

    CardPtr - HBA miniport driver's adapter data storage

Return Value:

    Nothing.


--*/

{
    PNONCACHED_EXTENSION MailBoxArray =
        CardPtr->MailBoxArray;
    PBASE_REGISTER baseIoAddress = CardPtr->BaseIoAddress;
    ULONG i;
    PMBO mailboxOut;
    PMBI mailboxIn;
    UCHAR status;


    ScsiPortStallExecution(500 * 1000);

    //
    // Wait up to 500 microseconds for adapter to initialize.
    //

    for (i = 0; i < 500; i++) {

        ScsiPortStallExecution(1);

        status = ScsiPortReadPortUchar(&CardPtr->BaseIoAddress->StatusRegister);

        if (status & IOP_SCSI_HBA_IDLE) {
            break;
        }

    }

    if (!(status & IOP_SCSI_HBA_IDLE)) {
        return(FALSE);
    }

    //
    // Zero out mailboxes.
    //

    for (i=0,mailboxIn = MailBoxArray->Mbi,mailboxOut = MailBoxArray->Mbo;
         i<MB_COUNT; i++, mailboxIn++,mailboxOut++) {
               mailboxOut->Command = mailboxIn->Status = 0;
    }

    CardPtr->StartMBO = (PMBO)(&MailBoxArray->Mbo);
    CardPtr->CurrMBO = (PMBO)(&MailBoxArray->Mbo);
    CardPtr->LastMBO = ((PMBO)(&MailBoxArray->Mbo) + (MB_COUNT - 1));
    CardPtr->StartMBI =(PMBI)( &MailBoxArray->Mbi);
    CardPtr->CurrMBI = (PMBI)(&MailBoxArray->Mbi);
    CardPtr->LastMBI = ((PMBI)(&MailBoxArray->Mbi) + (MB_COUNT - 1));


    DebugPrint((3,"ReInitializeHBA: Initialize mailbox\n"));

    if (!WriteCommandRegister(CardPtr,AC_MBOX_EXTENDED_INIT)) {
        DebugPrint((1,"ReInitializeHBA: Couldn't initialize mailboxes\n"));
        return FALSE;
    }

    //
    // Send Adapter number of mailbox locations.
    //

    if (!WriteCommandRegister(CardPtr,MB_COUNT)) {
        DebugPrint((1,"ReInitializeHBA: Extended InitMboxes failed\n"));
        return FALSE;
    }

    if (!WriteCommandRegister(CardPtr,
        ((PFOUR_BYTE)&MailBoxArray->MailboxPA)->Byte0)) {
        DebugPrint((1,"ReInitializeHBA: Extended InitMboxes failed\n"));
        return FALSE;
    }

    if (!WriteCommandRegister(CardPtr,
        ((PFOUR_BYTE)&MailBoxArray->MailboxPA)->Byte1)) {
        DebugPrint((1,"ReInitializeHBA: Extended InitMboxes failed\n"));
        return FALSE;
    }

    if (!WriteCommandRegister(CardPtr,
        ((PFOUR_BYTE)&MailBoxArray->MailboxPA)->Byte2)) {
        DebugPrint((1,"ReInitializeHBA: Extended InitMboxes failed\n"));
        return FALSE;
    }

    if (!WriteCommandRegister(CardPtr,
        ((PFOUR_BYTE)&MailBoxArray->MailboxPA)->Byte3)) {
        DebugPrint((1,"ReInitializeHBA: Extended InitMboxes failed\n"));
        return FALSE;
    }

    if (!FinishHBACmd(CardPtr)) {
        DebugPrint((1,"BLogicHWInitialize: Extended InitMboxes failed\n"));
        return FALSE;
    }

    /* turn on wide support if available */
    if (CardPtr->Flags & OS_SUPPORTS_WIDE)
    {

        //  DebugPrint((0,"ReInitializeHBA: about to send wide cmd\n"));
        
        if (!WriteCommandRegister(CardPtr, AC_WIDE_SUPPORT)) {
                CardPtr->Flags &= ~WIDE_ENABLED;
        }
        else if (!CheckInvalid(CardPtr)) {
                CardPtr->Flags &= ~WIDE_ENABLED;
        }
         else if (!WriteCommandRegister(CardPtr, 0x01)) {
                CardPtr->Flags &= ~WIDE_ENABLED;
        }
        if (!FinishHBACmd(CardPtr)) {
                CardPtr->Flags &= ~WIDE_ENABLED;
        }
        else {
                CardPtr->Flags |= WIDE_ENABLED;
        }
    } /* end if OS_SUPPORTS_WIDE */

   return TRUE;

} // end ReInitializeHBA()

UCHAR
MapError(
    IN PCARD_STRUC CardPtr,
    IN PSCSI_REQUEST_BLOCK Srb,
    IN PCCB Ccb
    )

/*++

Routine Description:

    Translate BusLogic error to SRB error, and log an error if necessary.

Arguments:

    CardPtr - The hardware device extension.

    Srb - The failing Srb.

    Ccb - Command Control Block contains error.

Return Value:

    SRB Error

--*/

{
    UCHAR status;
    ULONG logError = 0;

    switch (Ccb->HostStatus) {

        case CCB_COMPLETE:
                return SRB_STATUS_ERROR;

        case CCB_SELECTION_TIMEOUT:
            return SRB_STATUS_SELECTION_TIMEOUT;

        case CCB_DATA_OVER_UNDER_RUN:
            status = SRB_STATUS_DATA_OVERRUN;
            
            // 
            // Don't log the protocol error anymore.  it floods the system
            // for underruns as well
            //
            // logError = SP_PROTOCOL_ERROR;
            //
            
            break;

        case CCB_UNEXPECTED_BUS_FREE:
            status = SRB_STATUS_UNEXPECTED_BUS_FREE;
            logError = SP_UNEXPECTED_DISCONNECT;
            break;

        case CCB_PHASE_SEQUENCE_FAIL:
        case CCB_INVALID_DIRECTION:
            status = SRB_STATUS_PHASE_SEQUENCE_FAILURE;
            logError = SP_PROTOCOL_ERROR;
            break;

        case CCB_BAD_MBO_COMMAND:
        case CCB_INVALID_OP_CODE:
        case CCB_BAD_LINKED_LUN:
        case CCB_DUPLICATE_CCB:
        case CCB_INVALID_CCB:
            status = SRB_STATUS_INVALID_REQUEST;
            logError = SP_INTERNAL_ADAPTER_ERROR;
            break;

       default:
           status = SRB_STATUS_ERROR;
           logError = SP_INTERNAL_ADAPTER_ERROR;
           break;
    }

    if(logError) {

        ScsiPortLogError(
            CardPtr,
            Srb,
            Srb->PathId,
            Srb->TargetId,
            Srb->Lun,
            logError,
            (2 << 8) | Ccb->HostStatus
            );

    }

    return(status);

} // end MapError()


BOOLEAN
ReadCommandRegister(
    IN PCARD_STRUC CardPtr,
    OUT PUCHAR DataByte
    )

/*++

Routine Description:

    Read command register.

Arguments:

    DeviceExtesion - Pointer to adapder extension
    DataByte - Byte read from register

Return Value:

    TRUE if command register read.
    FALSE if timed out waiting for adapter.

--*/

{
    PBASE_REGISTER baseIoAddress = CardPtr->BaseIoAddress;
    ULONG i;

    //
    // Wait up to 500 microseconds for adapter to be ready.
    //

    for (i=0; i<500; i++) {

        if (ScsiPortReadPortUchar(&baseIoAddress->StatusRegister) &
            IOP_DATA_IN_PORT_FULL) {

            //
            // Adapter ready. Break out of loop.
            //

            break;

        } else {

            //
            // Stall 1 microsecond before
            // trying again.
            //

            ScsiPortStallExecution(1);
        }
    }

    if (i==500) {

            ScsiPortLogError(
                CardPtr,
                NULL,
                0,
                CardPtr->HostTargetId,
                0,
                SP_INTERNAL_ADAPTER_ERROR,
                3 << 8
                );

        DebugPrint((1, "BLogic:ReadCommandRegister:  Read command timed out\n"));
        return FALSE;
    }

    *DataByte = ScsiPortReadPortUchar(&baseIoAddress->CommandRegister);

    return TRUE;

} // end ReadCommandRegister()


BOOLEAN
WriteCommandRegister(
    IN PCARD_STRUC CardPtr,
    IN UCHAR AdapterCommand
    )

/*++

Routine Description:

    Write operation code to command register.

Arguments:

    DeviceExtesion - Pointer to adapter extension
    AdapterCommand - Value to be written to register

Return Value:

    TRUE if command sent.
    FALSE if timed out waiting for adapter.

--*/

{
    PBASE_REGISTER baseIoAddress = CardPtr->BaseIoAddress;
    ULONG i;

    //
    // Wait up to 500 microseconds for adapter to be ready.
    //

    for (i=0; i<500; i++) {

        if (ScsiPortReadPortUchar(&baseIoAddress->StatusRegister) &
            IOP_COMMAND_DATA_OUT_FULL) {

            //
            // Stall 1 microsecond before
            // trying again.
            //

            ScsiPortStallExecution(1);

        } else {

            //
            // Adapter ready. Break out of loop.
            //

            break;
        }
    }

    if (i==500) {

            ScsiPortLogError(
                CardPtr,
                NULL,
                0,
                CardPtr->HostTargetId,
                0,
                SP_INTERNAL_ADAPTER_ERROR,
                4 << 8
                );

        DebugPrint((1, "BLogic:WriteCommandRegister:  Write command timed out\n"));
        return FALSE;
    }

    ScsiPortWritePortUchar(&baseIoAddress->CommandRegister, AdapterCommand);

    return TRUE;

} // end WriteCommandRegister()


BOOLEAN
FinishHBACmd(
    IN PCARD_STRUC CardPtr
    )

/*++

Routine Description:

    Wait for command complete interrupt, clear interrupt, chk cmd status.

Arguments:

    CardPtr - Pointer to adapter extension

Return Value:

    TRUE if command completed successfully.
    FALSE if timed out waiting for adapter or invalid command.

--*/

{
    
    ULONG i;
    PBASE_REGISTER baseIoAddress = CardPtr->BaseIoAddress;

    for (i=0; i<500; i++) {

        if (!((ScsiPortReadPortUchar(&baseIoAddress->InterruptRegister) &
            (IOP_COMMAND_COMPLETE | IOP_ANY_INTERRUPT))==
            (IOP_COMMAND_COMPLETE | IOP_ANY_INTERRUPT))) {

            //
            // Stall 1 microsecond before
            // trying again.
            //

            ScsiPortStallExecution(1);

        } else {

            //
            // Adapter ready. Break out of loop.
            //

            break;
        }
    }

    if (i==500) {

        DebugPrint((1, "BLogic:FinishHBACmd: Wait for CmdCmplt & AnyIntr failed\n"));
        return FALSE;
    }

    ScsiPortWritePortUchar(&baseIoAddress->StatusRegister,IOP_INTERRUPT_RESET);

    if (ScsiPortReadPortUchar(&baseIoAddress->StatusRegister) &
     (IOP_INVALID_COMMAND)) {
        return FALSE;
    }

    return TRUE;

} // end FinishHBACmd()


BOOLEAN
CheckInvalid(
    IN PCARD_STRUC CardPtr
    )

/*++

Routine Description:

    Read status register to check for invalid command.

Arguments:

    DeviceExtesion - Pointer to adapder extension
    DataByte - Byte read from register

Return Value:

    FALSE if invalid command bit on or timed out waiting for adapter.
    TRUE if everything's o.k.

--*/

{
    PBASE_REGISTER baseIoAddress = CardPtr->BaseIoAddress;
    ULONG i;

    ScsiPortStallExecution(500 * 1000);

    //
    // Wait up to 500 microseconds for adapter to be ready.
    //

    for (i=0; i<500; i++) {
        if (ScsiPortReadPortUchar(&baseIoAddress->InterruptRegister) &
            IOP_COMMAND_COMPLETE) {
            //
            // Adapter command complete. Break out of loop.
            //

            break;

        } else {

            //
            // Stall 1 microsecond before
            // trying again.
            //

            ScsiPortStallExecution(1);
        }
    }

    if (i==500) {
        // if command not complete, must not be invalid 
        return TRUE;
    }

    if (ScsiPortReadPortUchar(&baseIoAddress->StatusRegister) &
       IOP_INVALID_COMMAND) 
           return FALSE;
   else
          return TRUE;

} // end CheckInvalid()



BOOLEAN
SendCCB(
    IN PSCSI_REQUEST_BLOCK Srb,
    IN PCARD_STRUC CardPtr,
    IN PDEV_STRUC DevStruc
    )

/*++

Routine Description:

    Finds empty outgoing Mbox, stuffs CCB into it and sends start command.

Arguments:

    CardPtr - Pointer to adapter extension
    Srb - Pointer to SCSI Request Block
    DevStruc - Pointer to device (TAR/LUN) structure

Return Value:

    TRUE if command completed successfully.


--*/

{
    PMBO mboxOut;
    ULONG physicalCCB;
    PCCB ccb;
    ULONG length;
    USHORT i;

    while (1)                                                                                   /* wait for free mbox out */
    {
        for (i=0, mboxOut = CardPtr->CurrMBO ; i< MB_COUNT; i++,mboxOut++)
        {       /* look for an open slot */

            if (mboxOut > CardPtr->LastMBO)
                mboxOut = CardPtr->StartMBO;

            if (mboxOut->Command == MBO_FREE)
            {

                /* Insert Phys addr of CCB into MBO */

                if (Srb->Function != SRB_FUNCTION_ABORT_COMMAND)
                        ccb = (PCCB)(Srb->SrbExtension);
                else
                        ccb = (PCCB)(Srb->NextSrb->SrbExtension);

                physicalCCB = ScsiPortConvertPhysicalAddressToUlong(
                ScsiPortGetPhysicalAddress(CardPtr, NULL, ccb, &length));

                //
                // Assume physical address is contiguous for size of CCB.
                //

                ASSERT(length >= sizeof(CCB));
                mboxOut->Address = physicalCCB;

                if (Srb->Function != SRB_FUNCTION_ABORT_COMMAND) {
                    /* insert this SRB into active queue for this device */

                    ccb->NxtActiveCCB = DevStruc->CurrentCCB;
                    DevStruc->CurrentCCB = ccb;
                    mboxOut->Command = MBO_START;
                }
                else
                    mboxOut->Command = MBO_ABORT;

                CardPtr->CurrMBO = mboxOut + 1;

                if (!WriteCommandRegister(CardPtr,AC_START_SCSI_COMMAND)) {
                    DebugPrint((1,"BLogicStartIo: Can't write command to adapter\n"));
                }

                return TRUE;

            } /* end for found a free MBO */
        }  /* end for 0 to mbox count */
    } /* end while forever */

} /* end SendCCB() */


PMBI
DoneMbox(
    IN PCARD_STRUC CardPtr
    )

/*++

Routine Description:

    Finds Full incoming Mbox

Arguments:

    CardPtr - Pointer to adapter extension

Return Value:

    Pointer to full MBI if full found, FALSE if not

--*/

{
    register PMBI mboxp;
    int i;

    mboxp = CardPtr->CurrMBI;

    for (i = 0; i < MB_COUNT; i++, mboxp++)
    {
        if (mboxp > CardPtr->LastMBI)
            mboxp = CardPtr->StartMBI;

        if (mboxp->Status != MBI_FREE)
        {
            CardPtr->CurrMBI = mboxp + 1;
            return (mboxp);
        }

    }
    return ((PMBI) NULL);
} /* end DoneMbox() */


BOOLEAN
AdjustCCBqueue(
    PCCB ccbp,
    IN PDEV_STRUC devptr
    )
/*++

Routine Description:

    Removes newly-completed CCB from outstanding CCB queue for a given
    device.

Arguments:

    ccbp  -  Pointer to the completed CCB
    devptr - Pointer to device (TAR/LUN) structure

Return Value:

    TRUE if matching CCB was found in active queue
    FALSE if no match could be found

--*/
{
        PCCB tempCCB = devptr->CurrentCCB;  /* ptr to head of active CCBS */

        if (tempCCB == 0)
        {
            return FALSE;
        }

        if (ccbp == tempCCB)    /* match with head of active CCB queue */
        {
                devptr->CurrentCCB = tempCCB->NxtActiveCCB;
                ccbp->NxtActiveCCB = (PCCB) 0;
                return TRUE;

        }

        while (tempCCB->NxtActiveCCB != 0 )
        {
                if (ccbp == tempCCB->NxtActiveCCB)
                {
                        tempCCB->NxtActiveCCB = ccbp->NxtActiveCCB;
                        ccbp->NxtActiveCCB = (PCCB) 0;
                        return TRUE;
                }

                tempCCB = tempCCB->NxtActiveCCB;
        }

        return FALSE;                           /* no match found */

}  /* end function AdjustCCBQueue */