windows-server-2003/drivers/storage/ide/atapi/atapi.c

/*++

Copyright (C) 1993-99  Microsoft Corporation

Module Name:

    atapi.c

Abstract:

    This is the miniport driver for IDE controllers.

Author:

    Mike Glass (MGlass)
    Chuck Park (ChuckP)
    Joe Dai (joedai)

Environment:

    kernel mode only

Notes:

Revision History:

    george C.(georgioc)     Merged wtih Compaq code to make miniport driver function
                            with the 120MB floppy drive
                            Added support for MEDIA STATUS NOTIFICATION
                            Added support for SCSIOP_START_STOP_UNIT (eject media)

    joedai                  PCI Bus Master IDE Support
                            ATA Passthrough (temporary solution)
                            LBA with ATA drive > 8G
                            PCMCIA IDE support
                            Native mode support

--*/

#include "ideport.h"

#if DBG
ULONG __DebugForceTimeout = 0;
static ULONG __DebugResetCounter = 0;
LOGICAL IdeDebugSimulateHardHang = FALSE;
#endif // DBG

#ifdef ALLOC_PRAGMA
    #pragma alloc_text(NONPAGE, InitHwExtWithIdentify)
#endif // ALLOC_PRAGMA

BOOLEAN
IssueIdentify(
             PIDE_REGISTERS_1    CmdBaseAddr,
             PIDE_REGISTERS_2    CtrlBaseAddr,
             IN ULONG            DeviceNumber,
             IN UCHAR            Command,
             IN BOOLEAN          InterruptOff,
             OUT PIDENTIFY_DATA  IdentifyData
             )

/*++

Routine Description:

    Issue IDENTIFY command to a device.

Arguments:

    HwDeviceExtension - HBA miniport driver's adapter data storage
    DeviceNumber - Indicates which device.
    Command - Either the standard (EC) or the ATAPI packet (A1) IDENTIFY.
    InterruptOff - should leave interrupt disabled

Return Value:

    TRUE if all goes well.

--*/

{
    ULONG                waitCount = 20000;
    ULONG                i,j;
    UCHAR                statusByte;
    UCHAR                signatureLow,
    signatureHigh;
    IDENTIFY_DATA        fullIdentifyData;

    RtlZeroMemory (IdentifyData, sizeof (IdentifyData));

    //
    // Select device 0 or 1.
    //
    SelectIdeDevice(CmdBaseAddr, DeviceNumber, 0);

    //
    // Check that the status register makes sense.
    //

    GetBaseStatus(CmdBaseAddr, statusByte);

    if (Command == IDE_COMMAND_IDENTIFY) {

        //
        // Mask status byte ERROR bits.
        //

        CLRMASK (statusByte, IDE_STATUS_ERROR | IDE_STATUS_INDEX);

        DebugPrint((1,
                    "IssueIdentify: Checking for IDE. Status (%x)\n",
                    statusByte));

        //
        // Check if register value is reasonable.
        //

        if (statusByte != IDE_STATUS_IDLE) {

            //
            // Reset the controller.
            //
            IdeHardReset (
                         CmdBaseAddr,
                         CtrlBaseAddr,
                         InterruptOff,
                         TRUE
                         );

            SelectIdeDevice(CmdBaseAddr, DeviceNumber, 0);

            //
            // Another check for signature, to deal with one model Atapi that doesn't assert signature after
            // a soft reset.
            //

            signatureLow = IdePortInPortByte(CmdBaseAddr->CylinderLow);
            signatureHigh = IdePortInPortByte(CmdBaseAddr->CylinderHigh);

            if (signatureLow == 0x14 && signatureHigh == 0xEB) {

                //
                // Device is Atapi.
                //

                return FALSE;
            }

            if (Is98LegacyIde(CmdBaseAddr)) {

                AtapiSoftReset(CmdBaseAddr, CtrlBaseAddr, DeviceNumber, TRUE);

                WaitOnBusy(CmdBaseAddr, statusByte);

                if (!(statusByte & IDE_STATUS_ERROR)) {

                    //
                    // Device is WD-Mode cdrom.
                    //

                    return FALSE;
                }
            }

            GetBaseStatus(CmdBaseAddr, statusByte);
            CLRMASK (statusByte, IDE_STATUS_INDEX);

            if (statusByte != IDE_STATUS_IDLE) {

                //
                // Give up on this.
                //

                return FALSE;
            }

        }

    } else {

        DebugPrint((1,
                    "IssueIdentify: Checking for ATAPI. Status (%x)\n",
                    statusByte));

    }

    //
    // Load CylinderHigh and CylinderLow with number bytes to transfer.
    //

    IdePortOutPortByte(CmdBaseAddr->CylinderHigh, (0x200 >> 8));
    IdePortOutPortByte(CmdBaseAddr->CylinderLow,  (0x200 & 0xFF));

    for (j = 0; j < 2; j++) {

        //
        // Send IDENTIFY command.
        //

        WaitOnBusy(CmdBaseAddr,statusByte);

        IdePortOutPortByte(CmdBaseAddr->Command, Command);

        WaitOnBusy(CmdBaseAddr,statusByte);

        if (statusByte & IDE_STATUS_ERROR) {

            continue;
        }

        //
        // Wait for DRQ.
        //

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

            WaitForDrq(CmdBaseAddr, statusByte);

            if (statusByte & IDE_STATUS_DRQ) {

                //
                // Read status to acknowledge any interrupts generated.
                //

                GetBaseStatus(CmdBaseAddr, statusByte);

                //
                // One last check for Atapi.
                //


                signatureLow = IdePortInPortByte(CmdBaseAddr->CylinderLow);
                signatureHigh = IdePortInPortByte(CmdBaseAddr->CylinderHigh);

                if (signatureLow == 0x14 && signatureHigh == 0xEB) {

                    //
                    // Device is Atapi.
                    //

                    return FALSE;
                }

                break;
            }

            if (Command == IDE_COMMAND_IDENTIFY) {

                //
                // Check the signature. If DRQ didn't come up it's likely Atapi.
                //

                signatureLow = IdePortInPortByte(CmdBaseAddr->CylinderLow);
                signatureHigh = IdePortInPortByte(CmdBaseAddr->CylinderHigh);

                if (signatureLow == 0x14 && signatureHigh == 0xEB) {

                    //
                    // Device is Atapi.
                    //

                    return FALSE;
                }

                if (Is98LegacyIde(CmdBaseAddr)) {

                    AtapiSoftReset(CmdBaseAddr, CtrlBaseAddr, DeviceNumber, TRUE);

                    WaitOnBusy(CmdBaseAddr, statusByte);

                    if (!(statusByte & IDE_STATUS_ERROR)) {

                        //
                        // Device is WD-Mode cdrom.
                        //

                        return FALSE;
                    }
                }
            }

            WaitOnBusy(CmdBaseAddr,statusByte);
        }

        if (i == 4 && j == 0) {

            //
            // Device didn't respond correctly. It will be given one more chances.
            //

            DebugPrint((1,
                        "IssueIdentify: DRQ never asserted (%x). Error reg (%x)\n",
                        statusByte,
                        IdePortInPortByte(CmdBaseAddr->Error)));

            AtapiSoftReset(CmdBaseAddr, CtrlBaseAddr, DeviceNumber, InterruptOff);

            GetStatus(CmdBaseAddr,statusByte);

            DebugPrint((1,
                        "IssueIdentify: Status after soft reset (%x)\n",
                        statusByte));

        } else {

            break;

        }
    }

    //
    // Check for error on really bad master devices that assert random
    // patterns of bits in the status register at the slave address.
    //
    if (statusByte & IDE_STATUS_ERROR) {
        return FALSE;
    }


    DebugPrint((1,
                "IssueIdentify: Status before read words %x\n",
                statusByte));

    //
    // pull out 256 words. After waiting for one model that asserts busy
    // after receiving the Packet Identify command.
    //

    WaitOnBusy(CmdBaseAddr,statusByte);

    if (!(statusByte & IDE_STATUS_DRQ)) {
        return FALSE;
    }

    if (Is98LegacyIde(CmdBaseAddr)) {
        //
        // Delay(10ms) for ATAPI CD-ROM device.
        //

        if (Command == IDE_COMMAND_ATAPI_IDENTIFY) {
            for (i = 0; i < 100; i++) {
                KeStallExecutionProcessor(100);
            }
        }
    }

    ReadBuffer(CmdBaseAddr,
               (PUSHORT)&fullIdentifyData,
               sizeof (fullIdentifyData) / 2);

    RtlMoveMemory(IdentifyData,&fullIdentifyData,sizeof(*IdentifyData));

    WaitOnBusy(CmdBaseAddr,statusByte);

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

        GetStatus(CmdBaseAddr,statusByte);

        if (statusByte & IDE_STATUS_DRQ) {

            //
            // pull out any remaining bytes and throw away.
            //

            READ_PORT_USHORT(CmdBaseAddr->Data);

        } else {

            break;

        }
    }

    DebugPrint((3,
                "IssueIdentify: Status after read words (%x)\n",
                statusByte));

    return TRUE;

} // end IssueIdentify()

VOID
InitDeviceGeometry(
                  PHW_DEVICE_EXTENSION HwDeviceExtension,
                  ULONG                Device,
                  ULONG                NumberOfCylinders,
                  ULONG                NumberOfHeads,
                  ULONG                SectorsPerTrack
                  )
{

    ASSERT (HwDeviceExtension);
    ASSERT (Device < HwDeviceExtension->MaxIdeDevice);
    ASSERT (NumberOfCylinders);
    ASSERT (NumberOfHeads);
    ASSERT (SectorsPerTrack);

    HwDeviceExtension->NumberOfCylinders[Device] = NumberOfCylinders;
    HwDeviceExtension->NumberOfHeads[Device]     = NumberOfHeads;
    HwDeviceExtension->SectorsPerTrack[Device]   = SectorsPerTrack;

    return;
}

VOID
InitHwExtWithIdentify(
                     IN PVOID           HwDeviceExtension,
                     IN ULONG           DeviceNumber,
                     IN UCHAR           Command,
                     IN PIDENTIFY_DATA  IdentifyData,
                     IN BOOLEAN         RemovableMedia
                     )

/*++

Routine Description:

    Issue IDENTIFY command to a device.

Arguments:

    HwDeviceExtension - HBA miniport driver's adapter data storage
    DeviceNumber - Indicates which device.
    Command - Either the standard (EC) or the ATAPI packet (A1) IDENTIFY.
    InterruptOff - should leave interrupt disabled

Return Value:

    TRUE if all goes well.

--*/

{
    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
    ULONG                i,j;

    //
    // Check out a few capabilities / limitations of the device.
    //

    if (IdentifyData->MediaStatusNotification == IDENTIFY_MEDIA_STATUS_NOTIFICATION_SUPPORTED) {

        //
        // Determine if this drive supports the MSN functions.
        //

        DebugPrint((2,"InitHwExtWithIdentify: Marking drive %d as removable. SFE = %d\n",
                    DeviceNumber,
                    IdentifyData->MediaStatusNotification));

        deviceExtension->DeviceFlags[DeviceNumber] |= DFLAGS_MSN_SUPPORT;
    }


    if (RemovableMedia) {

        //
        // This device has removable media
        //

        deviceExtension->DeviceFlags[DeviceNumber] |= DFLAGS_REMOVABLE_DRIVE;
        CLRMASK (deviceExtension->DeviceFlags[DeviceNumber], DFLAGS_IDENTIFY_VALID);

        DebugPrint((2,
                    "InitHwExtWithIdentify: Device media is removable\n"));

    } else {

        DebugPrint((2,
                    "InitHwExtWithIdentify: Device media is NOT removable\n"));
    }

    if (IdentifyData->GeneralConfiguration & 0x20 &&
        Command != IDE_COMMAND_IDENTIFY) {

        //
        // This device interrupts with the assertion of DRQ after receiving
        // Atapi Packet Command
        //

        deviceExtension->DeviceFlags[DeviceNumber] |= DFLAGS_INT_DRQ;

        DebugPrint((2,
                    "InitHwExtWithIdentify: Device interrupts on assertion of DRQ.\n"));

    } else {

        DebugPrint((2,
                    "InitHwExtWithIdentify: Device does not interrupt on assertion of DRQ.\n"));
    }

    if (((IdentifyData->GeneralConfiguration & 0xF00) == 0x100) &&
        Command != IDE_COMMAND_IDENTIFY) {

        //
        // This is a tape.
        //

        deviceExtension->DeviceFlags[DeviceNumber] |= DFLAGS_TAPE_DEVICE;

        DebugPrint((2,
                    "InitHwExtWithIdentify: Device is a tape drive.\n"));

    } else {

        DebugPrint((2,
                    "InitHwExtWithIdentify: Device is not a tape drive.\n"));
    }

    return;

} // InitHwExtWithIdentify


BOOLEAN
SetDriveParameters(
                  IN PVOID HwDeviceExtension,
                  IN ULONG DeviceNumber,
                  IN BOOLEAN Sync
                  )

/*++

Routine Description:

    Set drive parameters using the IDENTIFY data.

Arguments:

    HwDeviceExtension - HBA miniport driver's adapter data storage
    DeviceNumber - Indicates which device.

Return Value:

    TRUE if all goes well.


--*/

{
    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
    PIDE_REGISTERS_1     baseIoAddress1 = &deviceExtension->BaseIoAddress1;
    PIDE_REGISTERS_2     baseIoAddress2 = &deviceExtension->BaseIoAddress2;
    ULONG i;
    UCHAR statusByte;

    DebugPrint ((DBG_BUSSCAN, "SetDriveParameters: %s %d\n", __FILE__, __LINE__));

    DebugPrint((1,
                "SetDriveParameters: Number of heads %x\n",
                deviceExtension->NumberOfHeads[DeviceNumber]));

    DebugPrint((1,
                "SetDriveParameters: Sectors per track %x\n",
                deviceExtension->SectorsPerTrack[DeviceNumber]));
    if (deviceExtension->DeviceFlags[DeviceNumber] & DFLAGS_IDENTIFY_VALID) {

        ASSERT(!(deviceExtension->DeviceFlags[DeviceNumber] & DFLAGS_REMOVABLE_DRIVE));

        SETMASK(deviceExtension->DeviceFlags[DeviceNumber], DFLAGS_IDENTIFY_INVALID);
        CLRMASK(deviceExtension->DeviceFlags[DeviceNumber], DFLAGS_IDENTIFY_VALID);
    }

    //
    // Set up registers for SET PARAMETER command.
    //
    SelectIdeDevice(baseIoAddress1, DeviceNumber, (deviceExtension->NumberOfHeads[DeviceNumber] - 1));

    IdePortOutPortByte(baseIoAddress1->BlockCount,
                       (UCHAR)deviceExtension->SectorsPerTrack[DeviceNumber]);

    DebugPrint ((DBG_BUSSCAN, "SetDriveParameters: %s %d\n", __FILE__, __LINE__));

    //
    // Send SET PARAMETER command.
    //
    IdePortOutPortByte(baseIoAddress1->Command,
                       IDE_COMMAND_SET_DRIVE_PARAMETERS);

    DebugPrint ((DBG_BUSSCAN, "SetDriveParameters: %s %d\n", __FILE__, __LINE__));

    if (Sync) {

        DebugPrint ((DBG_BUSSCAN, "SetDriveParameters: %s %d\n", __FILE__, __LINE__));

        //
        // Wait for ERROR or command complete.
        //
        WaitOnBusy(baseIoAddress1,statusByte);

        DebugPrint ((DBG_BUSSCAN, "SetDriveParameters: %s %d\n", __FILE__, __LINE__));

        if (statusByte & IDE_STATUS_BUSY) {

            return FALSE;

        } else {

            if (statusByte & IDE_STATUS_ERROR) {

                UCHAR errorByte;

                errorByte = IdePortInPortByte(baseIoAddress1->Error);
                DebugPrint((1,
                            "SetDriveParameters: Error bit set. Status %x, error %x\n",
                            errorByte,
                            statusByte));

                return FALSE;

            } else {

                return TRUE;
            }
        }

    } else {

        return TRUE;
    }

} // end SetDriveParameters()

VOID
BuildResetStateTable (
    PHW_DEVICE_EXTENSION DeviceExtension
    )
{
    ULONG numStates;
    ULONG deviceNumber;

    //
    // build state table
    //
    numStates = 0;

    //
    // choose slave if master is not present
    //
    deviceNumber = (DeviceExtension->DeviceFlags[0] & DFLAGS_DEVICE_PRESENT) ? 0 : 1;

    DeviceExtension->ResetState.DeviceNumber[numStates] = deviceNumber;
    DeviceExtension->ResetState.State[numStates++] = IdeResetBegin;

    DeviceExtension->ResetState.DeviceNumber[numStates] = deviceNumber;
    DeviceExtension->ResetState.State[numStates++] = ideResetBusResetInProgress;

    for (deviceNumber = 0; deviceNumber < MAX_IDE_DEVICE; deviceNumber++) {

        if (DeviceExtension->DeviceFlags[deviceNumber] & DFLAGS_DEVICE_PRESENT) {

            if (DeviceExtension->DeviceFlags[deviceNumber] & DFLAGS_ATAPI_DEVICE) {

                DeviceExtension->ResetState.DeviceNumber[numStates] = deviceNumber;
                DeviceExtension->ResetState.State[numStates++] = ideResetAtapiReset;

                DeviceExtension->ResetState.DeviceNumber[numStates] = deviceNumber;
                DeviceExtension->ResetState.State[numStates++] = ideResetAtapiResetInProgress;

                DeviceExtension->ResetState.DeviceNumber[numStates] = deviceNumber;
                DeviceExtension->ResetState.State[numStates++] = ideResetAtapiIdentifyData;

            } else {

                DeviceExtension->ResetState.DeviceNumber[numStates] = deviceNumber;
                DeviceExtension->ResetState.State[numStates++] = ideResetAtaIDP;

                DeviceExtension->ResetState.DeviceNumber[numStates] = deviceNumber;
                DeviceExtension->ResetState.State[numStates++] = ideResetAtaIDPInProgress;

                DeviceExtension->ResetState.DeviceNumber[numStates] = deviceNumber;
                DeviceExtension->ResetState.State[numStates++] = ideResetAtaMSN;
            }
        }
    }

    //
    // choose slave if master is not present
    //
    deviceNumber = (DeviceExtension->DeviceFlags[0] & DFLAGS_DEVICE_PRESENT) ? 0 : 1;

    DeviceExtension->ResetState.DeviceNumber[numStates] = deviceNumber;
    DeviceExtension->ResetState.State[numStates++] = ideResetFinal;

    ASSERT (numStates <= RESET_STATE_TABLE_LEN);

    return;
}

BOOLEAN
AtapiResetController(
                    IN PVOID  HwDeviceExtension,
                    IN ULONG  PathId,
                    IN PULONG CallAgain
                    )

/*++

Routine Description:

    Reset IDE controller and/or Atapi device.

Arguments:

    HwDeviceExtension - HBA miniport driver's adapter data storage

Return Value:

    Nothing.


--*/

{
    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
    PIDE_REGISTERS_1 baseIoAddress1;
    PIDE_REGISTERS_2 baseIoAddress2;
    BOOLEAN result = FALSE;
    ULONG i;
    UCHAR statusByte;
    ULONG numStates;
    BOOLEAN  enumProbing = FALSE;
    ULONG lineNumber, deviceNumber;
    BOOLEAN setResetFinalState; 

    baseIoAddress1 = &deviceExtension->BaseIoAddress1;
    baseIoAddress2 = &deviceExtension->BaseIoAddress2;

    if (*CallAgain == 0) {

        BuildResetStateTable(deviceExtension);
    }

    DebugPrint ((DBG_RESET,
                 "AtapiResetController CallAgain = 0x%x, device = 0x%x, busyCount = 0x%x\n",
                 *CallAgain,
                 deviceExtension->ResetState.DeviceNumber[*CallAgain],
                 deviceExtension->ResetState.WaitBusyCount
                ));

    switch (deviceExtension->ResetState.State[*CallAgain]) {
    
    case IdeResetBegin:

        DebugPrint((DBG_RESET,
                    "AtapiResetController: Reset 0x%x IDE...\n",
                    deviceExtension->BaseIoAddress1.RegistersBaseAddress));

        //
        // Check if request is in progress.
        //
        if (deviceExtension->CurrentSrb) {

            enumProbing = TestForEnumProbing (deviceExtension->CurrentSrb);

            if ((deviceExtension->CurrentSrb->Function == SRB_FUNCTION_ATA_POWER_PASS_THROUGH) ||
                (deviceExtension->CurrentSrb->Function == SRB_FUNCTION_ATA_PASS_THROUGH)) {

                PATA_PASS_THROUGH    ataPassThroughData;

                ataPassThroughData = deviceExtension->CurrentSrb->DataBuffer;

                AtapiTaskRegisterSnapshot (baseIoAddress1, &ataPassThroughData->IdeReg);

            } else if (deviceExtension->CurrentSrb->Function == SRB_FUNCTION_ATA_PASS_THROUGH_EX) {

                PIDEREGS pIdeReg = (PIDEREGS) deviceExtension->CurrentSrb->Cdb;

                AtapiTaskRegisterSnapshot(baseIoAddress1, pIdeReg);
            }

            //
            // Complete outstanding request with SRB_STATUS_BUS_RESET.
            //

            IdePortCompleteRequest(deviceExtension,
                                   deviceExtension->CurrentSrb,
                                   (ULONG)SRB_STATUS_BUS_RESET);

            //
            // Clear request tracking fields.
            //

            deviceExtension->CurrentSrb = NULL;
            deviceExtension->BytesLeft = 0;
            deviceExtension->DataBuffer = NULL;

            //
            // Indicate ready for next request.
            //

            IdePortNotification(IdeNextRequest,
                                deviceExtension,
                                NULL);

        }

        //
        // Clear DMA
        //
        if (deviceExtension->DMAInProgress) {
            deviceExtension->DMAInProgress = FALSE;
            deviceExtension->BusMasterInterface.BmDisarm (deviceExtension->BusMasterInterface.Context);
        }

        //
        // Clear expecting interrupt flag.
        //

        deviceExtension->ExpectingInterrupt = FALSE;
        deviceExtension->RDP = FALSE;

        if (!enumProbing) {

            //
            // ATA soft reset.  reset only ATA devices
            //
            IdeHardReset (
                         baseIoAddress1,
                         baseIoAddress2,
                         TRUE,
                         FALSE
                         );
            (*CallAgain)++;
            deviceExtension->ResetState.WaitBusyCount = 0;

            //
            // go to the next stage if a short wait satisfies the 
            // requirement
            //
            SelectIdeDevice(baseIoAddress1,
                            deviceExtension->ResetState.DeviceNumber[*CallAgain],
                            0
                            );

            GetStatus(baseIoAddress1,statusByte);

            WaitOnBusyUntil(baseIoAddress1, statusByte, 200);

            if (statusByte & IDE_STATUS_BUSY) {

                return TRUE;

            } else {

                return AtapiResetController(
                                           HwDeviceExtension,
                                           PathId,
                                           CallAgain
                                           );
            }

        } else {

            //
            // timeout is caused by a command sent to a non-existing device
            // no need to reset
            //
            *CallAgain = 0;
        }

        return TRUE;
        break;

        //
        // all these states waits for BUSY to go clear
        // then go to the next state
        //

    case ideResetBusResetInProgress:

        SelectIdeDevice(baseIoAddress1,
                        deviceExtension->ResetState.DeviceNumber[*CallAgain],
                        0
                        );

    case ideResetAtapiResetInProgress:
    case ideResetAtaIDPInProgress:

        GetStatus(baseIoAddress1,statusByte);

        if (statusByte & IDE_STATUS_BUSY) {

            deviceExtension->ResetState.WaitBusyCount++;

            if ((deviceExtension->ResetState.WaitBusyCount > 30) ||
                (statusByte == 0xff)) {

                //
                // reset fails
                //
                DebugPrint ((DBG_ALWAYS, "ATAPI ResetController: ATA soft reset fails\n"));

                if (IdePortChannelEmpty (baseIoAddress1, 
                                         baseIoAddress2, 
                                         deviceExtension->MaxIdeDevice)) {

                    IdePortNotification(IdeAllDeviceMissing,
                                        deviceExtension,
                                        NULL);
                    *CallAgain = 0;
                    IdePortOutPortByte (baseIoAddress2->DeviceControl, IDE_DC_REENABLE_CONTROLLER);
                    return TRUE;
                }

                //
                // no choice, but continue with the reset
                //
//                *CallAgain = 0;
//                IdePortOutPortByte (baseIoAddress2, IDE_DC_REENABLE_CONTROLLER);
//                return FALSE;

            } else {

                DebugPrint ((DBG_ALWAYS, "ATAPI: ResetController not ready (status = 0x%x) ...wait for 1 sec\n", statusByte));
                return TRUE;
            }
        }

        (*CallAgain)++;
        return AtapiResetController(
                                   HwDeviceExtension,
                                   PathId,
                                   CallAgain
                                   );
        break;

    case ideResetAtapiReset:
        SelectIdeDevice(baseIoAddress1, deviceExtension->ResetState.DeviceNumber[*CallAgain], 0);
        IdePortOutPortByte(baseIoAddress1->Command, IDE_COMMAND_ATAPI_RESET);
        deviceExtension->ResetState.WaitBusyCount = 0;
        (*CallAgain)++;

        //
        // go to the next stage if a short wait satisfies the 
        // requirement
        //
        GetStatus(baseIoAddress1,statusByte);

        WaitOnBusyUntil(baseIoAddress1, statusByte, 200);

        if (statusByte & IDE_STATUS_BUSY) {

            return TRUE;

        } else {

            return AtapiResetController(
                                       HwDeviceExtension,
                                       PathId,
                                       CallAgain
                                       );
        }

        return TRUE;
        break;

    case ideResetAtaIDP:
        if (!Is98LegacyIde(baseIoAddress1)) {
            SetDriveParameters(HwDeviceExtension,
                               deviceExtension->ResetState.DeviceNumber[*CallAgain],
                               FALSE);
        }
        deviceExtension->ResetState.WaitBusyCount = 0;
        (*CallAgain)++;

        //
        // go to the next stage if a short wait satisfies the 
        // requirement
        //
        GetStatus(baseIoAddress1,statusByte);

        WaitOnBusyUntil(baseIoAddress1, statusByte, 200);

        if (statusByte & IDE_STATUS_BUSY) {

            return TRUE;

        } else {

            return AtapiResetController(
                                       HwDeviceExtension,
                                       PathId,
                                       CallAgain
                                       );
        }

        return TRUE;
        break;

    case ideResetAtapiIdentifyData:

        //
        // the device shouldn't be busy at this point
        //
        SelectIdeDevice(&deviceExtension->BaseIoAddress1,
                        deviceExtension->ResetState.DeviceNumber[*CallAgain],
                        0
                        );

        WaitOnBusyUntil(&deviceExtension->BaseIoAddress1,
                        statusByte,
                        100
                       );

        //
        // issue identify command only if the device is not
        // already busy
        //
        if (!(statusByte & IDE_STATUS_BUSY)) {

            GetAtapiIdentifyQuick( &deviceExtension->BaseIoAddress1,
                                   &deviceExtension->BaseIoAddress2,
                                   deviceExtension->ResetState.DeviceNumber[*CallAgain],
                                   &deviceExtension->IdentifyData[deviceExtension->ResetState.DeviceNumber[*CallAgain]]
                                   );

            /*
            IssueIdentify(
                         &deviceExtension->BaseIoAddress1,
                         &deviceExtension->BaseIoAddress2,
                         deviceExtension->ResetState.DeviceNumber[*CallAgain],
                         IDE_COMMAND_ATAPI_IDENTIFY,
                         FALSE,
                         &deviceExtension->IdentifyData[deviceExtension->ResetState.DeviceNumber[*CallAgain]]
                         );
                         */

        }

//        InitHwExtWithIdentify(
//            HwDeviceExtension,
//            deviceExtension->ResetState.DeviceNumber[*CallAgain],
//            IDE_COMMAND_ATAPI_IDENTIFY,
//            &deviceExtension->IdentifyData[deviceExtension->ResetState.DeviceNumber[*CallAgain]]
//            );
        (*CallAgain)++;
        return AtapiResetController(
                                   HwDeviceExtension,
                                   PathId,
                                   CallAgain
                                   );
        break;

    case ideResetAtaMSN:
        IdeMediaStatus(
                      TRUE, 
                      HwDeviceExtension, 
                      deviceExtension->ResetState.DeviceNumber[*CallAgain]
                      );
        (*CallAgain)++;
        return AtapiResetController(
                                   HwDeviceExtension,
                                   PathId,
                                   CallAgain
                                   );
        break;

    case ideResetFinal:

        //
        // HACK: if any of the devices are busy at this point, then they should
        // be marked dead. This will anyway happen because of the timeout count.
        // However, the waitOnBusy macros in all the routines would consume upto
        // 30s leaving the sytem practically hung until the reset completes. Instead,
        // we just clear the device present flag before the routine is called and
        // restore it after that.
        //
        for (i = 0; i < (deviceExtension->MaxIdeDevice/MAX_IDE_DEVICE); i++) {

            if (deviceExtension->DeviceFlags[i] & DFLAGS_DEVICE_PRESENT) {
                SelectIdeDevice(baseIoAddress1, i, 0);
                WaitOnBusyUntil(baseIoAddress1, statusByte, 100);

                if (statusByte & IDE_STATUS_BUSY) {
                    CLRMASK(deviceExtension->DeviceFlags[i], DFLAGS_DEVICE_PRESENT);
                    SETMASK(deviceExtension->DeviceFlags[i], DFLAGS_DEVICE_ERASED);
                }
            }
        }

        AtapiHwInitialize(HwDeviceExtension, NULL);

        //
        // Restore the device present flag
        //
        for (i = 0; i < (deviceExtension->MaxIdeDevice/MAX_IDE_DEVICE); i++) {

            if (deviceExtension->DeviceFlags[i] & DFLAGS_DEVICE_ERASED) {
                SETMASK(deviceExtension->DeviceFlags[i], DFLAGS_DEVICE_PRESENT);
            }
        }

        if (IdePortChannelEmpty (baseIoAddress1, 
                                 baseIoAddress2, deviceExtension->MaxIdeDevice)) {

            IdePortNotification(IdeAllDeviceMissing,
                                deviceExtension,
                                NULL);
        }
        *CallAgain = 0;
        for (i = 0; i < (deviceExtension->MaxIdeDevice/MAX_IDE_DEVICE); i++) {
            SelectIdeLine(baseIoAddress1, i);
            IdePortOutPortByte (baseIoAddress2->DeviceControl, IDE_DC_REENABLE_CONTROLLER);
        }
        return TRUE;
        break;

    default:
        ASSERT(FALSE);
        *CallAgain = 0;
        for (i = 0; i < (deviceExtension->MaxIdeDevice/MAX_IDE_DEVICE); i++) {
            SelectIdeLine(baseIoAddress1, i);
            IdePortOutPortByte (baseIoAddress2->DeviceControl, IDE_DC_REENABLE_CONTROLLER);
        }
        return FALSE;
        break;
    }
} // end AtapiResetController()



ULONG
MapError(
        IN PVOID HwDeviceExtension,
        IN PSCSI_REQUEST_BLOCK Srb
        )

/*++

Routine Description:

    This routine maps ATAPI and IDE errors to specific SRB statuses.

Arguments:

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

Return Value:

    SRB status

--*/

{
    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
    PIDE_REGISTERS_1     baseIoAddress1  = &deviceExtension->BaseIoAddress1;
    PIDE_REGISTERS_2     baseIoAddress2  = &deviceExtension->BaseIoAddress2;
    ULONG i;
    UCHAR errorByte;
    UCHAR srbStatus;
    UCHAR scsiStatus;
    SENSE_DATA  tempSenseBuffer;
    PSENSE_DATA  senseBuffer = (PSENSE_DATA)&tempSenseBuffer;

    //
    // Read the error register.
    //

    //errorByte = IdePortInPortByte(baseIoAddress1->Error);
    GetErrorByte(baseIoAddress1, errorByte);

    DebugPrint((DBG_IDE_DEVICE_ERROR,
                "MapError: cdb %x and Error register is %x\n",
                Srb->Cdb[0],
                errorByte));

    if (deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_ATAPI_DEVICE) {

        switch (errorByte >> 4) {
        case SCSI_SENSE_NO_SENSE:

            DebugPrint((DBG_IDE_DEVICE_ERROR,
                        "ATAPI: No sense information\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;
            break;

        case SCSI_SENSE_RECOVERED_ERROR:

            DebugPrint((DBG_IDE_DEVICE_ERROR,
                        "ATAPI: Recovered error\n"));
            scsiStatus = 0;
            srbStatus = SRB_STATUS_SUCCESS;
            break;

        case SCSI_SENSE_NOT_READY:

            DebugPrint((DBG_IDE_DEVICE_ERROR,
                        "ATAPI: Device not ready\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;
            break;

        case SCSI_SENSE_MEDIUM_ERROR:

            DebugPrint((DBG_IDE_DEVICE_ERROR,
                        "ATAPI: Media error\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;
            break;

        case SCSI_SENSE_HARDWARE_ERROR:

            DebugPrint((DBG_IDE_DEVICE_ERROR,
                        "ATAPI: Hardware error\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;
            break;

        case SCSI_SENSE_ILLEGAL_REQUEST:

            DebugPrint((DBG_IDE_DEVICE_ERROR,
                        "ATAPI: Illegal request\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;
            break;

        case SCSI_SENSE_UNIT_ATTENTION:

            DebugPrint((DBG_IDE_DEVICE_ERROR,
                        "ATAPI: Unit attention\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;
            break;

        case SCSI_SENSE_DATA_PROTECT:

            DebugPrint((DBG_IDE_DEVICE_ERROR,
                        "ATAPI: Data protect\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;
            break;

        case SCSI_SENSE_BLANK_CHECK:

            DebugPrint((DBG_IDE_DEVICE_ERROR,
                        "ATAPI: Blank check\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;
            break;

        case SCSI_SENSE_ABORTED_COMMAND:
            DebugPrint((DBG_IDE_DEVICE_ERROR,
                        "Atapi: Command Aborted\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;
            break;

        default:

            DebugPrint((DBG_IDE_DEVICE_ERROR,
                        "ATAPI: Invalid sense information\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;
            break;
        }

    } else {

        scsiStatus = 0;
        //
        // Save errorByte,to be used by SCSIOP_REQUEST_SENSE.
        //

        deviceExtension->ReturningMediaStatus = errorByte;

        RtlZeroMemory(senseBuffer, sizeof(SENSE_DATA));

        if (errorByte & IDE_ERROR_MEDIA_CHANGE_REQ) {
            DebugPrint((DBG_IDE_DEVICE_ERROR,
                        "IDE: Media change\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;

            if (Srb->SenseInfoBuffer) {

                senseBuffer->ErrorCode = 0x70;
                senseBuffer->Valid     = 1;
                senseBuffer->AdditionalSenseLength = 0xb;
                senseBuffer->SenseKey =  SCSI_SENSE_UNIT_ATTENTION;
                senseBuffer->AdditionalSenseCode = SCSI_ADSENSE_OPERATOR_REQUEST;
                senseBuffer->AdditionalSenseCodeQualifier = SCSI_SENSEQ_MEDIUM_REMOVAL;

                srbStatus |= SRB_STATUS_AUTOSENSE_VALID;
            }

        } else if (errorByte & IDE_ERROR_COMMAND_ABORTED) {

            DebugPrint((DBG_IDE_DEVICE_ERROR, "IDE: Command abort\n"));

            scsiStatus = SCSISTAT_CHECK_CONDITION;

            if ((errorByte & IDE_ERROR_CRC_ERROR) &&
                (deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_USE_UDMA) &&
                SRB_USES_DMA(Srb)) {

                DebugPrint((1, "Srb 0x%x had a CRC error using UDMA\n", Srb));

                srbStatus = SRB_STATUS_PARITY_ERROR;

                if (Srb->SenseInfoBuffer) {

                    senseBuffer->ErrorCode = 0x70;
                    senseBuffer->Valid     = 1;
                    senseBuffer->AdditionalSenseLength = 0xb;
                    senseBuffer->SenseKey =  SCSI_SENSE_HARDWARE_ERROR;
                    senseBuffer->AdditionalSenseCode = 0x8;
                    senseBuffer->AdditionalSenseCodeQualifier = 0x3;

                    srbStatus |= SRB_STATUS_AUTOSENSE_VALID;
                }

                deviceExtension->ErrorCount++;

            } else {

                srbStatus = SRB_STATUS_ABORTED;

                if (Srb->SenseInfoBuffer) {

                    senseBuffer->ErrorCode = 0x70;
                    senseBuffer->Valid     = 1;
                    senseBuffer->AdditionalSenseLength = 0xb;
                    senseBuffer->SenseKey =  SCSI_SENSE_ABORTED_COMMAND;
                    senseBuffer->AdditionalSenseCode = 0;
                    senseBuffer->AdditionalSenseCodeQualifier = 0;

                    srbStatus |= SRB_STATUS_AUTOSENSE_VALID;
                }

                if (Srb->SrbFlags & SRB_FLAGS_UNSPECIFIED_DIRECTION) {

                    deviceExtension->ErrorCount++;
                }
            }

        } else if (errorByte & IDE_ERROR_END_OF_MEDIA) {

            DebugPrint((DBG_IDE_DEVICE_ERROR,
                        "IDE: End of media\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;

            if (Srb->SenseInfoBuffer) {

                senseBuffer->ErrorCode = 0x70;
                senseBuffer->Valid     = 1;
                senseBuffer->AdditionalSenseLength = 0xb;
                senseBuffer->SenseKey =  SCSI_SENSE_NOT_READY;
                senseBuffer->AdditionalSenseCode = SCSI_ADSENSE_NO_MEDIA_IN_DEVICE;
                senseBuffer->AdditionalSenseCodeQualifier = 0;

                srbStatus |= SRB_STATUS_AUTOSENSE_VALID;
            }
            if (!(deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_MEDIA_STATUS_ENABLED)) {
                deviceExtension->ErrorCount++;
            }

        } else if (errorByte & IDE_ERROR_ILLEGAL_LENGTH) {

            DebugPrint((DBG_IDE_DEVICE_ERROR,
                        "IDE: Illegal length\n"));
            srbStatus = SRB_STATUS_INVALID_REQUEST;

        } else if (errorByte & IDE_ERROR_BAD_BLOCK) {

            DebugPrint((DBG_IDE_DEVICE_ERROR,
                        "IDE: Bad block\n"));
            srbStatus = SRB_STATUS_ERROR;
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            if (Srb->SenseInfoBuffer) {

                senseBuffer->ErrorCode = 0x70;
                senseBuffer->Valid     = 1;
                senseBuffer->AdditionalSenseLength = 0xb;
                senseBuffer->SenseKey =  SCSI_SENSE_HARDWARE_ERROR;
                senseBuffer->AdditionalSenseCode = 0;
                senseBuffer->AdditionalSenseCodeQualifier = 0;

                srbStatus |= SRB_STATUS_AUTOSENSE_VALID;
            }

        } else if (errorByte & IDE_ERROR_ID_NOT_FOUND) {

            DebugPrint((DBG_IDE_DEVICE_ERROR,
                        "IDE: Id not found\n"));
            srbStatus = SRB_STATUS_ERROR;
            scsiStatus = SCSISTAT_CHECK_CONDITION;

            if (Srb->SenseInfoBuffer) {

                senseBuffer->ErrorCode = 0x70;
                senseBuffer->Valid     = 1;
                senseBuffer->AdditionalSenseLength = 0xb;
                senseBuffer->SenseKey =  SCSI_SENSE_ILLEGAL_REQUEST;
                senseBuffer->AdditionalSenseCode = SCSI_ADSENSE_ILLEGAL_BLOCK;
                senseBuffer->AdditionalSenseCodeQualifier = 0;

                srbStatus |= SRB_STATUS_AUTOSENSE_VALID;
            }

            deviceExtension->ErrorCount++;

        } else if (errorByte & IDE_ERROR_MEDIA_CHANGE) {

            DebugPrint((DBG_IDE_DEVICE_ERROR,
                        "IDE: Media change\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;

            if (Srb->SenseInfoBuffer) {

                senseBuffer->ErrorCode = 0x70;
                senseBuffer->Valid     = 1;
                senseBuffer->AdditionalSenseLength = 0xb;
                senseBuffer->SenseKey =  SCSI_SENSE_UNIT_ATTENTION;
                senseBuffer->AdditionalSenseCode = SCSI_ADSENSE_MEDIUM_CHANGED;
                senseBuffer->AdditionalSenseCodeQualifier = 0;

                srbStatus |= SRB_STATUS_AUTOSENSE_VALID;
            }

        } else if (errorByte & IDE_ERROR_DATA_ERROR) {

            DebugPrint((DBG_IDE_DEVICE_ERROR,
                        "IDE: Data error\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;

            if (!(deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_MEDIA_STATUS_ENABLED)) {
                deviceExtension->ErrorCount++;
            }

            //
            // Build sense buffer
            //

            if (Srb->SenseInfoBuffer) {

                senseBuffer->ErrorCode = 0x70;
                senseBuffer->Valid     = 1;
                senseBuffer->AdditionalSenseLength = 0xb;
                senseBuffer->SenseKey = (deviceExtension->
                                         DeviceFlags[Srb->TargetId] & DFLAGS_REMOVABLE_DRIVE)? SCSI_SENSE_DATA_PROTECT : SCSI_SENSE_MEDIUM_ERROR;
                senseBuffer->AdditionalSenseCode = 0;
                senseBuffer->AdditionalSenseCodeQualifier = 0;

                srbStatus |= SRB_STATUS_AUTOSENSE_VALID;
            }
        } else { // no sense info

            DebugPrint((DBG_IDE_DEVICE_ERROR,
                        "IdePort: No sense information\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;
        }

        if (senseBuffer->Valid == 1) {

            ULONG length = sizeof(SENSE_DATA);

            if (Srb->SenseInfoBufferLength < length ) {

               length = Srb->SenseInfoBufferLength;
            }

            ASSERT(length);
            ASSERT(Srb->SenseInfoBuffer);

            RtlCopyMemory(Srb->SenseInfoBuffer, (PVOID) senseBuffer, length);
        }

        if ((deviceExtension->ErrorCount >= MAX_ERRORS) &&
            (!(deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_USE_DMA))) {

            deviceExtension->MaximumBlockXfer[Srb->TargetId] = 0;

            DebugPrint((DBG_ALWAYS,
                        "MapError: Disabling 32-bit PIO and Multi-sector IOs\n"));

            if (deviceExtension->ErrorCount == MAX_ERRORS) {

                //
                // Log the error.
                //

                IdePortLogError( HwDeviceExtension,
                                 Srb,
                                 Srb->PathId,
                                 Srb->TargetId,
                                 Srb->Lun,
                                 SP_BAD_FW_WARNING,
                                 4);
            }

            //
            // Reprogram to not use Multi-sector.
            //

            for (i = 0; i < deviceExtension->MaxIdeDevice; i++) {
                UCHAR statusByte;

                if (deviceExtension->DeviceFlags[i] & DFLAGS_DEVICE_PRESENT &&
                    !(deviceExtension->DeviceFlags[i] & DFLAGS_ATAPI_DEVICE)) {

                    //
                    // Select the device.
                    //
                    SelectIdeDevice(baseIoAddress1, i, 0);

                    //
                    // Setup sector count to reflect the # of blocks.
                    //

                    IdePortOutPortByte(baseIoAddress1->BlockCount,
                                       0);

                    //
                    // Issue the command.
                    //

                    IdePortOutPortByte(baseIoAddress1->Command,
                                       IDE_COMMAND_SET_MULTIPLE);

                    //
                    // Wait for busy to drop.
                    //

                    WaitOnBaseBusy(baseIoAddress1,statusByte);

                    //
                    // Check for errors. Reset the value to 0 (disable MultiBlock) if the
                    // command was aborted.
                    //

                    if (statusByte & IDE_STATUS_ERROR) {

                        //
                        // Read the error register.
                        //

                        errorByte = IdePortInPortByte(baseIoAddress1->Error);

                        DebugPrint((DBG_ALWAYS,
                                    "AtapiHwInitialize: Error setting multiple mode. Status %x, error byte %x\n",
                                    statusByte,
                                    errorByte));
                        //
                        // Adjust the devExt. value, if necessary.
                        //

                        deviceExtension->MaximumBlockXfer[i] = 0;

                    }
                    deviceExtension->DeviceParameters[i].IdePioReadCommand      = IDE_COMMAND_READ;
                    deviceExtension->DeviceParameters[i].IdePioWriteCommand     = IDE_COMMAND_WRITE;

#ifdef ENABLE_48BIT_LBA
                    if (deviceExtension->DeviceFlags[i] & DFLAGS_48BIT_LBA) {
                        deviceExtension->DeviceParameters[i].IdePioReadCommandExt = IDE_COMMAND_READ_EXT;
                        deviceExtension->DeviceParameters[i].IdePioWriteCommandExt = IDE_COMMAND_WRITE_EXT;
                    }
#endif
                    deviceExtension->DeviceParameters[i].MaxBytePerPioInterrupt = 512;
                    deviceExtension->MaximumBlockXfer[i] = 0;
                }
            }
        }
    }


    //
    // Set SCSI status to indicate a check condition.
    //

    Srb->ScsiStatus = scsiStatus;

    return srbStatus;

} // end MapError()

NTSTATUS
AtapiSetTransferMode (
                     PHW_DEVICE_EXTENSION DeviceExtension,
                     ULONG                DeviceNumber,
                     UCHAR                ModeValue
                     )
{

    PIDE_REGISTERS_1    baseIoAddress1 = &DeviceExtension->BaseIoAddress1;
    UCHAR               ideStatus; 

    if (DeviceExtension->CurrentSrb) {
        DebugPrint ((DBG_ALWAYS, "DeviceExtension->CurrentSrb = 0x%x\n", DeviceExtension->CurrentSrb));
        ASSERT(DeviceExtension->CurrentSrb == NULL);
    }
    ASSERT (DeviceExtension->ExpectingInterrupt == FALSE);

    if (Is98LegacyIde(baseIoAddress1)) {

        if ( !EnhancedIdeSupport() ) {

            DebugPrint((1,"atapi: AtapiSetTransferMode -  not enhanced-ide.\n"));
            return STATUS_INVALID_DEVICE_REQUEST;
        }

        if (DeviceExtension->DeviceFlags[DeviceNumber] & DFLAGS_WD_MODE) {
            //
            // WD-Mode cd-rom can not set transfer mode.
            //

            DebugPrint((1,"atapi: AtapiSetTransferMode -  not enhanced-ide.\n"));
            return STATUS_INVALID_DEVICE_REQUEST;
        }
    }

    SelectIdeDevice(baseIoAddress1, DeviceNumber, 0);

    WaitOnBusy(baseIoAddress1, ideStatus);

    IdePortOutPortByte(
                      baseIoAddress1->Error,
                      IDE_SET_FEATURE_SET_TRANSFER_MODE
                      );

    IdePortOutPortByte(
                      baseIoAddress1->BlockCount,
                      ModeValue
                      );

    IdePortOutPortByte(
                      baseIoAddress1->Command,
                      IDE_COMMAND_SET_FEATURE
                      );

    WaitOnBusy(baseIoAddress1, ideStatus);

    if (ideStatus & (IDE_STATUS_BUSY | IDE_STATUS_ERROR)) {

        return STATUS_INVALID_DEVICE_REQUEST;

    } else {

        return STATUS_SUCCESS;
    }
}



VOID
AtapiProgramTransferMode (
                         PHW_DEVICE_EXTENSION DeviceExtension
                         )
{
    ULONG                       i;

    for (i=0; i<DeviceExtension->MaxIdeDevice; i++) {

        UCHAR ideCommand;
        ULONG pioModeStatus;
        ULONG dmaModeStatus;
        ULONG xferMode;

        if (!(DeviceExtension->DeviceFlags[i] & DFLAGS_DEVICE_PRESENT)) {

            continue;
        }

        DebugPrint((DBG_XFERMODE, "ATAPI: ProgramTransferMode device %x- TMSelected = 0x%x\n",
                    i,
                    DeviceExtension->DeviceParameters[i].TransferModeSelected));

        CLRMASK (DeviceExtension->DeviceFlags[i], DFLAGS_USE_DMA | DFLAGS_USE_UDMA);

        if (!DeviceExtension->NoPioSetTransferMode) {

            //
            // many old devices just don't support set transfer mode
            // they act unpredictably after receiving one
            // e.g. "SAMSUNG SCR-730 REV D-05" cdrom will start returning
            // no error on TEST_UNIT_READY even if it doesn't have a media
            // 
            // we are going to apply some magic code here!!
            // we would not set transfer mode if the device doesn't support
            // timing faster than mode2
            //
            GetHighestPIOTransferMode(DeviceExtension->DeviceParameters[i].TransferModeSelected, xferMode);

            if (xferMode > PIO2) {

                DebugPrint((DBG_XFERMODE, "ATAPI: device %x, setting PIOmode 0x%x\n",
                            i,
                            xferMode));

                ideCommand = IDE_SET_ADVANCE_PIO_MODE(xferMode-PIO0);

                pioModeStatus = AtapiSetTransferMode (
                                                     DeviceExtension,
                                                     i, 
                                                     ideCommand
                                                     );
                if (!NT_SUCCESS(pioModeStatus)) {

                    DebugPrint ((DBG_ALWAYS, 
                                 "ATAPI: Unable to set pio xfer mode %d for 0x%x device %d\n", 
                                 xferMode,
                                 DeviceExtension->BaseIoAddress1.RegistersBaseAddress,
                                 i));
                }
            }
        }

        //
        // Program DMA mode
        //
        GetHighestDMATransferMode(DeviceExtension->DeviceParameters[i].TransferModeSelected, xferMode);


        if (xferMode >= UDMA0) {

            ideCommand = IDE_SET_UDMA_MODE(xferMode-UDMA0);

        } else if (xferMode >= MWDMA0) {

            ideCommand = IDE_SET_MWDMA_MODE(xferMode-MWDMA0);

        } else if (xferMode >= SWDMA0) {

            ideCommand = IDE_SET_SWDMA_MODE(xferMode-SWDMA0);

        }

        //
        // Issue the set features command only if we support
        // any of the DMA modes
        //
        if (xferMode >= SWDMA0) {

            DebugPrint((DBG_XFERMODE, "ATAPI: device %x, setting DMAmode 0x%x\n",
                        i,
                        xferMode));

            dmaModeStatus = AtapiSetTransferMode (
                                                 DeviceExtension,
                                                 i, 
                                                 ideCommand
                                                 );
            if (NT_SUCCESS(dmaModeStatus)) {

                DeviceExtension->DeviceFlags[i] |= DFLAGS_USE_DMA;

                if (xferMode >= UDMA0) {
                    DeviceExtension->DeviceFlags[i] |= DFLAGS_USE_UDMA;
                }

            } else {

                DebugPrint ((DBG_ALWAYS, 
                             "ATAPI: Unable to set DMA mode %d for  0x%x device %d\n",
                             xferMode,
                             DeviceExtension->BaseIoAddress1.RegistersBaseAddress,
                             i));
            }
        }
    }
    return;
}



BOOLEAN
AtapiHwInitialize(
                 IN PVOID HwDeviceExtension,
                 IN UCHAR FlushCommand[MAX_IDE_DEVICE * MAX_IDE_LINE]
                 )

/*++

Routine Description:

Arguments:

    HwDeviceExtension - HBA miniport driver's adapter data storage

Return Value:

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

--*/

{
    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
    PIDE_REGISTERS_1     baseIoAddress;
    ULONG i;
    UCHAR statusByte, errorByte;

    baseIoAddress = &deviceExtension->BaseIoAddress1;

    for (i = 0; i < deviceExtension->MaxIdeDevice; i++) {
        if (deviceExtension->DeviceFlags[i] & DFLAGS_DEVICE_PRESENT) {

            //
            // Select device
            //
            SelectIdeDevice(baseIoAddress, i, 0);

            //
            // Make sure device is ready for any command
            //
            if (!(deviceExtension->DeviceFlags[i] & DFLAGS_ATAPI_DEVICE)) {

                WaitForDRDY(baseIoAddress, statusByte);
            }

            if (!(deviceExtension->DeviceFlags[i] & DFLAGS_ATAPI_DEVICE)) {

                //
                // Enable media status notification
                //

                IdeMediaStatus(TRUE,HwDeviceExtension,i);

                //
                // If supported, setup Multi-block transfers.
                //
                if (deviceExtension->MaximumBlockXfer[i]) {

                    //
                    // Select the device.
                    //
                    SelectIdeDevice(baseIoAddress, i, 0);

                    //
                    // Setup sector count to reflect the # of blocks.
                    //

                    IdePortOutPortByte(baseIoAddress->BlockCount,
                                       deviceExtension->MaximumBlockXfer[i]);

                    //
                    // Issue the command.
                    //

                    IdePortOutPortByte(baseIoAddress->Command,
                                       IDE_COMMAND_SET_MULTIPLE);

                    //
                    // Wait for busy to drop.
                    //

                    WaitOnBaseBusy(baseIoAddress,statusByte);

                    //
                    // Check for errors. Reset the value to 0 (disable MultiBlock) if the
                    // command was aborted.
                    //

                    if (statusByte & IDE_STATUS_ERROR) {

                        //
                        // Read the error register.
                        //

                        errorByte = IdePortInPortByte(baseIoAddress->Error);

                        DebugPrint((1,
                                    "AtapiHwInitialize: Error setting multiple mode. Status %x, error byte %x\n",
                                    statusByte,
                                    errorByte));
                        //
                        // Adjust the devExt. value, if necessary.
                        //

                        deviceExtension->MaximumBlockXfer[i] = 0;

                    } else {
                        DebugPrint((2,
                                    "AtapiHwInitialize: Using Multiblock on Device %d. Blocks / int - %d\n",
                                    i,
                                    deviceExtension->MaximumBlockXfer[i]));
                    }
                }
            }

            // IdeMediaStatus(TRUE,HwDeviceExtension,i);

            //
            // We need to get our device ready for action before
            // returning from this function
            //
            // According to the atapi spec 2.5 or 2.6, an atapi device
            // clears its status BSY bit when it is ready for atapi commands.
            // However, some devices (Panasonic SQ-TC500N) are still
            // not ready even when the status BSY is clear.  They don't react
            // to atapi commands.
            //
            // Since there is really no other indication that tells us
            // the drive is really ready for action.  We are going to check BSY
            // is clear and then just wait for an arbitrary amount of time!  At
            // least for the older ATAPI changers.
            //
            if (deviceExtension->DeviceFlags[i] & DFLAGS_ATAPI_DEVICE) {
                PIDE_REGISTERS_1     baseIoAddress1 = &deviceExtension->BaseIoAddress1;
                PIDE_REGISTERS_2     baseIoAddress2 = &deviceExtension->BaseIoAddress2;
                ULONG waitCount;

                // have to get out of the loop sometime!
                // 10000 * 100us = 1000,000us = 1000ms = 1s
                waitCount = 10000;
                GetStatus(baseIoAddress1, statusByte);
                while ((statusByte & IDE_STATUS_BUSY) && waitCount) {
                    //
                    // Wait for Busy to drop.
                    //
                    KeStallExecutionProcessor(100);
                    GetStatus(baseIoAddress1, statusByte);
                    waitCount--;
                }
            }
        }
    }

    AtapiProgramTransferMode (deviceExtension);

    InitDeviceParameters (HwDeviceExtension, FlushCommand);

    return TRUE;

} // end AtapiHwInitialize()


VOID
AtapiHwInitializeMultiLun (
                          IN PVOID HwDeviceExtension,
                          IN ULONG TargetId,
                          IN ULONG numSlot
                          )
{
    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;

    deviceExtension->DeviceFlags[TargetId] |= DFLAGS_MULTI_LUN_INITED;

    deviceExtension->LastLun[TargetId] = (numSlot == 0) ? 0 : (numSlot - 1);

    return;
}

#ifdef DRIVER_PARAMETER_REGISTRY_SUPPORT

ULONG
AtapiParseArgumentString(
                        IN PCHAR String,
                        IN PCHAR KeyWord
                        )

/*++

Routine Description:

    This routine will parse the string for a match on the keyword, then
    calculate the value for the keyword and return it to the caller.

Arguments:

    String - The ASCII string to parse.
    KeyWord - The keyword for the value desired.

Return Values:

    Zero if value not found
    Value converted from ASCII to binary.

--*/

{
    PCHAR cptr;
    PCHAR kptr;
    ULONG value;
    ULONG stringLength = 0;
    ULONG keyWordLength = 0;
    ULONG index;

    if (!String) {
        return 0;
    }
    if (!KeyWord) {
        return 0;
    }

    //
    // Calculate the string length and lower case all characters.
    //

    cptr = String;
    while (*cptr) {
        if (*cptr >= 'A' && *cptr <= 'Z') {
            *cptr = *cptr + ('a' - 'A');
        }
        cptr++;
        stringLength++;
    }

    //
    // Calculate the keyword length and lower case all characters.
    //

    cptr = KeyWord;
    while (*cptr) {

        if (*cptr >= 'A' && *cptr <= 'Z') {
            *cptr = *cptr + ('a' - 'A');
        }
        cptr++;
        keyWordLength++;
    }

    if (keyWordLength > stringLength) {

        //
        // Can't possibly have a match.
        //

        return 0;
    }

    //
    // Now setup and start the compare.
    //

    cptr = String;

    ContinueSearch:

    //
    // The input string may start with white space.  Skip it.
    //

    while (*cptr == ' ' || *cptr == '\t') {
        cptr++;
    }

    if (*cptr == '\0') {

        //
        // end of string.
        //

        return 0;
    }

    kptr = KeyWord;
    while (*cptr++ == *kptr++) {

        if (*(cptr - 1) == '\0') {

            //
            // end of string
            //

            return 0;
        }
    }

    if (*(kptr - 1) == '\0') {

        //
        // May have a match backup and check for blank or equals.
        //

        cptr--;
        while (*cptr == ' ' || *cptr == '\t') {
            cptr++;
        }

        //
        // Found a match.  Make sure there is an equals.
        //

        if (*cptr != '=') {

            //
            // Not a match so move to the next semicolon.
            //

            while (*cptr) {
                if (*cptr++ == ';') {
                    goto ContinueSearch;
                }
            }
            return 0;
        }

        //
        // Skip the equals sign.
        //

        cptr++;

        //
        // Skip white space.
        //

        while ((*cptr == ' ') || (*cptr == '\t')) {
            cptr++;
        }

        if (*cptr == '\0') {

            //
            // Early end of string, return not found
            //

            return 0;
        }

        if (*cptr == ';') {

            //
            // This isn't it either.
            //

            cptr++;
            goto ContinueSearch;
        }

        value = 0;
        if ((*cptr == '0') && (*(cptr + 1) == 'x')) {

            //
            // Value is in Hex.  Skip the "0x"
            //

            cptr += 2;
            for (index = 0; *(cptr + index); index++) {

                if (*(cptr + index) == ' ' ||
                    *(cptr + index) == '\t' ||
                    *(cptr + index) == ';') {
                    break;
                }

                if ((*(cptr + index) >= '0') && (*(cptr + index) <= '9')) {
                    value = (16 * value) + (*(cptr + index) - '0');
                } else {
                    if ((*(cptr + index) >= 'a') && (*(cptr + index) <= 'f')) {
                        value = (16 * value) + (*(cptr + index) - 'a' + 10);
                    } else {

                        //
                        // Syntax error, return not found.
                        //
                        return 0;
                    }
                }
            }
        } else {

            //
            // Value is in Decimal.
            //

            for (index = 0; *(cptr + index); index++) {

                if (*(cptr + index) == ' ' ||
                    *(cptr + index) == '\t' ||
                    *(cptr + index) == ';') {
                    break;
                }

                if ((*(cptr + index) >= '0') && (*(cptr + index) <= '9')) {
                    value = (10 * value) + (*(cptr + index) - '0');
                } else {

                    //
                    // Syntax error return not found.
                    //
                    return 0;
                }
            }
        }

        return value;
    } else {

        //
        // Not a match check for ';' to continue search.
        //

        while (*cptr) {
            if (*cptr++ == ';') {
                goto ContinueSearch;
            }
        }

        return 0;
    }
}
#endif

VOID
InitDeviceParameters (
                     IN PVOID HwDeviceExtension,
                     IN UCHAR FlushCommand[MAX_IDE_DEVICE * MAX_IDE_LINE]
                     )
{
    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
    ULONG deviceNumber;

    //
    // pick out the ATA or ATAPI r/w command we are going to use
    //
    for (deviceNumber = 0; deviceNumber < deviceExtension->MaxIdeDevice; deviceNumber++) {
        if (deviceExtension->DeviceFlags[deviceNumber] & DFLAGS_DEVICE_PRESENT) {

            DebugPrint ((DBG_BUSSCAN, "ATAPI: Base=0x%x Device %d is going to do ", deviceExtension->BaseIoAddress1.RegistersBaseAddress, deviceNumber));
            if (deviceExtension->DeviceFlags[deviceNumber] & DFLAGS_USE_DMA) {
                DebugPrint ((DBG_BUSSCAN, "DMA\n"));
            } else {
                DebugPrint ((DBG_BUSSCAN, "PIO\n"));
            }


            if (deviceExtension->DeviceFlags[deviceNumber] & DFLAGS_ATAPI_DEVICE) {

                deviceExtension->DeviceParameters[deviceNumber].MaxBytePerPioInterrupt = 512;

            } else {

                if (deviceExtension->MaximumBlockXfer[deviceNumber]) {

                    DebugPrint ((DBG_BUSSCAN, "ATAPI: ATA Device (%d) is going to do PIO Multiple\n", deviceNumber));

                    deviceExtension->DeviceParameters[deviceNumber].IdePioReadCommand = IDE_COMMAND_READ_MULTIPLE;
                    deviceExtension->DeviceParameters[deviceNumber].IdePioWriteCommand = IDE_COMMAND_WRITE_MULTIPLE;

#ifdef ENABLE_48BIT_LBA
                    if (deviceExtension->DeviceFlags[deviceNumber] & DFLAGS_48BIT_LBA) {
                        deviceExtension->DeviceParameters[deviceNumber].IdePioReadCommandExt = IDE_COMMAND_READ_MULTIPLE_EXT;
                        deviceExtension->DeviceParameters[deviceNumber].IdePioWriteCommandExt = IDE_COMMAND_WRITE_MULTIPLE_EXT;
                    }
#endif

                    deviceExtension->DeviceParameters[deviceNumber].MaxBytePerPioInterrupt =
                    deviceExtension->MaximumBlockXfer[deviceNumber] * 512;
                } else {

                    DebugPrint ((DBG_BUSSCAN, "ATAPI: ATA Device (%d) is going to do PIO Single\n", deviceNumber));

                    deviceExtension->DeviceParameters[deviceNumber].IdePioReadCommand = IDE_COMMAND_READ;
                    deviceExtension->DeviceParameters[deviceNumber].IdePioWriteCommand = IDE_COMMAND_WRITE;

#ifdef ENABLE_48BIT_LBA
                    if (deviceExtension->DeviceFlags[deviceNumber] & DFLAGS_48BIT_LBA) {
                        deviceExtension->DeviceParameters[deviceNumber].IdePioReadCommandExt = IDE_COMMAND_READ_EXT;
                        deviceExtension->DeviceParameters[deviceNumber].IdePioWriteCommandExt = IDE_COMMAND_WRITE_EXT;
                    }
#endif
                    deviceExtension->DeviceParameters[deviceNumber].MaxBytePerPioInterrupt = 512;
                }

                if (FlushCommand) {

                    deviceExtension->DeviceParameters[deviceNumber].IdeFlushCommand = FlushCommand[deviceNumber];

#ifdef ENABLE_48BIT_LBA
                    //
                    // if the flush command worked then we are going to assume that the flush command
                    // for the 48 bit LBA feature set is supported.
                    //
                    if (deviceExtension->DeviceFlags[deviceNumber] & DFLAGS_48BIT_LBA) {
                        deviceExtension->DeviceParameters[deviceNumber].IdeFlushCommandExt = IDE_COMMAND_FLUSH_CACHE_EXT;
                        deviceExtension->DeviceParameters[deviceNumber].IdeFlushCommand = IDE_COMMAND_NO_FLUSH;
                    }
#endif
                }
            }
        }
    }
}


ULONG
Atapi2Scsi(
          IN PHW_DEVICE_EXTENSION DeviceExtension,
          IN PSCSI_REQUEST_BLOCK Srb,
          IN char *DataBuffer,
          IN ULONG ByteCount
          )
/*++

Routine Description:

    Convert atapi cdb and mode sense data to scsi format

Arguments:

    Srb         - SCSI request block
    DataBuffer  - mode sense data
    ByteCount   - mode sense data length

Return Value:

    byte adjust

--*/
{
    ULONG bytesAdjust = 0;

    if (DeviceExtension->scsi2atapi) {

        if (Srb->Cdb[0] == ATAPI_MODE_SENSE) {

            ASSERT(FALSE);

        } else if (Srb->Cdb[0] == ATAPI_LS120_FORMAT_UNIT) {

            Srb->Cdb[0] = SCSIOP_FORMAT_UNIT;
        }

        RESTORE_ORIGINAL_CDB(DeviceExtension, Srb);

        DeviceExtension->scsi2atapi = FALSE;
    }
    return bytesAdjust;
}


VOID
AtapiCallBack(
             IN PVOID HwDeviceExtension
             )
{
    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
    PSCSI_REQUEST_BLOCK  srb = deviceExtension->CurrentSrb;
    PATAPI_REGISTERS_1   baseIoAddress1;
    UCHAR statusByte;

    //
    // If the last command was DSC restrictive, see if it's set. If so, the device is
    // ready for a new request. Otherwise, reset the timer and come back to here later.
    //

    if (srb && (!(deviceExtension->ExpectingInterrupt))) {
#if DBG
        if (!SRB_IS_RDP(srb)) {
            DebugPrint((1,
                        "AtapiCallBack: Invalid CDB marked as RDP - %x\n",
                        srb->Cdb[0]));
        }
#endif

        baseIoAddress1 = (PATAPI_REGISTERS_1)&deviceExtension->BaseIoAddress1;
        if (deviceExtension->RDP) {
            GetStatus(baseIoAddress1, statusByte);
            if (statusByte & IDE_STATUS_DSC) {

                IdePortNotification(IdeRequestComplete,
                                    deviceExtension,
                                    srb);

                //
                // Clear current SRB.
                //

                deviceExtension->CurrentSrb = NULL;
                deviceExtension->RDP = FALSE;

                //
                // Ask for next request.
                //

                IdePortNotification(IdeNextRequest,
                                    deviceExtension,
                                    NULL);


                return;

            } else {

                DebugPrint((3,
                            "AtapiCallBack: Requesting another timer for Op %x\n",
                            deviceExtension->CurrentSrb->Cdb[0]));

                IdePortNotification(IdeRequestTimerCall,
                                    HwDeviceExtension,
                                    AtapiCallBack,
                                    1000);
                return;
            }
        }
    }

    DebugPrint((2,
                "AtapiCallBack: Calling ISR directly due to BUSY\n"));
    AtapiInterrupt(HwDeviceExtension);

}

//#define IdeCrashDumpLogIsrStatus(hwExtension, isrStatus) hwExtension->CrashDumpIsrStatus[hwExtension->CrashDumpLogIndex]=isrStatus;

BOOLEAN
AtapiInterrupt(
              IN PVOID HwDeviceExtension
              )

/*++

Routine Description:

    This is the interrupt service routine for ATAPI IDE miniport driver.

Arguments:

    HwDeviceExtension - HBA miniport driver's adapter data storage

Return Value:

    TRUE if expecting an interrupt.

--*/

{
    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
    PSCSI_REQUEST_BLOCK srb              = deviceExtension->CurrentSrb;
    PATAPI_REGISTERS_1 baseIoAddress1;
    PATAPI_REGISTERS_2 baseIoAddress2;
    ULONG byteCount = 0, bytesThisInterrupt = 512;
    ULONG status;
    ULONG i;
    UCHAR statusByte,interruptReason;
    BOOLEAN commandComplete = FALSE;
    BOOLEAN atapiDev = FALSE;
    UCHAR dmaStatus;
    BOOLEAN fakeStatus = FALSE;
    BOOLEAN packetBasedSrb;
    BOOLEAN wdModeCdRom;
    BMSTATUS bmStatus=0;
    BOOLEAN dmaInProgress = FALSE;
    BOOLEAN alwaysClearBusMasterInterrupt;
    UCHAR savedCmd;
    BOOLEAN interruptCleared = FALSE;

    alwaysClearBusMasterInterrupt = deviceExtension->BusMasterInterface.AlwaysClearBusMasterInterrupt;


    //
    // if this flag is set, we must try to clear the busmaster interrupt
    // this is to overcome a bug in the cpq controller
    // this is set for native mode contollers
    //                                     
    if (alwaysClearBusMasterInterrupt) {
        if (deviceExtension->BusMasterInterface.BmStatus) {
            bmStatus = deviceExtension->BusMasterInterface.BmStatus (deviceExtension->BusMasterInterface.Context);
            if (bmStatus & BMSTATUS_INTERRUPT) {
                deviceExtension->BusMasterInterface.BmDisarm (deviceExtension->BusMasterInterface.Context);

                interruptCleared = TRUE;
            }
        }
    }


    if (srb) {

        baseIoAddress1 =    (PATAPI_REGISTERS_1)&deviceExtension->BaseIoAddress1;
        baseIoAddress2 =    (PATAPI_REGISTERS_2)&deviceExtension->BaseIoAddress2;
    } else {
        DebugPrint((1,
                    "AtapiInterrupt: CurrentSrb is NULL.  Bogus Interrupt\n"));
        if (deviceExtension->InterruptMode == LevelSensitive) {
            if (deviceExtension->BaseIoAddress1.RegistersBaseAddress != NULL) {
                baseIoAddress1 = (PATAPI_REGISTERS_1)&deviceExtension->BaseIoAddress1;
                GetBaseStatus(baseIoAddress1, statusByte);
                /*
                GetSelectedIdeDevice(baseIoAddress1, savedCmd);
                SelectIdeDevice(baseIoAddress1, 0, 0);
                GetBaseStatus(baseIoAddress1, statusByte);
                SelectIdeDevice(baseIoAddress1, 1, 0);
                GetBaseStatus(baseIoAddress1, statusByte);
                ReSelectIdeDevice(baseIoAddress1, savedCmd);
                */
            }
        }

        return interruptCleared;
    }

    if (!(deviceExtension->ExpectingInterrupt)) {

        DebugPrint((1,
                    "AtapiInterrupt: Unexpected interrupt.\n"));

        return interruptCleared;
    }

    if (!alwaysClearBusMasterInterrupt) {
        if (deviceExtension->BusMasterInterface.BmStatus) {
            bmStatus = deviceExtension->BusMasterInterface.BmStatus (deviceExtension->BusMasterInterface.Context);
            if (bmStatus & BMSTATUS_INTERRUPT) {
                deviceExtension->BusMasterInterface.BmDisarm (deviceExtension->BusMasterInterface.Context);
            }
        }
    }

    //
    // For SiS IDE Controller, we have to read the bm status register first
    //
    if (deviceExtension->DMAInProgress) {

        // PCI Busmaster IDE Controller spec defines a bit in its status
        // register which indicates pending interrupt.  However,
        // CMD 646 (maybe some other one, too) doesn't always do that if
        // the interrupt is from a atapi device.  (strange, but true!)
        // Since we can look at this interrupt bit only if we are sharing
        // interrupt, we will do just that

        //
        // Doesn't look like it is our interrupt
        // If we are called from crashdmp (polling mode) then prociess the interrupt
        // even if the bit is not set. It is checked in the crashdmp routine.
        //
        if (!(bmStatus & BMSTATUS_INTERRUPT) && 
            !(deviceExtension->DriverMustPoll)) {
            DebugPrint((1, "No BusMaster Interrupt\n"));

            ASSERT(interruptCleared == FALSE);
            return FALSE;
        }

        dmaInProgress = deviceExtension->DMAInProgress;
        deviceExtension->DMAInProgress = FALSE;

        if (deviceExtension->BusMasterInterface.IgnoreActiveBitForAtaDevice) {
            if (!(deviceExtension->DeviceFlags[srb->TargetId] & DFLAGS_ATAPI_DEVICE)) {
                CLRMASK (bmStatus, BMSTATUS_NOT_REACH_END_OF_TRANSFER);
            }
        }
    }

    //
    // should we check for the interrupt bit for PIO transfers?
    //

    //
    // Select IDE line(Primary or Secondary).
    //
    SelectIdeLine(baseIoAddress1, srb->TargetId >> 1);

    //
    // Clear interrupt by reading status.
    //
    GetBaseStatus(baseIoAddress1, statusByte);

#ifdef ENABLE_ATAPI_VERIFIER
    if (ViIdeGenerateDmaTimeout(deviceExtension, dmaInProgress)) {
        deviceExtension->ExpectingInterrupt = FALSE;
        return TRUE;
    }
#endif

    //
    // Log the bus master status
    //
    if (!deviceExtension->DriverMustPoll) {
        IdeLogBmStatus(srb, bmStatus);
    }

    //IdeCrashDumpLogIsrStatus(deviceExtension, bmStatus);
    //
    // check the type of srb we have
    //
    if (deviceExtension->DeviceFlags[srb->TargetId] & DFLAGS_ATAPI_DEVICE) {

        packetBasedSrb = TRUE;

    } else {

        packetBasedSrb = FALSE;
    }


    if ((srb->Function == SRB_FUNCTION_ATA_PASS_THROUGH) ||
        (srb->Function == SRB_FUNCTION_ATA_POWER_PASS_THROUGH) ||
        (srb->Function == SRB_FUNCTION_ATA_PASS_THROUGH_EX)) {

        PIDEREGS             pIdeReg;

        packetBasedSrb = FALSE;

        if (srb->Function == SRB_FUNCTION_ATA_PASS_THROUGH_EX) {

            pIdeReg = (PIDEREGS) srb->Cdb;

        } else {

            PATA_PASS_THROUGH    ataPassThroughData;

            ataPassThroughData = srb->DataBuffer;
            pIdeReg            = &ataPassThroughData->IdeReg;
        }

        //
        // if the last command we issued was a SLEEP command,
        // the device interface (task registers) is invalid.
        // In order to complete the interrupt, will fake the 
        // a good status
        //
        if (pIdeReg->bCommandReg == IDE_COMMAND_SLEEP) {

            fakeStatus = TRUE;
        }

    }

    if (fakeStatus) {

        statusByte = IDE_STATUS_IDLE;
    }

    DebugPrint((1,
                "AtapiInterrupt: Entered with status (%x)\n",
                statusByte));


    if (statusByte & IDE_STATUS_BUSY) {

        if (deviceExtension->DriverMustPoll) {

            //
            // Crashdump is polling and we got caught with busy asserted.
            // Just go away, and we will be polled again shortly.
            //

            DebugPrint((1,
                        "AtapiInterrupt: Hit status=0x%x while polling during crashdump.\n", 
                        statusByte
                       ));

            deviceExtension->DMAInProgress = TRUE;
            return TRUE;
        }

        if (dmaInProgress) {

            //
            // this is really bad since we already disabled
            // dma at this point, but the device is still busy
            // can't really recover. just return from now.  
            // the timeout code will kick in and save the world
            //

            DebugPrint((DBG_ALWAYS,
                        "AtapiInterrupt: End of DMA transfer but device is still BUSY.  status = 0x%x\n", 
                        statusByte));

            //
            // we are not expecting interrupt anymore. Clear the flag.
            //
            deviceExtension->ExpectingInterrupt = FALSE;
            return interruptCleared;
        }

        //
        // Ensure BUSY is non-asserted.
        //

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

            GetBaseStatus(baseIoAddress1, statusByte);
            if (!(statusByte & IDE_STATUS_BUSY)) {
                break;
            }

        }

        if (i == 10) {

            DebugPrint((2,
                        "AtapiInterrupt: BUSY on entry. Status %x, Base IO %x\n",
                        statusByte,
                        baseIoAddress1));

            IdePortNotification(IdeRequestTimerCall,
                                HwDeviceExtension,
                                AtapiCallBack,
                                500);

            return interruptCleared;
        }
    }

    //
    // Check for error conditions.
    //

    if (statusByte & IDE_STATUS_ERROR) {

        if (srb->Cdb[0] != SCSIOP_REQUEST_SENSE) {

            //
            // Fail this request.
            //

            status = SRB_STATUS_ERROR;
            goto CompleteRequest;
        }
    }

    wdModeCdRom = FALSE;

    if (Is98LegacyIde(baseIoAddress1)) {

        if (deviceExtension->DeviceFlags[srb->TargetId] & DFLAGS_WD_MODE) {
            if (deviceExtension->DeviceFlags[srb->TargetId] & DFLAGS_ATAPI_DEVICE) {

                wdModeCdRom = TRUE;

            } else {

                status = SRB_STATUS_ERROR;
                goto CompleteRequest;
            }
        }
    }

    //
    // check reason for this interrupt.
    //
    if (packetBasedSrb && !wdModeCdRom) {

        interruptReason = (IdePortInPortByte(baseIoAddress1->InterruptReason) & 0x3);
        atapiDev = TRUE;
        bytesThisInterrupt = 512;

        if (dmaInProgress) {

            if (interruptReason != 0x3) {

                //
                // the device causes an interrupt in the middle of a
                // dma transfer!  bad bad bad device!
                // do nothing and just return.  this will get translated
                // to a timeout and we will retry.
                //
                DebugPrint((1, 
                            "Interrupt during DMA transfer, reason %x != 0x3\n", 
                            interruptReason
                           ));

                deviceExtension->ExpectingInterrupt = FALSE;

                return interruptCleared;
            }
        }

    } else {

        if (dmaInProgress) {

            interruptReason = 0x3;

        } else if (statusByte & IDE_STATUS_DRQ) {

            if (deviceExtension->MaximumBlockXfer[srb->TargetId]) {
                bytesThisInterrupt = 512 * deviceExtension->MaximumBlockXfer[srb->TargetId];

            }

            if (srb->SrbFlags & SRB_FLAGS_DATA_IN) {

                interruptReason =  0x2;

            } else if (srb->SrbFlags & SRB_FLAGS_DATA_OUT) {
                interruptReason = 0x0;

            } else {
                status = SRB_STATUS_ERROR;
                goto CompleteRequest;
            }

        } else if (statusByte & IDE_STATUS_BUSY) {

            ASSERT(interruptCleared == FALSE);
            return FALSE;

        } else {

            if (deviceExtension->BytesLeft && (!Is98LegacyIde(baseIoAddress1))) {

                //
                // We should return interruptCleared. But this is set based on
                // the bus master status bits. For non dma operations, we should not
                // rely on this. This code path should be revisited and the correct
                // return value should be determined. 
                //
                return interruptCleared;

            } else {

                //
                // Command complete - verify, write, or the SMART enable/disable.
                //
                // Also get_media_status

                interruptReason = 0x3;
            }
        }
    }

    if (interruptReason == 0x1 && (statusByte & IDE_STATUS_DRQ)) {

        //
        // Write the packet.
        //

        DebugPrint((2,
                    "AtapiInterrupt: Writing Atapi packet.\n"));

        //
        // Send CDB to device.
        //

        WriteBuffer(baseIoAddress1,
                    (PUSHORT)srb->Cdb,
                    6);

        if (SRB_USES_DMA(srb)) {
            deviceExtension->DMAInProgress = TRUE;
            deviceExtension->BusMasterInterface.BmArm (deviceExtension->BusMasterInterface.Context);
        }

        return interruptCleared;

    } else if (interruptReason == 0x0 && (statusByte & IDE_STATUS_DRQ)) {

        //
        // Write the data.
        //
        if (packetBasedSrb) {

            //
            // Pick up bytes to transfer and convert to words.
            //

            byteCount =
            IdePortInPortByte(baseIoAddress1->ByteCountLow);

            byteCount |=
            IdePortInPortByte(baseIoAddress1->ByteCountHigh) << 8;

            if (byteCount != deviceExtension->BytesLeft) {
                DebugPrint((3,
                            "AtapiInterrupt: %d bytes requested; %d bytes xferred\n",
                            deviceExtension->BytesLeft,
                            byteCount));
            }

            //
            // Verify this makes sense.
            //

            if (byteCount > deviceExtension->BytesLeft) {
                byteCount = deviceExtension->BytesLeft;
            }

        } else {

            //
            // IDE path. Check if words left is at least 256.
            //

            if (deviceExtension->BytesLeft < bytesThisInterrupt) {

                //
                // Transfer only words requested.
                //

                byteCount = deviceExtension->BytesLeft;

            } else {

                //
                // Transfer next block.
                //

                byteCount = bytesThisInterrupt;
            }
        }

        //
        // Ensure that this is a write command.
        //

        if (srb->SrbFlags & SRB_FLAGS_DATA_OUT) {

            DebugPrint((3,
                        "AtapiInterrupt: Write interrupt\n"));

            WaitOnBusy(baseIoAddress1,statusByte);

            WriteBuffer(baseIoAddress1,
                        (PUSHORT)deviceExtension->DataBuffer,
                        byteCount / sizeof(USHORT));

            if (byteCount & 1) {

                //
                // grab the last byte
                //
                IdePortOutPortByte(
                                  (PUCHAR)(baseIoAddress1->Data), 
                                  deviceExtension->DataBuffer[byteCount - 1]
                                  );
            }

        } else {

            DebugPrint((1,
                        "AtapiInterrupt: Int reason %x, but srb is for a write %x.\n",
                        interruptReason,
                        srb));

            //
            // Fail this request.
            //

            status = SRB_STATUS_ERROR;
            goto CompleteRequest;
        }


        //
        // Advance data buffer pointer and bytes left.
        //

        deviceExtension->DataBuffer += byteCount;
        deviceExtension->BytesLeft -= byteCount;

        return interruptCleared;

    } else if (interruptReason == 0x2 && (statusByte & IDE_STATUS_DRQ)) {

        if (packetBasedSrb) {

            //
            // Pick up bytes to transfer
            //

            byteCount =
            IdePortInPortByte(baseIoAddress1->ByteCountLow);

            byteCount |=
            IdePortInPortByte(baseIoAddress1->ByteCountHigh) << 8;

            if (byteCount != deviceExtension->BytesLeft) {
                DebugPrint((3,
                            "AtapiInterrupt: %d bytes requested; %d bytes xferred\n",
                            deviceExtension->BytesLeft,
                            byteCount));
            }

            //
            // Verify this makes sense.
            //

            if (byteCount > deviceExtension->BytesLeft) {
                byteCount = deviceExtension->BytesLeft;
            }

        } else {

            //
            // Check if words left is at least 256.
            //

            if (deviceExtension->BytesLeft < bytesThisInterrupt) {

                //
                // Transfer only words requested.
                //

                byteCount = deviceExtension->BytesLeft;

            } else {

                //
                // Transfer next block.
                //

                byteCount = bytesThisInterrupt;
            }
        }

        //
        // Ensure that this is a read command.
        //

        if (srb->SrbFlags & SRB_FLAGS_DATA_IN) {

            DebugPrint((3,
                        "AtapiInterrupt: Read interrupt\n"));

            WaitOnBusy(baseIoAddress1,statusByte);

            ReadBuffer(baseIoAddress1,
                       (PUSHORT)deviceExtension->DataBuffer,
                       byteCount / sizeof(USHORT));

            if (byteCount & 1) {

                //
                // grab the last byte
                //
                deviceExtension->DataBuffer[byteCount - 1] = IdePortInPortByte((PUCHAR)(baseIoAddress1->Data));
            }

        } else {

            DebugPrint((1,
                        "AtapiInterrupt: Int reason %x, but srb is for a read %x.\n",
                        interruptReason,
                        srb));

            //
            // Fail this request.
            //

            status = SRB_STATUS_ERROR;
            goto CompleteRequest;
        }

        //
        // Translate ATAPI data back to SCSI data if needed
        //
        if (deviceExtension->scsi2atapi) {

            //
            //convert and adjust the wordCount
            //
            byteCount -= Atapi2Scsi(
                                   deviceExtension, 
                                   srb, 
                                   deviceExtension->DataBuffer,
                                   byteCount 
                                   );
        }

        //
        // Advance data buffer pointer and bytes left.
        //

        deviceExtension->DataBuffer += byteCount;
        deviceExtension->BytesLeft -= byteCount;

        //
        // Check for read command complete.
        //

        if (deviceExtension->BytesLeft == 0) {

            if (packetBasedSrb) {

                //
                // Work around to make many atapi devices return correct sector size
                // of 2048. Also certain devices will have sector count == 0x00, check
                // for that also.
                //
                if (!(deviceExtension->DeviceFlags[srb->TargetId] & DFLAGS_MULTI_LUN_INITED)) {

                    if ((srb->Cdb[0] == 0x25) &&
                        ((deviceExtension->IdentifyData[srb->TargetId].GeneralConfiguration >> 8) & 0x1f) == 0x05) {

                        deviceExtension->DataBuffer -= byteCount;
                        if (deviceExtension->DataBuffer[0] == 0x00) {

                            *((ULONG *) &(deviceExtension->DataBuffer[0])) = 0xFFFFFF7F;

                        }

                        *((ULONG *) &(deviceExtension->DataBuffer[2])) = 0x00080000;
                        deviceExtension->DataBuffer += byteCount;
                    }
                }
            } else {

                //
                // Completion for IDE drives.
                //


                if (deviceExtension->BytesLeft) {

                    status = SRB_STATUS_DATA_OVERRUN;

                } else {

                    status = SRB_STATUS_SUCCESS;

                }

                goto CompleteRequest;

            }
        }

        return interruptCleared;

    } else if (interruptReason == 0x3) { // && !(statusByte & IDE_STATUS_DRQ)) {

        if (dmaInProgress) {

            deviceExtension->BytesLeft = 0;

            ASSERT (interruptReason == 3);

            //
            // bmStatus is initalized eariler.
            //
            if (!BMSTATUS_SUCCESS(bmStatus)) {

                if (bmStatus & BMSTATUS_ERROR_TRANSFER) {

                    status = SRB_STATUS_ERROR;
                }

                if (bmStatus & BMSTATUS_NOT_REACH_END_OF_TRANSFER) {

                    status = SRB_STATUS_DATA_OVERRUN;
                }

            } else {

                status = SRB_STATUS_SUCCESS;
            }

        } else {

            //
            // Command complete.
            //

            if (deviceExtension->BytesLeft) {

                status = SRB_STATUS_DATA_OVERRUN;

            } else {

                status = SRB_STATUS_SUCCESS;
            }
        }

        CompleteRequest:

        if (status == SRB_STATUS_ERROR) {

            DebugPrint ((1, 
                         "AtapiInterrupt: last command return status byte = 0x%x and error byte = 0x%x\n", 
                         statusByte, 
                         IdePortInPortByte(baseIoAddress1->Error)));

            if (deviceExtension->scsi2atapi) {

                RESTORE_ORIGINAL_CDB(deviceExtension, srb);

                deviceExtension->scsi2atapi = FALSE;

            }
            //
            // Map error to specific SRB status and handle request sense.
            //
            if ((srb->Function == SRB_FUNCTION_FLUSH) ||
                (srb->Function == SRB_FUNCTION_SHUTDOWN)) {

                //
                // return status success even if a flush fails
                //
                status = SRB_STATUS_SUCCESS;
            } else {

                //
                // log only the error that is caused by normal reuqest that
                // fails
                //
                if ((srb->Function != SRB_FUNCTION_ATA_PASS_THROUGH) &&
                    (srb->Function != SRB_FUNCTION_ATA_POWER_PASS_THROUGH) &&
                    (srb->Function != SRB_FUNCTION_ATA_PASS_THROUGH_EX)) {

                    status = MapError(deviceExtension,
                                      srb);
                }
            }


            deviceExtension->RDP = FALSE;

#if DBG
//#define ATAPI_RANDOM_RW_ERROR_FREQUENCY    50
    #if ATAPI_RANDOM_RW_ERROR_FREQUENCY

        } else if (status == SRB_STATUS_SUCCESS) {

            static ULONG _____RWCount = 0;

            if ((srb->Cdb[0] == SCSIOP_READ) || (srb->Cdb[0] == SCSIOP_WRITE)) {

                _____RWCount++;

//                if (baseIoAddress1 == (PATAPI_REGISTERS_1)0x170) {
                {

                    if ((_____RWCount % ATAPI_RANDOM_RW_ERROR_FREQUENCY) == 0) {

                        DebugPrint ((1, "ATAPI: Forcing R/W error\n"));

                        srb->SrbStatus = SRB_STATUS_ERROR;
                        srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
                        if (srb->SenseInfoBuffer) {

                            PSENSE_DATA  senseBuffer = (PSENSE_DATA)srb->SenseInfoBuffer;

                            senseBuffer->ErrorCode = 0x70;
                            senseBuffer->Valid     = 1;
                            senseBuffer->AdditionalSenseLength = 0xb;
                            senseBuffer->SenseKey =  SCSI_SENSE_HARDWARE_ERROR;
                            senseBuffer->AdditionalSenseCode = 0;
                            senseBuffer->AdditionalSenseCodeQualifier = 0;

                            srb->SrbStatus |= SRB_STATUS_AUTOSENSE_VALID;
                        }
                        status = srb->SrbStatus;
                    }
                }
            }

    #endif // DBG
#endif // ATAPI_GENERATE_RANDOM_RW_ERROR

        } else {

            //
            // Wait for busy to drop.
            //

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

                if (fakeStatus) {

                    statusByte = IDE_STATUS_IDLE;
                } else {

                    GetStatus(baseIoAddress1,statusByte);
                }
                if (!(statusByte & IDE_STATUS_BUSY)) {
                    break;
                }
                KeStallExecutionProcessor(500);
            }

            if (i == 60) {

                //
                // reset the controller.
                //

                DebugPrint((0,
                            "AtapiInterrupt: Resetting due to BSY still up - %x. Base Io %x\n",
                            statusByte,
                            baseIoAddress1));

                if (deviceExtension->DriverMustPoll) {

                    //
                    // When we are polling, no dpc gets enqueued. 
                    // Try a quick reset...
                    //
                    //AtapiSyncResetController (HwDeviceExtension,srb->PathId);
                    status = SRB_STATUS_BUS_RESET;

                } else {

                    //
                    // Reset the controller in the completion DPC
                    //
                    IdePortNotification(IdeResetRequest,
                                        deviceExtension,
                                        NULL);

                    return interruptCleared;
                }

            }

            //
            // Check to see if DRQ is still up.
            //

            if (statusByte & IDE_STATUS_DRQ) {

                for (i = 0; i < 500; i++) {
                    GetStatus(baseIoAddress1,statusByte);
                    if (!(statusByte & IDE_STATUS_DRQ)) {
                        break;
                    }
                    KeStallExecutionProcessor(100);

                }

                if (i == 500) {

                    //
                    // reset the controller.
                    //
                    DebugPrint((0,
                                "AtapiInterrupt: Resetting due to DRQ still up - %x\n",
                                statusByte));

                    if (deviceExtension->DriverMustPoll) {

                        //
                        // When we are polling, no dpc gets enqueued. 
                        // Try a quick reset...
                        //
                        //AtapiSyncResetController (HwDeviceExtension,srb->PathId);
                        status = SRB_STATUS_BUS_RESET;

                    } else {

                        //
                        // Reset the controller in the completion DPC
                        //
                        IdePortNotification(IdeResetRequest,
                                            deviceExtension,
                                            NULL);
                        return interruptCleared;
                    }

                }

            }
        }


        //
        // Clear interrupt expecting and dmaInProgress flag.
        //

        deviceExtension->ExpectingInterrupt = FALSE;

        //
        // Sanity check that there is a current request.
        //

        if (srb != NULL) {

            //
            // Set status in SRB.
            //

            srb->SrbStatus = (UCHAR)status;

            //
            // Check for underflow.
            //

            if (deviceExtension->BytesLeft) {

                //
                // Subtract out residual words and update if filemark hit,
                // setmark hit , end of data, end of media...
                //

                if (!(deviceExtension->DeviceFlags[srb->TargetId] & DFLAGS_TAPE_DEVICE)) {

                    if (status == SRB_STATUS_DATA_OVERRUN) {
                        srb->DataTransferLength -= deviceExtension->BytesLeft;
                    } else {
                        srb->DataTransferLength = 0;
                    }
                } else {
                    srb->DataTransferLength -= deviceExtension->BytesLeft;
                }
            }

            if ((srb->Function == SRB_FUNCTION_ATA_PASS_THROUGH) ||
                (srb->Function == SRB_FUNCTION_ATA_POWER_PASS_THROUGH)) {

                PATA_PASS_THROUGH ataPassThroughData = srb->DataBuffer;

                AtapiTaskRegisterSnapshot ((PIDE_REGISTERS_1)baseIoAddress1, &ataPassThroughData->IdeReg);

            } else if (deviceExtension->CurrentSrb->Function == SRB_FUNCTION_ATA_PASS_THROUGH_EX) {

                PIDEREGS pIdeReg = (PIDEREGS) srb->Cdb;

                AtapiTaskRegisterSnapshot((PIDE_REGISTERS_1)baseIoAddress1, pIdeReg);
            }

            if (srb->Function != SRB_FUNCTION_IO_CONTROL) {

                //
                // Indicate command complete.
                //

                if (!(deviceExtension->RDP) &&
                    !(deviceExtension->DriverMustPoll)) {
                    IdePortNotification(IdeRequestComplete,
                                        deviceExtension,
                                        srb);

                }
            } else {

                PSENDCMDOUTPARAMS cmdOutParameters = (PSENDCMDOUTPARAMS)(((PUCHAR)srb->DataBuffer) + sizeof(SRB_IO_CONTROL));
                UCHAR             error = 0;

                if (status != SRB_STATUS_SUCCESS) {
                    error = IdePortInPortByte(baseIoAddress1->Error);
                }

                //
                // Build the SMART status block depending upon the completion status.
                //

                cmdOutParameters->cBufferSize = byteCount;
                cmdOutParameters->DriverStatus.bDriverError = (error) ? SMART_IDE_ERROR : 0;
                cmdOutParameters->DriverStatus.bIDEError = error;

                //
                // If the sub-command is return smart status, jam the value from cylinder low and high, into the
                // data buffer.
                //

                if (deviceExtension->SmartCommand == RETURN_SMART_STATUS) {
                    cmdOutParameters->bBuffer[0] = RETURN_SMART_STATUS;
                    cmdOutParameters->bBuffer[1] = IdePortInPortByte(baseIoAddress1->InterruptReason);
                    cmdOutParameters->bBuffer[2] = IdePortInPortByte(baseIoAddress1->Unused1);
                    cmdOutParameters->bBuffer[3] = IdePortInPortByte(baseIoAddress1->ByteCountLow);
                    cmdOutParameters->bBuffer[4] = IdePortInPortByte(baseIoAddress1->ByteCountHigh);
                    cmdOutParameters->bBuffer[5] = IdePortInPortByte(baseIoAddress1->DriveSelect);
                    cmdOutParameters->bBuffer[6] = SMART_CMD;
                    cmdOutParameters->cBufferSize = 8;
                }

                //
                // Indicate command complete.
                //

                IdePortNotification(IdeRequestComplete,
                                    deviceExtension,
                                    srb);

            }

        } else {

            DebugPrint((1,
                        "AtapiInterrupt: No SRB!\n"));
        }

        //
        // Indicate ready for next request.
        //

        if (!(deviceExtension->RDP)) {

            //
            // Clear current SRB.
            //

            deviceExtension->CurrentSrb = NULL;

            if (!deviceExtension->DriverMustPoll) {
                IdePortNotification(IdeNextRequest,
                                    deviceExtension,
                                    NULL);
            }
        } else {

            ASSERT(!deviceExtension->DriverMustPoll);
            IdePortNotification(IdeRequestTimerCall,
                                HwDeviceExtension,
                                AtapiCallBack,
                                2000);
        }

        return interruptCleared;

    } else {

        //
        // Unexpected int.
        //

        DebugPrint((0,
                    "AtapiInterrupt: Unexpected interrupt. InterruptReason %x. Status %x.\n",
                    interruptReason,
                    statusByte));

        ASSERT(interruptCleared == FALSE);
        return interruptCleared;
    }

    return interruptCleared;

} // end AtapiInterrupt()


ULONG
IdeSendSmartCommand(
                   IN PVOID HwDeviceExtension,
                   IN PSCSI_REQUEST_BLOCK Srb
                   )

/*++

Routine Description:

    This routine handles SMART enable, disable, read attributes and threshold commands.

Arguments:

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

Return Value:

    SRB status

--*/

{
    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
    PIDE_REGISTERS_1     baseIoAddress1  = &deviceExtension->BaseIoAddress1;
    PIDE_REGISTERS_2     baseIoAddress2  = &deviceExtension->BaseIoAddress2;
    PSENDCMDOUTPARAMS    cmdOutParameters = (PSENDCMDOUTPARAMS)(((PUCHAR)Srb->DataBuffer) + sizeof(SRB_IO_CONTROL));
    PSENDCMDINPARAMS      pCmdInParameters = (PSENDCMDINPARAMS)(((PUCHAR)Srb->DataBuffer) + sizeof(SRB_IO_CONTROL));
    SENDCMDINPARAMS      cmdInParameters = *(PSENDCMDINPARAMS)(((PUCHAR)Srb->DataBuffer) + sizeof(SRB_IO_CONTROL));
    PIDEREGS             regs = &cmdInParameters.irDriveRegs;
    ULONG                i;
    UCHAR                statusByte,targetId;
    ULONG                byteCount;


    if (cmdInParameters.irDriveRegs.bCommandReg == SMART_CMD) {

        targetId = cmdInParameters.bDriveNumber;

        //TODO optimize this check

        if ((!(deviceExtension->DeviceFlags[targetId] & DFLAGS_DEVICE_PRESENT)) ||
            (deviceExtension->DeviceFlags[targetId] & DFLAGS_ATAPI_DEVICE)) {

            return SRB_STATUS_SELECTION_TIMEOUT;
        }

        deviceExtension->SmartCommand = cmdInParameters.irDriveRegs.bFeaturesReg;

        //
        // fudge the target Id field in the srb
        // atapi interrupt will use this field.
        //
        Srb->TargetId = targetId;

        //
        // Determine which of the commands to carry out.
        //

#ifdef ENABLE_SMARTLOG_SUPPORT
        if ((cmdInParameters.irDriveRegs.bFeaturesReg == READ_ATTRIBUTES) ||
            (cmdInParameters.irDriveRegs.bFeaturesReg == READ_THRESHOLDS) ||
            (cmdInParameters.irDriveRegs.bFeaturesReg == SMART_READ_LOG)) {
#else
        if ((cmdInParameters.irDriveRegs.bFeaturesReg == READ_ATTRIBUTES) ||
            (cmdInParameters.irDriveRegs.bFeaturesReg == READ_THRESHOLDS)) {
#endif

            ULONG dataLength = 0;

            SelectIdeLine(baseIoAddress1, targetId >> 1);

            WaitOnBusy(baseIoAddress1,statusByte);

            if (statusByte & IDE_STATUS_BUSY) {
                DebugPrint((1,
                            "IdeSendSmartCommand: Returning BUSY status\n"));
                return SRB_STATUS_BUSY;
            }

#ifdef ENABLE_SMARTLOG_SUPPORT
            if (cmdInParameters.irDriveRegs.bFeaturesReg == SMART_READ_LOG) {

                dataLength = cmdInParameters.irDriveRegs.bSectorCountReg* SMART_LOG_SECTOR_SIZE;

            } else {

                dataLength = READ_ATTRIBUTE_BUFFER_SIZE;

            }
#else
            dataLength = READ_ATTRIBUTE_BUFFER_SIZE;
#endif

            //
            // Zero the ouput buffer as the input buffer info. has been saved off locally (the buffers are the same).
            //
            for (i = 0; i < (sizeof(SENDCMDOUTPARAMS) + dataLength - 1); i++) {
                ((PUCHAR)cmdOutParameters)[i] = 0;
            }

            //
            // Set data buffer pointer and words left.
            //
            deviceExtension->DataBuffer = (PUCHAR)cmdOutParameters->bBuffer;
            deviceExtension->BytesLeft = dataLength;

            //
            // Indicate expecting an interrupt.
            //
            deviceExtension->ExpectingInterrupt = TRUE;

            SelectIdeDevice(baseIoAddress1, targetId, 0);
            IdePortOutPortByte(baseIoAddress1->Error,regs->bFeaturesReg);
            IdePortOutPortByte(baseIoAddress1->BlockCount,regs->bSectorCountReg);
            IdePortOutPortByte(baseIoAddress1->BlockNumber,regs->bSectorNumberReg);
            IdePortOutPortByte(baseIoAddress1->CylinderLow,regs->bCylLowReg);
            IdePortOutPortByte(baseIoAddress1->CylinderHigh,regs->bCylHighReg);
            IdePortOutPortByte(baseIoAddress1->Command,regs->bCommandReg);

            //
            // Wait for interrupt.
            //
            return SRB_STATUS_PENDING;

        } else if ((cmdInParameters.irDriveRegs.bFeaturesReg == ENABLE_SMART) ||
                   (cmdInParameters.irDriveRegs.bFeaturesReg == DISABLE_SMART) ||
                   (cmdInParameters.irDriveRegs.bFeaturesReg == RETURN_SMART_STATUS) ||
                   (cmdInParameters.irDriveRegs.bFeaturesReg == ENABLE_DISABLE_AUTOSAVE) ||
                   (cmdInParameters.irDriveRegs.bFeaturesReg == EXECUTE_OFFLINE_DIAGS) ||
                   (cmdInParameters.irDriveRegs.bFeaturesReg == SAVE_ATTRIBUTE_VALUES) ||
                   (cmdInParameters.irDriveRegs.bFeaturesReg == ENABLE_DISABLE_AUTO_OFFLINE)) {
#ifdef ENABLE_SMARTLOG_SUPPORT
            //
            // Allow only the non-captive tests, for now.
            //
            if (cmdInParameters.irDriveRegs.bFeaturesReg == EXECUTE_OFFLINE_DIAGS) {

                UCHAR sectorNumber = regs->bSectorNumberReg;

                if ((sectorNumber == SMART_OFFLINE_ROUTINE_OFFLINE) ||
                    (sectorNumber == SMART_SHORT_SELFTEST_OFFLINE) ||
                    (sectorNumber == SMART_EXTENDED_SELFTEST_OFFLINE) ||
                    (sectorNumber == SMART_ABORT_OFFLINE_SELFTEST)) {

                    DebugPrint((1, 
                                "The SMART offline command %x is allowed\n",
                                sectorNumber));

                } else if ((sectorNumber == SMART_SHORT_SELFTEST_CAPTIVE) ||
                           (sectorNumber == SMART_EXTENDED_SELFTEST_CAPTIVE)) {

                    //
                    // Don't allow captive mode requests, if you have a slave(another)
                    // device
                    //
                    if (HasSlaveDevice(deviceExtension, targetId)) {
                        return SRB_STATUS_INVALID_REQUEST;
                    }

                }
            }
#endif

            SelectIdeLine(baseIoAddress1, targetId >> 1);

            WaitOnBusy(baseIoAddress1,statusByte);

            if (statusByte & IDE_STATUS_BUSY) {
                DebugPrint((1,
                            "IdeSendSmartCommand: Returning BUSY status\n"));
                return SRB_STATUS_BUSY;
            }

            //
            // Zero the ouput buffer as the input buffer info. has been saved off locally (the buffers are the same).
            //
            for (i = 0; i < (sizeof(SENDCMDOUTPARAMS) - 1); i++) {
                ((PUCHAR)cmdOutParameters)[i] = 0;
            }

            //
            // Set data buffer pointer and indicate no data transfer.
            //
            deviceExtension->DataBuffer = (PUCHAR)cmdOutParameters->bBuffer;
            deviceExtension->BytesLeft = 0;

            //
            // Indicate expecting an interrupt.
            //
            deviceExtension->ExpectingInterrupt = TRUE;

            SelectIdeDevice(baseIoAddress1, targetId, 0);
            IdePortOutPortByte(baseIoAddress1->Error,regs->bFeaturesReg);
            IdePortOutPortByte(baseIoAddress1->BlockCount,regs->bSectorCountReg);
            IdePortOutPortByte(baseIoAddress1->BlockNumber,regs->bSectorNumberReg);
            IdePortOutPortByte(baseIoAddress1->CylinderLow,regs->bCylLowReg);
            IdePortOutPortByte(baseIoAddress1->CylinderHigh,regs->bCylHighReg);
            IdePortOutPortByte(baseIoAddress1->Command,regs->bCommandReg);

            //
            // Wait for interrupt.
            //
            return SRB_STATUS_PENDING;

        }
#ifdef ENABLE_SMARTLOG_SUPPORT
        else if (cmdInParameters.irDriveRegs.bFeaturesReg == SMART_WRITE_LOG) {

            SelectIdeLine(baseIoAddress1, targetId >> 1);

            WaitOnBusy(baseIoAddress1,statusByte);

            if (statusByte & IDE_STATUS_BUSY) {
                DebugPrint((1,
                            "IdeSendSmartCommand: Returning BUSY status\n"));
                return SRB_STATUS_BUSY;
            }

            //
            // we are assuming that the drive will return an error if we try to
            // write multiple sectors when it is not supported.
            //

            //
            // set the input buffer and the datalength fields.
            //
            deviceExtension->DataBuffer = (PUCHAR)pCmdInParameters->bBuffer;
            deviceExtension->BytesLeft = cmdInParameters.irDriveRegs.bSectorCountReg* SMART_LOG_SECTOR_SIZE;

            //
            // Indicate expecting an interrupt.
            //
            deviceExtension->ExpectingInterrupt = TRUE;

            SelectIdeDevice(baseIoAddress1, targetId, 0);
            IdePortOutPortByte(baseIoAddress1->Error,regs->bFeaturesReg);
            IdePortOutPortByte(baseIoAddress1->BlockCount,regs->bSectorCountReg);
            IdePortOutPortByte(baseIoAddress1->BlockNumber,regs->bSectorNumberReg);
            IdePortOutPortByte(baseIoAddress1->CylinderLow,regs->bCylLowReg);
            IdePortOutPortByte(baseIoAddress1->CylinderHigh,regs->bCylHighReg);
            IdePortOutPortByte(baseIoAddress1->Command,regs->bCommandReg);

            ASSERT(!SRB_USES_DMA(Srb));

            if (!SRB_USES_DMA(Srb)) {

                if (deviceExtension->BytesLeft < 
                    deviceExtension->DeviceParameters[Srb->TargetId].MaxBytePerPioInterrupt) {
                    byteCount = deviceExtension->BytesLeft;
                } else {
                    byteCount = deviceExtension->DeviceParameters[Srb->TargetId].MaxBytePerPioInterrupt;
                }
                //
                // Wait for BSY and DRQ.
                //

                WaitOnBaseBusy(baseIoAddress1,statusByte);

                if (statusByte & IDE_STATUS_BUSY) {

                    DebugPrint((1,
                                "IdeSendSmartCommand: Returning BUSY status %x\n",
                                statusByte));
                    return SRB_STATUS_BUSY;

                }

                if (statusByte & IDE_STATUS_ERROR) {

                    DebugPrint((1,
                                "IdeSendSmartCommand: Returning ERROR status %x\n",
                                statusByte));

                    deviceExtension->BytesLeft = 0;

                    //
                    // Clear interrupt expecting flag.
                    //
                    deviceExtension->ExpectingInterrupt = FALSE;
                    return MapError(deviceExtension, Srb);
                }

                for (i = 0; i < 1000; i++) {
                    GetBaseStatus(baseIoAddress1, statusByte);
                    if (statusByte & IDE_STATUS_DRQ) {
                        break;
                    }
                    KeStallExecutionProcessor(200);

                }

                if (!(statusByte & IDE_STATUS_DRQ)) {

                    DebugPrint((1,
                                "IdeSmartCommand: DRQ never asserted (%x)\n", 
                                statusByte));

                    deviceExtension->BytesLeft = 0;

                    //
                    // Clear interrupt expecting flag.
                    //

                    deviceExtension->ExpectingInterrupt = FALSE;

                    //
                    // Clear current SRB.
                    //

                    deviceExtension->CurrentSrb = NULL;

                    return SRB_STATUS_SELECTION_TIMEOUT;
                }

                //
                // Write next 256 words.
                //

                WriteBuffer(baseIoAddress1,
                            (PUSHORT)deviceExtension->DataBuffer,
                            byteCount / sizeof(USHORT));

                //
                // Adjust buffer address and words left count.
                //

                deviceExtension->BytesLeft -= byteCount;
                deviceExtension->DataBuffer += byteCount;

            }
            //
            // Wait for interrupt.
            //
            return SRB_STATUS_PENDING;

        }
#endif
    }

    return SRB_STATUS_INVALID_REQUEST;

} // end IdeSendSmartCommand()

#ifdef ENABLE_48BIT_LBA

ULONG
IdeReadWriteExt(
               IN PVOID HwDeviceExtension,
               IN PSCSI_REQUEST_BLOCK Srb
               )

/*++

Routine Description:

    This routine handles IDE read and writes.

Arguments:

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

Return Value:

    SRB status

--*/

{
    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
    PIDE_REGISTERS_1     baseIoAddress1  = &deviceExtension->BaseIoAddress1;
    PIDE_REGISTERS_2     baseIoAddress2  = &deviceExtension->BaseIoAddress2;
    ULONG                i;
    ULONG                byteCount;
    UCHAR                statusByte,statusByte2;
    UCHAR                cylinderHigh,cylinderLow,drvSelect;
    ULONG                sectorCount;
    LARGE_INTEGER        startingSector;

    //
    // the device should support 48 bit LBA
    //
    ASSERT(deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_48BIT_LBA);
    ASSERT(deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_LBA);

    //
    // Select device 0 or 1.
    //
    SelectIdeDevice(baseIoAddress1, Srb->TargetId, 0);

    GetStatus(baseIoAddress1, statusByte2);

    if (statusByte2 & IDE_STATUS_BUSY) {
        DebugPrint((DBG_CRASHDUMP | DBG_READ_WRITE,
                    "IdeReadWrite: Returning BUSY status\n"));
        return SRB_STATUS_BUSY;
    }

    if (!(statusByte2 & IDE_STATUS_DRDY)) {

        DebugPrint((DBG_CRASHDUMP | DBG_READ_WRITE,
                    "IdeReadWrite: IDE_STATUS_DRDY not set\n"));
        return SRB_STATUS_BUSY;
    }

    //
    // Set data buffer pointer and words left.
    // BytesLeft should be 64-bit.
    //
    deviceExtension->DataBuffer = (PUCHAR)Srb->DataBuffer;
    deviceExtension->BytesLeft = Srb->DataTransferLength;

    //
    // Indicate expecting an interrupt.
    //
    deviceExtension->ExpectingInterrupt = TRUE;

    //                                                         
    // Set up sector count register. Round up to next block.
    //
    sectorCount = (Srb->DataTransferLength + 0x1FF) / 0x200;

    ASSERT(sectorCount != 0);


    //
    // Get starting sector number from CDB.
    //
    startingSector.QuadPart = 0;
    startingSector.LowPart = ((PCDB)Srb->Cdb)->CDB10.LogicalBlockByte3 |
                              ((PCDB)Srb->Cdb)->CDB10.LogicalBlockByte2 << 8 |
                              ((PCDB)Srb->Cdb)->CDB10.LogicalBlockByte1 << 16 |
                              ((PCDB)Srb->Cdb)->CDB10.LogicalBlockByte0 << 24;

    DebugPrint((1,
                "startingSector = 0x%x, length = 0x%x\n",
                startingSector.LowPart,
                sectorCount
                ));


    //
    // the device shall support LBA. We will not use CHS
    //
    SelectIdeDevice(baseIoAddress1,
                    Srb->TargetId,
                    IDE_LBA_MODE);

    //
    // load the higher order bytes
    //
    IdePortOutPortByte (
                       baseIoAddress1->BlockCount,
                       (UCHAR)((sectorCount & 0x0000ff00) >> 8));

    IdePortOutPortByte (
                       baseIoAddress1->BlockNumber,
                       (UCHAR) (((startingSector.LowPart) & 0xff000000) >> 24));

    IdePortOutPortByte (
                       baseIoAddress1->CylinderLow,
                       (UCHAR) (((startingSector.HighPart) & 0x000000ff) >> 0));

    IdePortOutPortByte (
                       baseIoAddress1->CylinderHigh,
                       (UCHAR) (((startingSector.HighPart) & 0x0000ff00) >> 8));

    //
    // load the lower order bytes
    //
    IdePortOutPortByte (
                       baseIoAddress1->BlockCount,
                       (UCHAR)((sectorCount & 0x000000ff) >> 0));

    IdePortOutPortByte (
                       baseIoAddress1->BlockNumber,
                       (UCHAR) (((startingSector.LowPart) & 0x000000ff) >> 0));

    IdePortOutPortByte (
                       baseIoAddress1->CylinderLow,
                       (UCHAR) (((startingSector.LowPart) & 0x0000ff00) >> 8));

    IdePortOutPortByte (
                       baseIoAddress1->CylinderHigh,
                       (UCHAR) (((startingSector.LowPart) & 0x00ff0000) >> 16));

    //
    // Check if write request.
    //
    if (Srb->SrbFlags & SRB_FLAGS_DATA_IN) {

        //
        // Send read command.
        //
        if (SRB_USES_DMA(Srb)) {

            IdePortOutPortByte (
                               baseIoAddress1->Command, 
                               IDE_COMMAND_READ_DMA_EXT);

        } else {

            ASSERT (deviceExtension->DeviceParameters[Srb->TargetId].IdePioReadCommandExt);

            IdePortOutPortByte (
                               baseIoAddress1->Command,
                               deviceExtension->DeviceParameters[Srb->TargetId].IdePioReadCommandExt);
        }

    } else {


        //
        // Send write command.
        //
        if (SRB_USES_DMA(Srb)) {

            IdePortOutPortByte (
                               baseIoAddress1->Command, 
                               IDE_COMMAND_WRITE_DMA_EXT);

        } else {

            ASSERT(deviceExtension->DeviceParameters[Srb->TargetId].IdePioWriteCommandExt);

            IdePortOutPortByte (
                               baseIoAddress1->Command,
                               deviceExtension->DeviceParameters[Srb->TargetId].IdePioWriteCommandExt);
        }

        if (!SRB_USES_DMA(Srb)) {

            if (deviceExtension->BytesLeft < 
                deviceExtension->DeviceParameters[Srb->TargetId].MaxBytePerPioInterrupt) {
                byteCount = deviceExtension->BytesLeft;
            } else {
                byteCount = deviceExtension->DeviceParameters[Srb->TargetId].MaxBytePerPioInterrupt;
            }
            //
            // Wait for BSY and DRQ.
            //

            WaitOnBaseBusy(baseIoAddress1,statusByte);

            if (statusByte & IDE_STATUS_BUSY) {

                DebugPrint((DBG_CRASHDUMP | DBG_READ_WRITE,
                            "IdeReadWrite 2: Returning BUSY status %x\n",
                            statusByte));
                return SRB_STATUS_BUSY;
            }

            for (i = 0; i < 1000; i++) {
                GetBaseStatus(baseIoAddress1, statusByte);
                if (statusByte & IDE_STATUS_DRQ) {
                    break;
                }
                KeStallExecutionProcessor(200);

            }

            if (!(statusByte & IDE_STATUS_DRQ)) {

                DebugPrint((DBG_CRASHDUMP | DBG_READ_WRITE,
                            "IdeReadWrite: DRQ never asserted (%x) original status (%x)\n",
                            statusByte,
                            statusByte2));

                deviceExtension->BytesLeft = 0;

                //
                // Clear interrupt expecting flag.
                //

                deviceExtension->ExpectingInterrupt = FALSE;

                //
                // Clear current SRB.
                //

                deviceExtension->CurrentSrb = NULL;

                return SRB_STATUS_TIMEOUT;
            }

            //
            // Write next 256 words.
            //

            WriteBuffer(baseIoAddress1,
                        (PUSHORT)deviceExtension->DataBuffer,
                        byteCount / sizeof(USHORT));

            //
            // Adjust buffer address and words left count.
            //

            deviceExtension->BytesLeft -= byteCount;
            deviceExtension->DataBuffer += byteCount;

        }
    }

    if (SRB_USES_DMA(Srb)) {
        deviceExtension->DMAInProgress = TRUE;
        deviceExtension->BusMasterInterface.BmArm (deviceExtension->BusMasterInterface.Context);
    }

    //
    // Wait for interrupt.
    //

    return SRB_STATUS_PENDING;

} // end IdeReadWriteExt()
#endif


ULONG
IdeReadWrite(
            IN PVOID HwDeviceExtension,
            IN PSCSI_REQUEST_BLOCK Srb
            )

/*++

Routine Description:

    This routine handles IDE read and writes.

Arguments:

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

Return Value:

    SRB status

--*/

{
    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
    PIDE_REGISTERS_1     baseIoAddress1  = &deviceExtension->BaseIoAddress1;
    PIDE_REGISTERS_2     baseIoAddress2  = &deviceExtension->BaseIoAddress2;
    ULONG                startingSector,i;
    ULONG                byteCount;
    UCHAR                statusByte,statusByte2;
    UCHAR                cylinderHigh,cylinderLow,drvSelect,sectorNumber;


    //
    // Select device 0 or 1.
    //
    SelectIdeDevice(baseIoAddress1, Srb->TargetId, 0);

    GetStatus(baseIoAddress1, statusByte2);

    if (statusByte2 & IDE_STATUS_BUSY) {
        DebugPrint((DBG_CRASHDUMP | DBG_READ_WRITE,
                    "IdeReadWrite: Returning BUSY status\n"));
        return SRB_STATUS_BUSY;
    }

    if (!(statusByte2 & IDE_STATUS_DRDY)) {

        if ((statusByte2 == 0) && 
            (deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_SONY_MEMORYSTICK)) {
            statusByte2=IDE_STATUS_DRDY;
        } else {
            DebugPrint((DBG_CRASHDUMP | DBG_READ_WRITE,
                        "IdeReadWrite: IDE_STATUS_DRDY not set\n"));
            return SRB_STATUS_BUSY;
        }
    }


    //
    // returns status busy when atapi verifier is enabled
    //
    //ViIdeFakeHungController(HwDeviceExtension);

    //
    // Set data buffer pointer and words left.
    //

    deviceExtension->DataBuffer = (PUCHAR)Srb->DataBuffer;
    deviceExtension->BytesLeft = Srb->DataTransferLength;

    //
    // Indicate expecting an interrupt.
    //

    deviceExtension->ExpectingInterrupt = TRUE;

    //                                                         
    // Set up sector count register. Round up to next block.
    //
    IdePortOutPortByte (
                       baseIoAddress1->BlockCount,
                       (UCHAR)((Srb->DataTransferLength + 0x1FF) / 0x200));

    //
    // Get starting sector number from CDB.
    //

    startingSector = ((PCDB)Srb->Cdb)->CDB10.LogicalBlockByte3 |
                     ((PCDB)Srb->Cdb)->CDB10.LogicalBlockByte2 << 8 |
                     ((PCDB)Srb->Cdb)->CDB10.LogicalBlockByte1 << 16 |
                     ((PCDB)Srb->Cdb)->CDB10.LogicalBlockByte0 << 24;

    DebugPrint((DBG_CRASHDUMP | DBG_READ_WRITE,
                "IdeReadWrite: Starting sector is %x, Number of bytes %x\n",
                startingSector,
                Srb->DataTransferLength));

    if (deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_LBA) {

        SelectIdeDevice(baseIoAddress1,
                        Srb->TargetId,
                        (IDE_LBA_MODE | ((startingSector & 0x0f000000) >> 24)));

        IdePortOutPortByte (
                           baseIoAddress1->BlockNumber,
                           (UCHAR) ((startingSector & 0x000000ff) >> 0));
        IdePortOutPortByte (
                           baseIoAddress1->CylinderLow,
                           (UCHAR) ((startingSector & 0x0000ff00) >> 8));

        IdePortOutPortByte (
                           baseIoAddress1->CylinderHigh,
                           (UCHAR) ((startingSector & 0x00ff0000) >> 16));


    } else {  //CHS

        //
        // Set up sector number register.
        //

        sectorNumber =  (UCHAR)((startingSector % deviceExtension->SectorsPerTrack[Srb->TargetId]) + 1);
        IdePortOutPortByte (
                           baseIoAddress1->BlockNumber,
                           sectorNumber);

        //
        // Set up cylinder low register.
        //

        cylinderLow =  (UCHAR)(startingSector / (deviceExtension->SectorsPerTrack[Srb->TargetId] *
                                                 deviceExtension->NumberOfHeads[Srb->TargetId]));
        IdePortOutPortByte (
                           baseIoAddress1->CylinderLow,
                           cylinderLow);

        //
        // Set up cylinder high register.
        //

        cylinderHigh = (UCHAR)((startingSector / (deviceExtension->SectorsPerTrack[Srb->TargetId] *
                                                  deviceExtension->NumberOfHeads[Srb->TargetId])) >> 8);
        IdePortOutPortByte (
                           baseIoAddress1->CylinderHigh,
                           cylinderHigh);

        //
        // Set up head and drive select register.
        //

        drvSelect = (UCHAR)(((startingSector / deviceExtension->SectorsPerTrack[Srb->TargetId]) %
                             deviceExtension->NumberOfHeads[Srb->TargetId]));
        SelectIdeDevice(baseIoAddress1, Srb->TargetId, drvSelect);

        DebugPrint((DBG_CRASHDUMP | DBG_READ_WRITE,
                    "IdeReadWrite: Cylinder %x Head %x Sector %x\n",
                    startingSector /
                    (deviceExtension->SectorsPerTrack[Srb->TargetId] *
                     deviceExtension->NumberOfHeads[Srb->TargetId]),
                    (startingSector /
                     deviceExtension->SectorsPerTrack[Srb->TargetId]) %
                    deviceExtension->NumberOfHeads[Srb->TargetId],
                    startingSector %
                    deviceExtension->SectorsPerTrack[Srb->TargetId] + 1));
    }

    //
    // Check if write request.
    //

    if (Srb->SrbFlags & SRB_FLAGS_DATA_IN) {

        //
        // Send read command.
        //
        if (SRB_USES_DMA(Srb)) {

            IdePortOutPortByte (
                               baseIoAddress1->Command, 
                               IDE_COMMAND_READ_DMA);

        } else {

            IdePortOutPortByte (
                               baseIoAddress1->Command,
                               deviceExtension->DeviceParameters[Srb->TargetId].IdePioReadCommand);
        }

    } else {


        //
        // Send write command.
        //
        if (SRB_USES_DMA(Srb)) {

            IdePortOutPortByte (
                               baseIoAddress1->Command, 
                               IDE_COMMAND_WRITE_DMA);

        } else {

            IdePortOutPortByte (
                               baseIoAddress1->Command,
                               deviceExtension->DeviceParameters[Srb->TargetId].IdePioWriteCommand);
        }

        if (!SRB_USES_DMA(Srb)) {

            if (deviceExtension->BytesLeft < 
                deviceExtension->DeviceParameters[Srb->TargetId].MaxBytePerPioInterrupt) {
                byteCount = deviceExtension->BytesLeft;
            } else {
                byteCount = deviceExtension->DeviceParameters[Srb->TargetId].MaxBytePerPioInterrupt;
            }
            //
            // Wait for BSY and DRQ.
            //

            WaitOnBaseBusy(baseIoAddress1,statusByte);

            if (statusByte & IDE_STATUS_BUSY) {

                DebugPrint((DBG_CRASHDUMP | DBG_READ_WRITE,
                            "IdeReadWrite 2: Returning BUSY status %x\n",
                            statusByte));
                return SRB_STATUS_BUSY;
            }

            for (i = 0; i < 1000; i++) {
                GetBaseStatus(baseIoAddress1, statusByte);
                if (statusByte & IDE_STATUS_DRQ) {
                    break;
                }
                KeStallExecutionProcessor(200);

            }

            if (!(statusByte & IDE_STATUS_DRQ)) {

                DebugPrint((DBG_CRASHDUMP | DBG_READ_WRITE,
                            "IdeReadWrite: DRQ never asserted (%x) original status (%x)\n",
                            statusByte,
                            statusByte2));

                deviceExtension->BytesLeft = 0;

                //
                // Clear interrupt expecting flag.
                //

                deviceExtension->ExpectingInterrupt = FALSE;

                //
                // Clear current SRB.
                //

                deviceExtension->CurrentSrb = NULL;

                return SRB_STATUS_TIMEOUT;
            }

            //
            // Write next 256 words.
            //

            WriteBuffer(baseIoAddress1,
                        (PUSHORT)deviceExtension->DataBuffer,
                        byteCount / sizeof(USHORT));

            //
            // Adjust buffer address and words left count.
            //

            deviceExtension->BytesLeft -= byteCount;
            deviceExtension->DataBuffer += byteCount;

        }
    }

    if (SRB_USES_DMA(Srb)) {
        deviceExtension->DMAInProgress = TRUE;
        deviceExtension->BusMasterInterface.BmArm (deviceExtension->BusMasterInterface.Context);
    }

    //
    // Wait for interrupt.
    //

    return SRB_STATUS_PENDING;

} // end IdeReadWrite()

#ifdef ENABLE_48BIT_LBA
ULONG
IdeVerifyExt(
            IN PVOID HwDeviceExtension,
            IN PSCSI_REQUEST_BLOCK Srb
            )

/*++

Routine Description:

    This routine handles IDE Verify.

Arguments:

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

Return Value:

    SRB status

--*/

{
    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
    PIDE_REGISTERS_1     baseIoAddress1  = &deviceExtension->BaseIoAddress1;
    PIDE_REGISTERS_2     baseIoAddress2  = &deviceExtension->BaseIoAddress2;
    LARGE_INTEGER        startingSector;
    ULONG                sectors;
    ULONG                endSector;
    ULONG                sectorCount;

    //
    // the device should support 48 bit LBA
    //
    ASSERT(deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_48BIT_LBA);
    ASSERT(deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_LBA);

    //
    // Get starting sector number from CDB.
    //
    startingSector.QuadPart = 0;
    startingSector.QuadPart = ((PCDB)Srb->Cdb)->CDB10.LogicalBlockByte3 |
                              ((PCDB)Srb->Cdb)->CDB10.LogicalBlockByte2 << 8 |
                              ((PCDB)Srb->Cdb)->CDB10.LogicalBlockByte1 << 16 |
                              ((PCDB)Srb->Cdb)->CDB10.LogicalBlockByte0 << 24;

    DebugPrint((3,
                "IdeVerify: Starting sector %x. Number of blocks %x\n",
                startingSector,
                ((PCDB)Srb->Cdb)->CDB10.TransferBlocksLsb));

    sectorCount = (USHORT)(((PCDB)Srb->Cdb)->CDB10.TransferBlocksMsb << 8 |
                           ((PCDB)Srb->Cdb)->CDB10.TransferBlocksLsb );

    if (sectorCount > 0x10000) {

        DebugPrint((DBG_ALWAYS,
                    "IdeVerify: verify too many sectors 0x%x\n",
                    sectorCount));

        return SRB_STATUS_INVALID_REQUEST;
    }


    //
    // Set data buffer pointer and words left.
    //

    deviceExtension->DataBuffer = Srb->DataBuffer;
    deviceExtension->BytesLeft = Srb->DataTransferLength;

    //
    // Indicate expecting an interrupt.
    //

    deviceExtension->ExpectingInterrupt = TRUE;


    SelectIdeDevice(baseIoAddress1,
                    Srb->TargetId,
                    IDE_LBA_MODE);

    //
    // Load the higer order bytes
    //
    IdePortOutPortByte(baseIoAddress1->BlockNumber,
                       (UCHAR) (((startingSector.LowPart) & 0xff000000) >> 24));

    IdePortOutPortByte(baseIoAddress1->CylinderLow,
                       (UCHAR) (((startingSector.HighPart) & 0x000000ff) >> 0));

    IdePortOutPortByte(baseIoAddress1->CylinderHigh,
                       (UCHAR) (((startingSector.HighPart) & 0x0000ff00) >> 8));

    IdePortOutPortByte(baseIoAddress1->BlockCount,
                       (UCHAR)((sectorCount & 0x0000ff00) >> 8));

    //
    // Load the lower order bytes
    //
    IdePortOutPortByte(baseIoAddress1->BlockNumber,
                       (UCHAR) (((startingSector.LowPart) & 0x000000ff) >> 0));

    IdePortOutPortByte(baseIoAddress1->CylinderLow,
                       (UCHAR) (((startingSector.LowPart) & 0x0000ff00) >> 8));

    IdePortOutPortByte(baseIoAddress1->CylinderHigh,
                       (UCHAR) (((startingSector.LowPart) & 0x00ff0000) >> 16));

    IdePortOutPortByte(baseIoAddress1->BlockCount,
                       (UCHAR)((sectorCount & 0x000000ff) >> 0));

    //
    // Send verify command.
    //

    IdePortOutPortByte(baseIoAddress1->Command,
                       IDE_COMMAND_VERIFY_EXT);

    //
    // Wait for interrupt.
    //

    return SRB_STATUS_PENDING;

} // end IdeVerifyExt()
#endif


ULONG
IdeVerify(
         IN PVOID HwDeviceExtension,
         IN PSCSI_REQUEST_BLOCK Srb
         )

/*++

Routine Description:

    This routine handles IDE Verify.

Arguments:

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

Return Value:

    SRB status

--*/

{
    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
    PIDE_REGISTERS_1     baseIoAddress1  = &deviceExtension->BaseIoAddress1;
    PIDE_REGISTERS_2     baseIoAddress2  = &deviceExtension->BaseIoAddress2;
    ULONG                startingSector;
    ULONG                sectors;
    ULONG                endSector;
    USHORT               sectorCount;

    //
    // Drive has these number sectors.
    //

#if DBG
    if (deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_LBA) { // LBA
        sectors = deviceExtension->IdentifyData[Srb->TargetId].UserAddressableSectors;
    } else {
        sectors = deviceExtension->SectorsPerTrack[Srb->TargetId] *
                  deviceExtension->NumberOfHeads[Srb->TargetId] *
                  deviceExtension->NumberOfCylinders[Srb->TargetId];
    }
#endif

    DebugPrint((3,
                "IdeVerify: Total sectors %x\n",
                sectors));

    //
    // Get starting sector number from CDB.
    //

    startingSector = ((PCDB)Srb->Cdb)->CDB10.LogicalBlockByte3 |
                     ((PCDB)Srb->Cdb)->CDB10.LogicalBlockByte2 << 8 |
                     ((PCDB)Srb->Cdb)->CDB10.LogicalBlockByte1 << 16 |
                     ((PCDB)Srb->Cdb)->CDB10.LogicalBlockByte0 << 24;

    DebugPrint((3,
                "IdeVerify: Starting sector %x. Number of blocks %x\n",
                startingSector,
                ((PCDB)Srb->Cdb)->CDB10.TransferBlocksLsb));

    sectorCount = (USHORT)(((PCDB)Srb->Cdb)->CDB10.TransferBlocksMsb << 8 |
                           ((PCDB)Srb->Cdb)->CDB10.TransferBlocksLsb );
    endSector = startingSector + sectorCount;

    DebugPrint((3,
                "IdeVerify: Ending sector %x\n",
                endSector));

    if (sectorCount > 0x100) {

        DebugPrint((DBG_ALWAYS,
                    "IdeVerify: verify too many sectors 0x%x\n",
                    sectorCount));

        return SRB_STATUS_INVALID_REQUEST;
    }


    //
    // Set data buffer pointer and words left.
    //

    deviceExtension->DataBuffer = Srb->DataBuffer;
    deviceExtension->BytesLeft = Srb->DataTransferLength;

    //
    // Indicate expecting an interrupt.
    //

    deviceExtension->ExpectingInterrupt = TRUE;


    if (deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_LBA) { // LBA

        SelectIdeDevice(baseIoAddress1,
                        Srb->TargetId,
                        (IDE_LBA_MODE |((startingSector & 0x0f000000) >> 24)));

        IdePortOutPortByte(baseIoAddress1->BlockNumber,
                           (UCHAR) ((startingSector & 0x000000ff) >> 0));

        IdePortOutPortByte(baseIoAddress1->CylinderLow,
                           (UCHAR) ((startingSector & 0x0000ff00) >> 8));

        IdePortOutPortByte(baseIoAddress1->CylinderHigh,
                           (UCHAR) ((startingSector & 0x00ff0000) >> 16));

        DebugPrint((2,
                    "IdeVerify: LBA: startingSector %x\n",
                    startingSector));

    } else {  //CHS

        //
        // Set up head and drive select register.
        //

        SelectIdeDevice(baseIoAddress1,
                        Srb->TargetId,
                        (UCHAR)((startingSector /
                                 deviceExtension->SectorsPerTrack[Srb->TargetId]) %
                                deviceExtension->NumberOfHeads[Srb->TargetId]));

        //
        // Set up sector number register.
        //

        IdePortOutPortByte(baseIoAddress1->BlockNumber,
                           (UCHAR)((startingSector %
                                    deviceExtension->SectorsPerTrack[Srb->TargetId]) + 1));

        //
        // Set up cylinder low register.
        //

        IdePortOutPortByte(baseIoAddress1->CylinderLow,
                           (UCHAR)(startingSector /
                                   (deviceExtension->SectorsPerTrack[Srb->TargetId] *
                                    deviceExtension->NumberOfHeads[Srb->TargetId])));

        //
        // Set up cylinder high register.
        //

        IdePortOutPortByte(baseIoAddress1->CylinderHigh,
                           (UCHAR)((startingSector /
                                    (deviceExtension->SectorsPerTrack[Srb->TargetId] *
                                     deviceExtension->NumberOfHeads[Srb->TargetId])) >> 8));

        DebugPrint((2,
                    "IdeVerify: CHS: Cylinder %x Head %x Sector %x\n",
                    startingSector /
                    (deviceExtension->SectorsPerTrack[Srb->TargetId] *
                     deviceExtension->NumberOfHeads[Srb->TargetId]),
                    (startingSector /
                     deviceExtension->SectorsPerTrack[Srb->TargetId]) %
                    deviceExtension->NumberOfHeads[Srb->TargetId],
                    startingSector %
                    deviceExtension->SectorsPerTrack[Srb->TargetId] + 1));
    }

/********
    if (endSector > sectors) {

        //
        // Too big, round down.
        //

        DebugPrint((1,
                    "IdeVerify: Truncating request to %x blocks\n",
                    sectors - startingSector - 1));

        IdePortOutPortByte(baseIoAddress1->BlockCount,
                               (UCHAR)(sectors - startingSector - 1));

    } else {

        IdePortOutPortByte(baseIoAddress1->BlockCount,(UCHAR)sectorCount);
    }
******/

    IdePortOutPortByte(baseIoAddress1->BlockCount,(UCHAR)sectorCount);

    //
    // Send verify command.
    //

    IdePortOutPortByte(baseIoAddress1->Command,
                       IDE_COMMAND_VERIFY);

    //
    // Wait for interrupt.
    //

    return SRB_STATUS_PENDING;

} // end IdeVerify()


VOID
Scsi2Atapi(
          IN PHW_DEVICE_EXTENSION DeviceExtension,
          IN PSCSI_REQUEST_BLOCK Srb
          )

/*++

Routine Description:

    Convert SCSI packet command to Atapi packet command.

Arguments:

    Srb - IO request packet

Return Value:

    None

--*/
{
    SAVE_ORIGINAL_CDB(DeviceExtension, Srb);

    DeviceExtension->scsi2atapi = FALSE;

    if (!(DeviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_TAPE_DEVICE)) {

        //
        // Change the cdb length
        //
        //Srb->CdbLength = 12;

        switch (Srb->Cdb[0]) {
        case SCSIOP_MODE_SENSE: {

            ASSERT(FALSE);

            break;
            }

        case SCSIOP_MODE_SELECT: {

            ASSERT (FALSE);

            break;
            }

        case SCSIOP_START_STOP_UNIT: {

                //
                // Bad Cd-roms
                // STOP command (1B) hangs during shutdown/hibernation on
                // some cd-rom drives. Setting the Immediate bit to 0 seems
                // to work
                //

                PCDB cdb = (PCDB)Srb->Cdb;
                if ((cdb->START_STOP.Immediate == 1) && 
                    (cdb->START_STOP.LoadEject == 0) &&
                    (cdb->START_STOP.Start == 0))

                    cdb->START_STOP.Immediate=0;
                DeviceExtension->scsi2atapi = TRUE;
                break;
            }

        case SCSIOP_FORMAT_UNIT:

            if (DeviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_LS120_FORMAT) {

                Srb->Cdb[0] = ATAPI_LS120_FORMAT_UNIT;
                DeviceExtension->scsi2atapi = TRUE;
            }
            break;

        }
    }

    return;
} // Scsi2Atapi



ULONG
AtapiSendCommand(
                IN PVOID HwDeviceExtension,
                IN PSCSI_REQUEST_BLOCK Srb
                )

/*++

Routine Description:

    Send ATAPI packet command to device.

Arguments:

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

Return Value:


--*/

{
    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
    PATAPI_REGISTERS_1   baseIoAddress1  = (PATAPI_REGISTERS_1)&deviceExtension->BaseIoAddress1;
    PATAPI_REGISTERS_2   baseIoAddress2 =  (PATAPI_REGISTERS_2)&deviceExtension->BaseIoAddress2;
    ULONG i;
    ULONG flags;
    UCHAR statusByte,byteCountLow,byteCountHigh;


#ifdef ENABLE_48BIT_LBA
    ASSERT(!(deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_48BIT_LBA));
#endif

    DebugPrint((DBG_ATAPI_DEVICES,
                "AtapiSendCommand: Command %x to TargetId %d lun %d\n",
                Srb->Cdb[0],
                Srb->TargetId,
                Srb->Lun));

    if (Srb->SrbFlags & SRB_FLAGS_UNSPECIFIED_DIRECTION) {
        DebugPrint((DBG_ATAPI_DEVICES,
                    "AtapiSendCommand: xferLength=%x, LBA=%x\n",
                    Srb->DataTransferLength,
                    (((PCDB)Srb->Cdb)->CDB10.LogicalBlockByte0 |
                     (((PCDB)Srb->Cdb)->CDB10.LogicalBlockByte1 << 8) | 
                     (((PCDB)Srb->Cdb)->CDB10.LogicalBlockByte2 << 16) |
                     (((PCDB)Srb->Cdb)->CDB10.LogicalBlockByte3 << 24))
                   ));
    }

    //
    // Make sure command is to ATAPI device.
    //

    flags = deviceExtension->DeviceFlags[Srb->TargetId];

    if (Srb->Lun > deviceExtension->LastLun[Srb->TargetId]) {
        return SRB_STATUS_SELECTION_TIMEOUT;
    }

    if (!(flags & DFLAGS_ATAPI_DEVICE)) {
        return SRB_STATUS_SELECTION_TIMEOUT;
    }

    //
    // Select device 0 or 1.
    //
    SelectIdeDevice(baseIoAddress1, Srb->TargetId, 0);


    //
    // Verify that controller is ready for next command.
    //

    GetStatus(baseIoAddress1,statusByte);

    DebugPrint((2,
                "AtapiSendCommand: Entered with status %x\n",
                statusByte));

    if (statusByte & IDE_STATUS_BUSY) {
        DebugPrint((1,
                    "AtapiSendCommand: Device busy (%x)\n",
                    statusByte));
        return SRB_STATUS_BUSY;

    }

    //
    // If a tape drive has doesn't have DSC set and the last command is restrictive, don't send
    // the next command. See discussion of Restrictive Delayed Process commands in QIC-157.
    //

#if 0
    if ((!(statusByte & IDE_STATUS_DSC)) &&
        (flags & DFLAGS_TAPE_DEVICE) && deviceExtension->RDP) {
        KeStallExecutionProcessor(1000);
        DebugPrint((2,"AtapiSendCommand: DSC not set. %x\n",statusByte));
        return SRB_STATUS_BUSY;
    }
#endif

    //
    // Extended RDP to include SEEK commands for CD-ROMS.
    //
    if ((!(statusByte & IDE_STATUS_DSC)) && deviceExtension->RDP &&
        (flags & DFLAGS_RDP_SET)) {

        KeStallExecutionProcessor(1000);

        DebugPrint((DBG_ATAPI_DEVICES,
                    "AtapiSendCommand: DSC not set. %x\n",
                    statusByte
                   ));

        return SRB_STATUS_BUSY;
    }

    if (SRB_IS_RDP(Srb)) {

        deviceExtension->RDP = TRUE;
        SETMASK(deviceExtension->DeviceFlags[Srb->TargetId], DFLAGS_RDP_SET);

        DebugPrint((3,
                    "AtapiSendCommand: %x mapped as DSC restrictive\n",
                    Srb->Cdb[0]));

    } else {

        deviceExtension->RDP = FALSE;
        CLRMASK(deviceExtension->DeviceFlags[Srb->TargetId], DFLAGS_RDP_SET);
    }

    //
    // Convert SCSI to ATAPI commands if needed
    //
    Scsi2Atapi(deviceExtension, Srb);

    //
    // Set data buffer pointer and words left.
    //

    deviceExtension->DataBuffer = Srb->DataBuffer;
    deviceExtension->BytesLeft = Srb->DataTransferLength;

    WaitOnBusy(baseIoAddress1,statusByte);

    //
    // Write transfer byte count to registers.
    //

    byteCountLow = (UCHAR)(Srb->DataTransferLength & 0xFF);
    byteCountHigh = (UCHAR)(Srb->DataTransferLength >> 8);

    if (Srb->DataTransferLength >= 0x10000) {
        byteCountLow = byteCountHigh = 0xFF;
    }

    IdePortOutPortByte(baseIoAddress1->ByteCountLow,byteCountLow);
    IdePortOutPortByte(baseIoAddress1->ByteCountHigh, byteCountHigh);

    if (SRB_USES_DMA(Srb)) {
        IdePortOutPortByte(baseIoAddress1->Error, 0x1);
    } else {

        IdePortOutPortByte(baseIoAddress1->Error, 0x0);
    }

    if (flags & DFLAGS_INT_DRQ) {

        //
        // This device interrupts when ready to receive the packet.
        //
        // Write ATAPI packet command.
        //

        deviceExtension->ExpectingInterrupt = TRUE;

        IdePortOutPortByte(baseIoAddress1->Command,
                           IDE_COMMAND_ATAPI_PACKET);

        DebugPrint((3,
                    "AtapiSendCommand: Wait for int. to send packet. Status (%x)\n",
                    statusByte));

        return SRB_STATUS_PENDING;

    } else {

        //
        // Write ATAPI packet command.
        //

        IdePortOutPortByte(baseIoAddress1->Command,
                           IDE_COMMAND_ATAPI_PACKET);

        //
        // Wait for DRQ.
        //

        WaitOnBusy(baseIoAddress1, statusByte);
        WaitForDrq(baseIoAddress1, statusByte);

        if (!(statusByte & IDE_STATUS_DRQ)) {

            DebugPrint((1,
                        "AtapiSendCommand: DRQ never asserted (%x)\n",
                        statusByte));
            return SRB_STATUS_ERROR;
        }
    }

    //
    // Need to read status register.
    //

    GetBaseStatus(baseIoAddress1, statusByte);

    //
    // Indicate expecting an interrupt and wait for it.
    //

    deviceExtension->ExpectingInterrupt = TRUE;


    //
    // Send CDB to device.
    //

    WaitOnBusy(baseIoAddress1,statusByte);

    WriteBuffer(baseIoAddress1,
                (PUSHORT)Srb->Cdb,
                6);

    if (SRB_USES_DMA(Srb)) {
        deviceExtension->DMAInProgress = TRUE;
        deviceExtension->BusMasterInterface.BmArm (deviceExtension->BusMasterInterface.Context);
    }

    return SRB_STATUS_PENDING;

} // end AtapiSendCommand()

ULONG
IdeSendFlushCommand(
                   IN PVOID HwDeviceExtension,
                   IN PSCSI_REQUEST_BLOCK Srb
                   )
/*++

Routine Description:

    Program ATA registers for IDE flush command.

Arguments:

    HwDeviceExtension - ATAPI driver storage.
    Srb - System request block.

Return Value:

    SRB status (pending if all goes well).

--*/
{
    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
    PIDE_REGISTERS_1     baseIoAddress1  = &deviceExtension->BaseIoAddress1;
    UCHAR                flushCommand;
    ULONG status;


    //
    // Get the flush command
    //
    flushCommand = deviceExtension->DeviceParameters[Srb->TargetId].IdeFlushCommand;

    //
    // We should check for the case where we have  already queued a 
    // flush cache command. 
    //
    if (flushCommand == IDE_COMMAND_NO_FLUSH) {
        return SRB_STATUS_SUCCESS;
    }

    //
    // if we reached this stage then the device should support flush command
    //
    ASSERT (flushCommand != IDE_COMMAND_NO_FLUSH);

    DebugPrint((1,
                "IdeSendFlushCommand: device %d, srb 0x%x\n",
                Srb->TargetId,
                Srb
               ));

    //
    // Select the right device
    //
    SelectIdeDevice(baseIoAddress1, Srb->TargetId, 0);

    //
    // Set data buffer pointer and words left.
    //
    deviceExtension->DataBuffer = (PUCHAR)Srb->DataBuffer;
    deviceExtension->BytesLeft = Srb->DataTransferLength;

    //
    // Indicate expecting an interrupt.
    //
    deviceExtension->ExpectingInterrupt = TRUE;
    status = SRB_STATUS_PENDING;


    //
    // Program the TaskFile registers
    //
    IdePortOutPortByte(baseIoAddress1->Error,        0);
    IdePortOutPortByte(baseIoAddress1->BlockCount,   0);
    IdePortOutPortByte(baseIoAddress1->BlockNumber,  0);
    IdePortOutPortByte(baseIoAddress1->CylinderLow,  0);
    IdePortOutPortByte(baseIoAddress1->CylinderHigh, 0);
    IdePortOutPortByte(baseIoAddress1->Command,      flushCommand);

    return status;
}

#ifdef ENABLE_48BIT_LBA

ULONG
IdeSendFlushCommandExt(
                      IN PVOID HwDeviceExtension,
                      IN PSCSI_REQUEST_BLOCK Srb
                      )
/*++

Routine Description:

    Program ATA registers for IDE flush ext command.

Arguments:

    HwDeviceExtension - ATAPI driver storage.
    Srb - System request block.

Return Value:

    SRB status (pending if all goes well).

--*/
{
    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
    PIDE_REGISTERS_1     baseIoAddress1  = &deviceExtension->BaseIoAddress1;
    UCHAR                flushCommand;
    ULONG status;
    UCHAR statusByte;


    //
    // the device should support 48 bit LBA
    //
    ASSERT(deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_48BIT_LBA);

    //
    // Get the flush command
    //
    flushCommand = deviceExtension->DeviceParameters[Srb->TargetId].IdeFlushCommandExt;

    //
    // We should check for the case where we have  already queued a 
    // flush cache command. 
    //
    if (flushCommand == IDE_COMMAND_NO_FLUSH) {
        return SRB_STATUS_SUCCESS;
    }

    //
    // if we reached this stage then the device should support flush command
    //
    ASSERT (flushCommand != IDE_COMMAND_NO_FLUSH);

    DebugPrint((1,
                "IdeSendFlushCommand: device %d, srb 0x%x\n",
                Srb->TargetId,
                Srb
               ));

    //
    // Select the right device
    //
    SelectIdeDevice(baseIoAddress1, Srb->TargetId, 0);

    //
    // Set data buffer pointer and words left.
    //
    deviceExtension->DataBuffer = (PUCHAR)Srb->DataBuffer;
    deviceExtension->BytesLeft = Srb->DataTransferLength;

    //
    // Indicate expecting an interrupt.
    //
    deviceExtension->ExpectingInterrupt = TRUE;
    status = SRB_STATUS_PENDING;


    //
    // Program the TaskFile registers (previous content)
    //
    IdePortOutPortByte(baseIoAddress1->Error,        0);
    IdePortOutPortByte(baseIoAddress1->BlockCount,   0);
    IdePortOutPortByte(baseIoAddress1->BlockNumber,  0);
    IdePortOutPortByte(baseIoAddress1->CylinderLow,  0);
    IdePortOutPortByte(baseIoAddress1->CylinderHigh, 0);

    //
    // Program the TaskFile registers (current content)
    //
    IdePortOutPortByte(baseIoAddress1->Error,        0);
    IdePortOutPortByte(baseIoAddress1->BlockCount,   0);
    IdePortOutPortByte(baseIoAddress1->BlockNumber,  0);
    IdePortOutPortByte(baseIoAddress1->CylinderLow,  0);
    IdePortOutPortByte(baseIoAddress1->CylinderHigh, 0);

    IdePortOutPortByte(baseIoAddress1->Command,      flushCommand);

    return status;
}
#endif

ULONG
IdeSendCommand(
              IN PVOID HwDeviceExtension,
              IN PSCSI_REQUEST_BLOCK Srb
              )

/*++

Routine Description:

    Program ATA registers for IDE disk transfer.

Arguments:

    HwDeviceExtension - ATAPI driver storage.
    Srb - System request block.

Return Value:

    SRB status (pending if all goes well).

--*/

{
    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
    PIDE_REGISTERS_1     baseIoAddress1  = &deviceExtension->BaseIoAddress1;
    PIDE_REGISTERS_2     baseIoAddress2  = &deviceExtension->BaseIoAddress2;
    PCDB cdb;

    UCHAR statusByte,errorByte;
    ULONG status;
    ULONG i;
    PMODE_PARAMETER_HEADER   modeData;

    DebugPrint((2,
                "IdeSendCommand: Command %x to device %d\n",
                Srb->Cdb[0],
                Srb->TargetId));



    switch (Srb->Cdb[0]) {
    case SCSIOP_INQUIRY:

        //
        // Filter out all TIDs but 0 and 1 since this is an IDE interface
        // which support up to two devices.
        //

        if ((Srb->Lun != 0) ||
            (!(deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_DEVICE_PRESENT))) {

            //
            // Indicate no device found at this address.
            //

            status = SRB_STATUS_SELECTION_TIMEOUT;
            break;

        } else {

            INQUIRYDATA     inquiryData;
            PIDENTIFY_DATA  identifyData = &deviceExtension->IdentifyData[Srb->TargetId];

            //
            // Zero INQUIRY data structure.
            //
            RtlZeroMemory(Srb->DataBuffer, Srb->DataTransferLength);

            RtlZeroMemory((PUCHAR) &inquiryData, sizeof(INQUIRYDATA));

            inquiryData.DeviceType = DIRECT_ACCESS_DEVICE;

            //
            // Set the removable bit, if applicable.
            //

            if (deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_REMOVABLE_DRIVE) {
                inquiryData.RemovableMedia = 1;
            }

            //
            // Fill in vendor identification fields.
            //
            //for (i = 0; i < 20; i += 2) {
            //    inquiryData.VendorId[i] =
            //    ((PUCHAR)identifyData->ModelNumber)[i + 1];
            //    inquiryData.VendorId[i+1] =
            //    ((PUCHAR)identifyData->ModelNumber)[i];
            //}
            //
            // break it into two loops such that it 
            // explicitly indicates the fields to 
            // which the id is copied
            //

            //
            // copy the first 8 bytes to VendorId
            //
            for (i = 0; i < 8; i += 2) {
                inquiryData.VendorId[i] =
                ((PUCHAR)identifyData->ModelNumber)[i + 1];
                inquiryData.VendorId[i+1] =
                ((PUCHAR)identifyData->ModelNumber)[i];
            }

            //
            // copy the next 12 bytes to ProductId
            //
            for (i = 0; i < 12; i += 2) {
                inquiryData.ProductId[i] =
                ((PUCHAR)identifyData->ModelNumber)[i + 9];
                inquiryData.ProductId[i+1] =
                ((PUCHAR)identifyData->ModelNumber)[i + 8];
            }

            //
            // Initialize unused portion of product id.
            //
            for (i = 0; i < 4; i++) {
                inquiryData.ProductId[12+i] = ' ';
            }

            //
            // Move firmware revision from IDENTIFY data to
            // product revision in INQUIRY data.
            //
            for (i = 0; i < 4; i += 2) {
                inquiryData.ProductRevisionLevel[i] =
                ((PUCHAR)identifyData->FirmwareRevision)[i+1];
                inquiryData.ProductRevisionLevel[i+1] =
                ((PUCHAR)identifyData->FirmwareRevision)[i];
            }

            //
            // Copy as much the return data as possible
            //
            RtlMoveMemory (
                          Srb->DataBuffer,
                          &inquiryData,
                          Srb->DataTransferLength > sizeof (INQUIRYDATA) ? 
                          sizeof (INQUIRYDATA) : 
                          Srb->DataTransferLength
                          );

            status = SRB_STATUS_SUCCESS;
        }

        break;

    case SCSIOP_TEST_UNIT_READY:

        if (deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_MEDIA_STATUS_ENABLED) {

            //
            // Select device 0 or 1.
            //

            SelectIdeDevice(baseIoAddress1, Srb->TargetId, 0);
            IdePortOutPortByte(baseIoAddress1->Command,IDE_COMMAND_GET_MEDIA_STATUS);

            //
            // Wait for busy. If media has not changed, return success
            //

            WaitOnBusy(baseIoAddress1,statusByte);

            if (!(statusByte & IDE_STATUS_ERROR)) {
                deviceExtension->ExpectingInterrupt = FALSE;
                status = SRB_STATUS_SUCCESS;
            } else {
                errorByte = IdePortInPortByte(baseIoAddress1->Error);
                if (errorByte == IDE_ERROR_DATA_ERROR) {

                    //
                    // Special case: If current media is write-protected,
                    // the 0xDA command will always fail since the write-protect bit
                    // is sticky,so we can ignore this error
                    //

                    GetBaseStatus(baseIoAddress1, statusByte);
                    status = SRB_STATUS_SUCCESS;

                } else {

                    deviceExtension->ReturningMediaStatus = errorByte;

                    //
                    // we need to set the scsi status here. Otherwise we 
                    // won't issue a request sense
                    //
                    Srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
                    Srb->SrbStatus = SRB_STATUS_ERROR;

                    status = SRB_STATUS_ERROR;
                }
            }
        } else {
            status = SRB_STATUS_SUCCESS;
        }

        break;

    case SCSIOP_VERIFY:
#ifdef ENABLE_48BIT_LBA

        if (deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_48BIT_LBA) {

            status = IdeVerifyExt(HwDeviceExtension, Srb);
            break;
        }
#endif
        status = IdeVerify(HwDeviceExtension,Srb);

        break;
#ifdef  DIDE_CPQ_BM
    case SCSIOP_DVD_READ:
    case SCSIOP_REPORT_KEY:
    case SCSIOP_SEND_KEY:
    case SCSIOP_READ_DVD_STRUCTURE:
#endif
    case SCSIOP_READ:
    case SCSIOP_WRITE:

#ifdef ENABLE_48BIT_LBA

        if (deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_48BIT_LBA) {

            status = IdeReadWriteExt(HwDeviceExtension,
                                     Srb);
            break;
        }
#endif
        status = IdeReadWrite(HwDeviceExtension,
                              Srb);
        break;

    case SCSIOP_START_STOP_UNIT:

        //
        //Determine what type of operation we should perform
        //
        cdb = (PCDB)Srb->Cdb;

        if (cdb->START_STOP.LoadEject == 1) {

            SelectIdeLine(baseIoAddress1, Srb->TargetId >> 1);

            //
            // Eject media,
            // first select device 0 or 1.
            //
            WaitOnBusy(baseIoAddress1,statusByte);

            SelectIdeDevice(baseIoAddress1, Srb->TargetId, 0);
            IdePortOutPortByte(baseIoAddress1->Command,IDE_COMMAND_MEDIA_EJECT);
        }
        status = SRB_STATUS_SUCCESS;
        break;

    case SCSIOP_MEDIUM_REMOVAL:

        cdb = (PCDB)Srb->Cdb;

        SelectIdeLine(baseIoAddress1, Srb->TargetId >> 1);

        WaitOnBusy(baseIoAddress1,statusByte);

        SelectIdeDevice(baseIoAddress1, Srb->TargetId, 0);
        if (cdb->MEDIA_REMOVAL.Prevent == TRUE) {
            IdePortOutPortByte(baseIoAddress1->Command,IDE_COMMAND_DOOR_LOCK);
        } else {
            IdePortOutPortByte(baseIoAddress1->Command,IDE_COMMAND_DOOR_UNLOCK);
        }

        status = SRB_STATUS_SUCCESS;

        WaitOnBusy(baseIoAddress1,statusByte);

        if (statusByte & IDE_STATUS_ERROR) {

            errorByte = IdePortInPortByte(baseIoAddress1->Error);

            status = MapError(HwDeviceExtension, Srb);

        }

        break;

    case SCSIOP_REQUEST_SENSE:
        // this function makes sense buffers to report the results
        // of the original GET_MEDIA_STATUS command

        if ((deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_MEDIA_STATUS_ENABLED) && 
            (Srb->DataTransferLength >= sizeof(SENSE_DATA))) {
            status = IdeBuildSenseBuffer(HwDeviceExtension, Srb);
        } else {
            status = SRB_STATUS_INVALID_REQUEST;
        }
        break;

    case SCSIOP_SYNCHRONIZE_CACHE:

        DebugPrint((1,
                    "Flush the cache for IDE device %d\n",
                    Srb->TargetId
                   ));

        status = SRB_STATUS_SUCCESS;

        //
        // Send the flush command if one exists
        //
#ifdef ENABLE_48BIT_LBA
            if (deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_48BIT_LBA) {

                if (deviceExtension->DeviceParameters[Srb->TargetId].IdeFlushCommandExt != 
                    IDE_COMMAND_NO_FLUSH) {

                    status = IdeSendFlushCommandExt(HwDeviceExtension, Srb);
                }

            } else {
#endif

                if (deviceExtension->DeviceParameters[Srb->TargetId].IdeFlushCommand != 
                    IDE_COMMAND_NO_FLUSH) {

                    status = IdeSendFlushCommand(deviceExtension, Srb);
                }
#ifdef ENABLE_48BIT_LBA
            }
#endif
        break;

    case SCSIOP_FORMAT_UNIT:
        if ( IsNEC_98 ) {
            // 
            // Support physical format of fixed disk.
            // It is meaningful for SCSI device.
            // So, we do not execute it on IDE device.
            // But we need to return the success in order to fit with SCSI
            // 
            status = SRB_STATUS_SUCCESS;
            break;
        }

    default:

        DebugPrint((1,
                    "IdeSendCommand: Unsupported command %x\n",
                    Srb->Cdb[0]));

        status = SRB_STATUS_INVALID_REQUEST;

    } // end switch

    return status;

} // end IdeSendCommand()

ULONG
IdeSendPassThroughCommand(
                         IN PVOID HwDeviceExtension,
                         IN PSCSI_REQUEST_BLOCK Srb
                         )

/*++

Routine Description:

    Program ATA registers for IDE disk transfer.

Arguments:

    HwDeviceExtension - ATAPI driver storage.
    Srb - System request block.

Return Value:

    SRB status (pending if all goes well).

--*/

{
    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
    PIDE_REGISTERS_1     baseIoAddress1  = &deviceExtension->BaseIoAddress1;
    PIDE_REGISTERS_2     baseIoAddress2  = &deviceExtension->BaseIoAddress2;
    PCDB cdb;
    UCHAR statusByte,errorByte;
    ULONG status;
    PATA_PASS_THROUGH       ataPassThroughData;
    PIDEREGS                pIdeReg;

    ataPassThroughData = Srb->DataBuffer;
    pIdeReg            = &ataPassThroughData->IdeReg;

    //
    // select the right device
    //
    CLRMASK (pIdeReg->bDriveHeadReg, 0xb0);
    pIdeReg->bDriveHeadReg |= (UCHAR) (((Srb->TargetId & 0x1) << 4) | 0xA0);

    SelectIdeDevice(baseIoAddress1, Srb->TargetId, pIdeReg->bDriveHeadReg);

    //
    // check to see if this is a "no-op" SRB 
    //
    if (pIdeReg->bReserved & ATA_PTFLAGS_NO_OP) {

        ULONG repeatCount = (ULONG)ataPassThroughData->IdeReg.bSectorCountReg;
        UCHAR busyWait = pIdeReg->bSectorNumberReg;

        //
        // wait for busy if this is set
        //
        if (busyWait != 0) {

            ULONG busyWaitTime;

            if (busyWait > 30) {

                busyWait = 30;
            }

            busyWaitTime = busyWait * 1000;

            GetStatus(baseIoAddress1, statusByte);

            WaitOnBusyUntil(baseIoAddress1, statusByte, busyWaitTime);
        }

        if (repeatCount <= 0) {
            repeatCount = 1;
        }

        while (repeatCount) {
            repeatCount--;

            KeStallExecutionProcessor(100);

            //
            // get a copy of the task file registers
            //
            AtapiTaskRegisterSnapshot (
                                      baseIoAddress1,
                                      pIdeReg
                                      );
        }

        return SRB_STATUS_SUCCESS;
    }

    if (pIdeReg->bReserved & ATA_PTFLAGS_EMPTY_CHANNEL_TEST) {

#ifdef DPC_FOR_EMPTY_CHANNEL
        if (status=IdePortChannelEmptyQuick(baseIoAddress1, baseIoAddress2, 
                                            deviceExtension->MaxIdeDevice, &deviceExtension->CurrentIdeDevice,
                                            &deviceExtension->MoreWait, &deviceExtension->NoRetry)) {
            if (status==STATUS_RETRY) {
                return SRB_STATUS_PENDING;
            }
            return SRB_STATUS_SUCCESS;
        } else {
            return SRB_STATUS_ERROR;
        }
#endif

        if (IdePortChannelEmpty(baseIoAddress1, baseIoAddress2, deviceExtension->MaxIdeDevice)) {

            return SRB_STATUS_SUCCESS;

        } else {

            return SRB_STATUS_ERROR;
        }
    }


    if (pIdeReg->bReserved & ATA_PTFLAGS_INLINE_HARD_RESET) {

        IdeHardReset (
                     baseIoAddress1,
                     baseIoAddress2,
                     FALSE,
                     TRUE
                     );

        //
        // re-select the right device
        //
        SelectIdeDevice(baseIoAddress1, Srb->TargetId, pIdeReg->bDriveHeadReg);
    }

    GetStatus(baseIoAddress1, statusByte);

    if (statusByte & IDE_STATUS_BUSY) {
        DebugPrint((1,
                    "IdeSendPassThroughCommand: Returning BUSY status\n"));
        return SRB_STATUS_BUSY;
    }
    if (pIdeReg->bReserved & ATA_PTFLAGS_STATUS_DRDY_REQUIRED) {

        if (!(statusByte & IDE_STATUS_DRDY)) {

            if ((statusByte == 0)  &&
                (deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_SONY_MEMORYSTICK)) {
                statusByte = IDE_STATUS_DRDY;
            } else {
                DebugPrint((1,
                            "IdeSendPassThroughCommand: DRDY not ready\n"));
                return SRB_STATUS_BUSY;
            }
        }
    }
    if (pIdeReg->bCommandReg != IDE_COMMAND_ATAPI_RESET) {


#if 1
        //
        // if identifydata in device extension is valid, use it
        // send it to the device if enum probling flag is set
        //
        if ((deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_IDENTIFY_VALID) && 
            (pIdeReg->bCommandReg == IDE_COMMAND_IDENTIFY) &&
            (!(pIdeReg->bFeaturesReg & ATA_PTFLAGS_ENUM_PROBING))) {

            ASSERT(!(deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_REMOVABLE_DRIVE));

            DebugPrint((1, "Bypassing identify command\n"));

            RtlMoveMemory(ataPassThroughData->DataBuffer, &(deviceExtension->IdentifyData[Srb->TargetId]), 
                          ataPassThroughData->DataBufferSize);

            return SRB_STATUS_SUCCESS;

        }
#endif
        //
        // Set data buffer pointer and bytes left.
        //

        deviceExtension->DataBuffer = ataPassThroughData->DataBuffer;
        deviceExtension->BytesLeft = ataPassThroughData->DataBufferSize;

        //
        // Indicate expecting an interrupt.
        //

        deviceExtension->ExpectingInterrupt = TRUE;
        status = SRB_STATUS_PENDING;

        IdePortOutPortByte(baseIoAddress1->Error,        pIdeReg->bFeaturesReg);
        IdePortOutPortByte(baseIoAddress1->BlockCount,   pIdeReg->bSectorCountReg);
        IdePortOutPortByte(baseIoAddress1->BlockNumber,  pIdeReg->bSectorNumberReg);
        IdePortOutPortByte(baseIoAddress1->CylinderLow,  pIdeReg->bCylLowReg);
        IdePortOutPortByte(baseIoAddress1->CylinderHigh, pIdeReg->bCylHighReg);
        IdePortOutPortByte(baseIoAddress1->Command,      pIdeReg->bCommandReg);

    } else {

        //
        // perform sync. atapi soft reset because this command doesn't generate interrupts
        //
        AtapiSoftReset(baseIoAddress1, baseIoAddress2, Srb->TargetId & 0x1, FALSE);
        status = SRB_STATUS_SUCCESS;
    }

    DebugPrint ((1, "IdeSendPassThroughCommand: 0x%x 0x%x command = 0x%x\n", baseIoAddress1->RegistersBaseAddress, Srb->TargetId, pIdeReg->bCommandReg));

    return status;

} // end IdeSendPassThroughCommand()


VOID
IdeMediaStatus(
              BOOLEAN EnableMSN,
              IN PVOID HwDeviceExtension,
              ULONG DeviceNumber
              )
/*++

Routine Description:

    Enables disables media status notification

Arguments:

HwDeviceExtension - ATAPI driver storage.

--*/

{
    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
    PIDE_REGISTERS_1     baseIoAddress = &deviceExtension->BaseIoAddress1;
    UCHAR statusByte,errorByte;


    if (EnableMSN == TRUE) {

        //
        // If supported enable Media Status Notification support
        //

        if ((deviceExtension->DeviceFlags[DeviceNumber] & DFLAGS_MSN_SUPPORT)) {

            //
            // enable
            //
            SelectIdeDevice(baseIoAddress, DeviceNumber, 0);
            IdePortOutPortByte(baseIoAddress->Error,(UCHAR) (0x95));
            IdePortOutPortByte(baseIoAddress->Command,
                               IDE_COMMAND_SET_FEATURE);

            WaitOnBaseBusy(baseIoAddress,statusByte);

            if (statusByte & IDE_STATUS_ERROR) {
                //
                // Read the error register.
                //
                errorByte = IdePortInPortByte(baseIoAddress->Error);

                DebugPrint((1,
                            "IdeMediaStatus: Error enabling media status. Status %x, error byte %x\n",
                            statusByte,
                            errorByte));
            } else {
                deviceExtension->DeviceFlags[DeviceNumber] |= DFLAGS_MEDIA_STATUS_ENABLED;
                DebugPrint((1,"IdeMediaStatus: Media Status Notification Supported\n"));
                deviceExtension->ReturningMediaStatus = 0;

            }

        }
    } else { // end if EnableMSN == TRUE

        //
        // disable if previously enabled
        //
        if ((deviceExtension->DeviceFlags[DeviceNumber] & DFLAGS_MEDIA_STATUS_ENABLED)) {

            SelectIdeDevice(baseIoAddress, DeviceNumber, 0);
            IdePortOutPortByte(baseIoAddress->Error,(UCHAR) (0x31));
            IdePortOutPortByte(baseIoAddress->Command,
                               IDE_COMMAND_SET_FEATURE);

            WaitOnBaseBusy(baseIoAddress,statusByte);
            CLRMASK (deviceExtension->DeviceFlags[DeviceNumber], DFLAGS_MEDIA_STATUS_ENABLED);
        }


    }

}

ULONG
IdeBuildSenseBuffer(
                   IN PVOID HwDeviceExtension,
                   IN PSCSI_REQUEST_BLOCK Srb
                   )

/*++

Routine Description:

    Builts an artificial sense buffer to report the results of a GET_MEDIA_STATUS
    command. This function is invoked to satisfy the SCSIOP_REQUEST_SENSE.
Arguments:

    HwDeviceExtension - ATAPI driver storage.
    Srb - System request block.

Return Value:

    SRB status (ALWAYS SUCCESS).

--*/

{
    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
    ULONG status;
    PSENSE_DATA  senseBuffer = (PSENSE_DATA)Srb->DataBuffer;

    if (senseBuffer) {

        if (deviceExtension->ReturningMediaStatus & IDE_ERROR_MEDIA_CHANGE) {

            senseBuffer->ErrorCode = 0x70;
            senseBuffer->Valid     = 1;
            senseBuffer->AdditionalSenseLength = 0xb;
            senseBuffer->SenseKey =  SCSI_SENSE_UNIT_ATTENTION;
            senseBuffer->AdditionalSenseCode = SCSI_ADSENSE_MEDIUM_CHANGED;
            senseBuffer->AdditionalSenseCodeQualifier = 0;
        } else if (deviceExtension->ReturningMediaStatus & IDE_ERROR_MEDIA_CHANGE_REQ) {

            senseBuffer->ErrorCode = 0x70;
            senseBuffer->Valid     = 1;
            senseBuffer->AdditionalSenseLength = 0xb;
            senseBuffer->SenseKey =  SCSI_SENSE_UNIT_ATTENTION;
            senseBuffer->AdditionalSenseCode = SCSI_ADSENSE_OPERATOR_REQUEST;
            senseBuffer->AdditionalSenseCodeQualifier = SCSI_SENSEQ_MEDIUM_REMOVAL;
        } else if (deviceExtension->ReturningMediaStatus & IDE_ERROR_END_OF_MEDIA) {

            senseBuffer->ErrorCode = 0x70;
            senseBuffer->Valid     = 1;
            senseBuffer->AdditionalSenseLength = 0xb;
            senseBuffer->SenseKey =  SCSI_SENSE_NOT_READY;
            senseBuffer->AdditionalSenseCode = SCSI_ADSENSE_NO_MEDIA_IN_DEVICE;
            senseBuffer->AdditionalSenseCodeQualifier = 0;
        } else if (deviceExtension->ReturningMediaStatus & IDE_ERROR_DATA_ERROR) {

            senseBuffer->ErrorCode = 0x70;
            senseBuffer->Valid     = 1;
            senseBuffer->AdditionalSenseLength = 0xb;
            senseBuffer->SenseKey =  SCSI_SENSE_DATA_PROTECT;
            senseBuffer->AdditionalSenseCode = 0;
            senseBuffer->AdditionalSenseCodeQualifier = 0;
        }

        return SRB_STATUS_SUCCESS;
    }
    return SRB_STATUS_ERROR;

}// End of IdeBuildSenseBuffer




BOOLEAN
AtapiStartIo(
            IN PVOID HwDeviceExtension,
            IN PSCSI_REQUEST_BLOCK Srb
            )

/*++

Routine Description:

    This routine is called from the port driver synchronized
    with the kernel to start an IO request.

Arguments:

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

Return Value:

    TRUE

--*/

{
    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
    ULONG status;


#if DBG

    //
    // Code to simulate a hard-hang of an IDE device.
    //

    if (IdeDebugSimulateHardHang) {
    
        Srb->SrbStatus = SRB_STATUS_BUSY;

        //
        // Indicate command complete.
        //

        IdePortNotification(IdeRequestComplete,
                            deviceExtension,
                            Srb);

        //
        // Indicate ready for next request.
        //

        IdePortNotification(IdeNextRequest,
                            deviceExtension,
                            NULL);

        //
        // Mark all the devices deadmeat
        //

        IdePortNotification(IdeAllDeviceMissing,
                            deviceExtension,
                            NULL);

        return TRUE;
    }
#endif // DBG

    //
    // Determine which function.
    //

    switch (Srb->Function) {
    
    case SRB_FUNCTION_ATA_POWER_PASS_THROUGH:
    case SRB_FUNCTION_FLUSH:
    case SRB_FUNCTION_SHUTDOWN:
    case SRB_FUNCTION_ATA_PASS_THROUGH:
    case SRB_FUNCTION_ATA_PASS_THROUGH_EX:
    case SRB_FUNCTION_EXECUTE_SCSI:

        //
        // Sanity check. Only one request can be outstanding on a
        // controller.
        //

        if (deviceExtension->CurrentSrb) {

            DebugPrint((1,
                        "AtapiStartIo: Already have a request!\n"));
            Srb->SrbStatus = SRB_STATUS_BUSY;
            IdePortNotification(IdeRequestComplete,
                                deviceExtension,
                                Srb);
            return FALSE;
        }

        //
        // Indicate that a request is active on the controller.
        //

        deviceExtension->CurrentSrb = Srb;

        //
        // Send command to device.
        //
        if (Srb->Function == SRB_FUNCTION_ATA_PASS_THROUGH_EX) {

            //
            // ATA PASSTHROUGH EX
            status = IdeSendAtaPassThroughExCommand(HwDeviceExtension,
                                                    Srb
                                                    );

        } else if ((Srb->Function == SRB_FUNCTION_ATA_PASS_THROUGH) ||
                   (Srb->Function == SRB_FUNCTION_ATA_POWER_PASS_THROUGH)) {

            // ATA_PASSTHORUGH
            status = IdeSendPassThroughCommand(HwDeviceExtension,
                                               Srb);

        } else if ((deviceExtension->DeviceFlags[Srb->TargetId] & 
                    (DFLAGS_ATAPI_DEVICE | DFLAGS_DEVICE_PRESENT)) ==
                   (DFLAGS_ATAPI_DEVICE | DFLAGS_DEVICE_PRESENT)) {

            status = AtapiSendCommand(HwDeviceExtension,
                                      Srb);

        } else if ((Srb->Function == SRB_FUNCTION_FLUSH) ||
                   (Srb->Function == SRB_FUNCTION_SHUTDOWN)) {

#ifdef ENABLE_48BIT_LBA
            if (deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_48BIT_LBA) {

                status = IdeSendFlushCommandExt(HwDeviceExtension,
                                                Srb);
            } else {
#endif

                status = IdeSendFlushCommand(HwDeviceExtension,
                                             Srb);

#ifdef ENABLE_48BIT_LBA
            }
#endif

        } else if (deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_DEVICE_PRESENT) {

            status = IdeSendCommand(HwDeviceExtension,
                                    Srb);

        } else {

            status = SRB_STATUS_SELECTION_TIMEOUT;
        }

        break;

    case SRB_FUNCTION_ABORT_COMMAND:

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

        if (!deviceExtension->CurrentSrb) {

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

            //
            // Complete abort SRB.
            //

            status = SRB_STATUS_ABORT_FAILED;

            break;
        }

        //
        // Abort function indicates that a request timed out.
        // Call reset routine. Card will only be reset if
        // status indicates something is wrong.
        // Fall through to reset code.
        //

    case SRB_FUNCTION_RESET_BUS:

        //
        // Reset Atapi and SCSI bus.
        //

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

        SelectIdeLine(&deviceExtension->BaseIoAddress1, Srb->TargetId >> 1);

        if (!AtapiSyncResetController(deviceExtension,
                                      Srb->PathId)) {

            DebugPrint((1,"AtapiStartIo: Reset bus failed\n"));

            //
            // Log reset failure.
            //

            IdePortLogError(
                           HwDeviceExtension,
                           NULL,
                           0,
                           0,
                           0,
                           SP_INTERNAL_ADAPTER_ERROR,
                           5 << 8
                           );

            status = SRB_STATUS_ERROR;

        } else {

            status = SRB_STATUS_SUCCESS;
        }

        break;

    case SRB_FUNCTION_IO_CONTROL:

        if (deviceExtension->CurrentSrb) {

            DebugPrint((1,
                        "AtapiStartIo: Already have a request!\n"));
            Srb->SrbStatus = SRB_STATUS_BUSY;
            IdePortNotification(IdeRequestComplete,
                                deviceExtension,
                                Srb);
            return FALSE;
        }

        //
        // Indicate that a request is active on the controller.
        //

        deviceExtension->CurrentSrb = Srb;

        if (strlen("SCSIDISK") != RtlCompareMemory(((PSRB_IO_CONTROL)(Srb->DataBuffer))->Signature,"SCSIDISK",strlen("SCSIDISK"))) {

            DebugPrint((1,
                        "AtapiStartIo: IoControl signature incorrect. Send %s, expected %s\n",
                        ((PSRB_IO_CONTROL)(Srb->DataBuffer))->Signature,
                        "SCSIDISK"));

            status = SRB_STATUS_INVALID_REQUEST;
            break;
        }

        switch (((PSRB_IO_CONTROL)(Srb->DataBuffer))->ControlCode) {
        
        case IOCTL_SCSI_MINIPORT_SMART_VERSION: {

                PGETVERSIONINPARAMS versionParameters = (PGETVERSIONINPARAMS)(((PUCHAR)Srb->DataBuffer) + sizeof(SRB_IO_CONTROL));
                UCHAR deviceNumber;
                UCHAR channelNo;

                //
                // Version and revision per SMART 1.03
                //

                versionParameters->bVersion = 1;
                versionParameters->bRevision = 1;
                versionParameters->bReserved = 0;

                //
                // Indicate that support for IDE IDENTIFY, ATAPI IDENTIFY and SMART commands.
                //

                versionParameters->fCapabilities = (CAP_ATA_ID_CMD | CAP_ATAPI_ID_CMD | CAP_SMART_CMD);

                //
                // This is done because of how the IOCTL_SCSI_MINIPORT
                // determines 'targetid's'. Disk.sys places the real target id value
                // in the DeviceMap field. Once we do some parameter checking, the value passed
                // back to the application will be determined.
                //


                //
                // HACK: atapi doesn't have the channel number. So it uses the hack below.
                // this should work on non native mode IDE controllers
                //
                channelNo = (deviceExtension->PrimaryAddress)? 0:1;

                //
                // the bIDEDeviceMap is a bit map, with the bits defined as follows
                // bit 0 - IDE drive as master on Primary channel
                // bit 1 - IDE drive as slave on Primary channel
                // bit 2 - IDE drive as master on Secondary channel
                // bit 3 - IDE drive as slave on Secondary Channel
                // bit 4 - ATAPI drive as master on Primary Channle
                // bit 5 - ATAPI drive as slave on Primary Channle
                // bit 6 - ATAPI drive as master on secondary Channle
                // bit 7 - ATAPI drive as slave on secondary Channle
                //
                // since we have an FDO per channel, we can only fill in the fields
                // pertinent to this channel. 
                //

                versionParameters->bIDEDeviceMap = 0;

                //
                // Master device
                //
                deviceNumber = 0;
                if (deviceExtension->DeviceFlags[deviceNumber] & DFLAGS_DEVICE_PRESENT) {
                    if (deviceExtension->DeviceFlags[deviceNumber] & DFLAGS_ATAPI_DEVICE) {

                        deviceNumber += channelNo*2 + 4;

                    } else {

                        deviceNumber += channelNo*2;

                    }

                    versionParameters->bIDEDeviceMap |= (1 << deviceNumber);
                }

                //
                // slave device
                //
                deviceNumber = 1;
                if (deviceExtension->DeviceFlags[deviceNumber] & DFLAGS_DEVICE_PRESENT) {
                    if (deviceExtension->DeviceFlags[deviceNumber] & DFLAGS_ATAPI_DEVICE) {

                        deviceNumber += channelNo*2 + 4;

                    } else {

                        deviceNumber += channelNo*2;

                    }

                    versionParameters->bIDEDeviceMap |= (1 << deviceNumber);
                }


                //if (!(deviceExtension->DeviceFlags[deviceNumber] & DFLAGS_DEVICE_PRESENT) ||
                 //   (deviceExtension->DeviceFlags[deviceNumber] & DFLAGS_ATAPI_DEVICE)) {
//
 //                   status = SRB_STATUS_SELECTION_TIMEOUT;
  //                  break;
   //             }

                status = SRB_STATUS_SUCCESS;
                break;
            }

        case IOCTL_SCSI_MINIPORT_IDENTIFY: {

                PSENDCMDOUTPARAMS cmdOutParameters = (PSENDCMDOUTPARAMS)(((PUCHAR)Srb->DataBuffer) + sizeof(SRB_IO_CONTROL));
                SENDCMDINPARAMS   cmdInParameters = *(PSENDCMDINPARAMS)(((PUCHAR)Srb->DataBuffer) + sizeof(SRB_IO_CONTROL));
                ULONG             i;
                UCHAR             targetId;


                if (cmdInParameters.irDriveRegs.bCommandReg == ID_CMD) {

                    //
                    // Extract the target.
                    //

                    targetId = cmdInParameters.bDriveNumber;

                    if (!(deviceExtension->DeviceFlags[targetId] & DFLAGS_DEVICE_PRESENT) ||
                        (deviceExtension->DeviceFlags[targetId] & DFLAGS_ATAPI_DEVICE)) {

                        status = SRB_STATUS_SELECTION_TIMEOUT;
                        break;
                    }

                    //
                    // Zero the output buffer
                    //

                    for (i = 0; i < (sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1); i++) {
                        ((PUCHAR)cmdOutParameters)[i] = 0;
                    }

                    //
                    // Build status block.
                    //

                    cmdOutParameters->cBufferSize = IDENTIFY_BUFFER_SIZE;
                    cmdOutParameters->DriverStatus.bDriverError = 0;
                    cmdOutParameters->DriverStatus.bIDEError = 0;

                    //
                    // Extract the identify data from the device extension.
                    //

                    RtlMoveMemory (cmdOutParameters->bBuffer, &deviceExtension->IdentifyData[targetId], IDENTIFY_DATA_SIZE);

                    status = SRB_STATUS_SUCCESS;


                } else {
                    status = SRB_STATUS_INVALID_REQUEST;
                }
                break;
            }

        case  IOCTL_SCSI_MINIPORT_READ_SMART_ATTRIBS:
        case  IOCTL_SCSI_MINIPORT_READ_SMART_THRESHOLDS:
        case  IOCTL_SCSI_MINIPORT_ENABLE_SMART:
        case  IOCTL_SCSI_MINIPORT_DISABLE_SMART:
        case  IOCTL_SCSI_MINIPORT_RETURN_STATUS:
        case  IOCTL_SCSI_MINIPORT_ENABLE_DISABLE_AUTOSAVE:
        case  IOCTL_SCSI_MINIPORT_SAVE_ATTRIBUTE_VALUES:
        case  IOCTL_SCSI_MINIPORT_EXECUTE_OFFLINE_DIAGS:
        case  IOCTL_SCSI_MINIPORT_ENABLE_DISABLE_AUTO_OFFLINE:
#ifdef ENABLE_SMARTLOG_SUPPORT
        case  IOCTL_SCSI_MINIPORT_READ_SMART_LOG:
        case  IOCTL_SCSI_MINIPORT_WRITE_SMART_LOG:
#endif

            status = IdeSendSmartCommand(HwDeviceExtension,Srb);
            break;

        default :

            status = SRB_STATUS_INVALID_REQUEST;
            break;

        }

        break;

    default:

        //
        // Indicate unsupported command.
        //

        status = SRB_STATUS_INVALID_REQUEST;

        break;

    } // end switch

    //
    // Check if command complete.
    //

    if (status != SRB_STATUS_PENDING) {

        DebugPrint((2,
                    "AtapiStartIo: Srb %x complete with status %x\n",
                    Srb,
                    status));

        //
        // Clear current SRB.
        //

        deviceExtension->CurrentSrb = NULL;

        //
        // Set status in SRB.
        //

        Srb->SrbStatus = (UCHAR)status;

        //
        // Indicate command complete.
        //

        IdePortNotification(IdeRequestComplete,
                            deviceExtension,
                            Srb);

        //
        // Indicate ready for next request.
        //

        IdePortNotification(IdeNextRequest,
                            deviceExtension,
                            NULL);
    }

    return TRUE;

} // end AtapiStartIo()

BOOLEAN
AtapiSyncResetController(
                        IN PVOID  HwDeviceExtension,
                        IN ULONG  PathId
                        )
{
    ULONG   callAgain = 0;
    BOOLEAN result;

    do {

        result = AtapiResetController(
                                     HwDeviceExtension,
                                     PathId,
                                     &callAgain
                                     );

    } while (callAgain);

    return result;
}


NTSTATUS
IdeHardReset (
             PIDE_REGISTERS_1     BaseIoAddress1,
             PIDE_REGISTERS_2     BaseIoAddress2,
             BOOLEAN              InterruptOff,
             BOOLEAN              Sync
             )
{
    UCHAR resetByte;

    DebugPrint((1,
                "IdeHardReset: Resetting controller.\n"));

    //
    // Kingston DP-ATA/20 pcmcia flash card
    //
    // if we don't make sure we select master device,
    // later when we check for busy status, we will
    // get the non-existing slave status
    //
    IdePortOutPortByte (BaseIoAddress1->DriveSelect, 0xA0);

    IdePortOutPortByte (BaseIoAddress2->DeviceControl, IDE_DC_RESET_CONTROLLER | IDE_DC_DISABLE_INTERRUPTS);

    //
    // ATA-2 spec requires a minimum of 5 microsec stall here
    //
    KeStallExecutionProcessor (10);

    if (InterruptOff) {
        resetByte = IDE_DC_DISABLE_INTERRUPTS;

    } else {
        resetByte = IDE_DC_REENABLE_CONTROLLER;
    }

    IdePortOutPortByte (BaseIoAddress2->DeviceControl, resetByte);

    //
    // ATA-2 spec requires a minimum of 400 ns stall here
    //
    KeStallExecutionProcessor (1);

    if (Sync) {

        UCHAR deviceSelect;
        UCHAR status;
        ULONG sec;                                                      
        ULONG i;                                                        
        UCHAR statusByte;

        WaitOnBusyUntil(BaseIoAddress1, statusByte, 500);

        IdePortOutPortByte (BaseIoAddress1->DriveSelect, 0xa0);
        deviceSelect = IdePortInPortByte(BaseIoAddress1->DriveSelect);
        if (deviceSelect != 0xa0) {

            //
            // slave only channel
            //
            KeStallExecutionProcessor(1000);                     
            IdePortOutPortByte (BaseIoAddress1->DriveSelect, 0xb0);
        }

        //
        // ATA-2 spec allows a maximum of 31s for both master and slave device to come back from reset
        //
        for (sec=0; sec<31; sec++) {

            /**/                                                        
            /* one second loop */                                       
            /**/                                                        
            for (i=0; i<2500; i++) {
                GetStatus(BaseIoAddress1, status);                       
                if (status & IDE_STATUS_BUSY) {
                    KeStallExecutionProcessor(400);                     
                    continue;                                           
                } else {
                    break;                                              
                }                                                       
            }                                                           
            if (status == 0xff) {
                break;                                                  
            } else if (status & IDE_STATUS_BUSY) {
                DebugPrint ((0, "ATAPI: IdeHardReset WaitOnBusy failed. status = 0x%x\n", (ULONG) (status))); 
            } else {
                break;                                                  
            }                                                           
        }                                                               

        if (status & IDE_STATUS_BUSY) {

            DebugPrint ((0, "ATAPI: IdeHardReset WaitOnBusy failed. status = 0x%x\n", (ULONG) (status))); 

            return STATUS_UNSUCCESSFUL;

        } else {

            return STATUS_SUCCESS;
        }

    } else {

        return STATUS_SUCCESS;
    }
}


VOID
AtapiTaskRegisterSnapshot (
                          IN PIDE_REGISTERS_1 CmdRegBase,
                          IN OUT PIDEREGS     IdeReg
                          )
{
    ASSERT(IdeReg);

    IdeReg->bFeaturesReg     = IdePortInPortByte(CmdRegBase->Error);
    IdeReg->bSectorCountReg  = IdePortInPortByte(CmdRegBase->BlockCount);
    IdeReg->bSectorNumberReg = IdePortInPortByte(CmdRegBase->BlockNumber);
    IdeReg->bCylLowReg       = IdePortInPortByte(CmdRegBase->CylinderLow);
    IdeReg->bCylHighReg      = IdePortInPortByte(CmdRegBase->CylinderHigh);
    IdeReg->bDriveHeadReg    = IdePortInPortByte(CmdRegBase->DriveSelect);
    IdeReg->bCommandReg      = IdePortInPortByte(CmdRegBase->Command);

    return;
} // AtapiTaskFileSnapshot

BOOLEAN
GetAtapiIdentifyQuick (
    IN PIDE_REGISTERS_1 BaseIoAddress1,
    IN PIDE_REGISTERS_2 BaseIoAddress2,
    IN ULONG DeviceNumber,
    OUT PIDENTIFY_DATA IdentifyData
    )
{
    UCHAR statusByte;
    ULONG i;

    SelectIdeDevice(BaseIoAddress1, DeviceNumber, 0);

    GetStatus(BaseIoAddress1, statusByte);

    if (statusByte & IDE_STATUS_BUSY) {

        return FALSE;
    }

    IdePortOutPortByte(BaseIoAddress1->Command, IDE_COMMAND_ATAPI_IDENTIFY);

    WaitOnBusyUntil(BaseIoAddress1, statusByte, 500);

    if ((statusByte & IDE_STATUS_BUSY) ||
        (statusByte & IDE_STATUS_ERROR)) {

        return FALSE;
    }
    
    if (statusByte & IDE_STATUS_DRQ) {

        ReadBuffer(BaseIoAddress1,
                   (PUSHORT)IdentifyData,
                   sizeof (IDENTIFY_DATA) / 2);

    }

    GetStatus(BaseIoAddress1, statusByte);

    //
    // pull out any remaining bytes and throw away.
    //
    i=0;
    while ((statusByte & IDE_STATUS_DRQ) && (i < 100)) {

        READ_PORT_USHORT(BaseIoAddress1->Data);

        GetStatus(BaseIoAddress1, statusByte);

        KeStallExecutionProcessor(50);

        i++;
    }

    return TRUE;

}

ULONG
IdeSendAtaPassThroughExCommand(
    IN PVOID HwDeviceExtension, 
    IN PSCSI_REQUEST_BLOCK Srb 
    )

/*++

Routine Description:

    Programs ATA registers 

Arguments:

    HwDeviceExtension - ATAPI driver storage.
    Srb - System request block.

Return Value:

    SRB status (pending if all goes well).

--*/

{
    PHW_DEVICE_EXTENSION deviceExtension = HwDeviceExtension;
    PIDE_REGISTERS_1     baseIoAddress1  = &deviceExtension->BaseIoAddress1;
    PIDE_REGISTERS_2     baseIoAddress2  = &deviceExtension->BaseIoAddress2;
    UCHAR statusByte,errorByte;
    ULONG status;
    PIDEREGS                pIdeReg;

    pIdeReg             = (PIDEREGS) Srb->Cdb;

    ASSERT(!SRB_USES_DMA(Srb));

    //
    // select the right device
    //
    CLRMASK (pIdeReg->bDriveHeadReg, 0xb0);
    pIdeReg->bDriveHeadReg |= (UCHAR) (((Srb->TargetId & 0x1) << 4) | 0xA0);

    SelectIdeDevice(baseIoAddress1, Srb->TargetId, pIdeReg->bDriveHeadReg);

    GetStatus(baseIoAddress1, statusByte);

    WaitOnBusyUntil(baseIoAddress1, statusByte, 200);

    if (statusByte & IDE_STATUS_BUSY) {

        DebugPrint((0,
                    "ataPassThrough: Returning status 0x%x\n",
                    statusByte
                    ));

        return SRB_STATUS_BUSY;
    }

    if (pIdeReg->bReserved & ATA_PTFLAGS_STATUS_DRDY_REQUIRED) {

        if (!(statusByte & IDE_STATUS_DRDY)) {

            DebugPrint((0,
                        "ataPassThrough: DRDY not ready\n"
                        ));

            return SRB_STATUS_BUSY;
        }
    }

    //
    // Set data buffer pointer and bytes left.
    //

    deviceExtension->DataBuffer = Srb->DataBuffer;
    deviceExtension->BytesLeft = Srb->DataTransferLength;

    //
    // Indicate expecting an interrupt.
    //

    deviceExtension->ExpectingInterrupt = TRUE;
    status = SRB_STATUS_PENDING;

    if (pIdeReg->bReserved & ATA_FLAGS_48BIT_COMMAND) {
        
        if (deviceExtension->DeviceFlags[Srb->TargetId] & DFLAGS_48BIT_LBA) {

            PIDEREGS prevReg = (PIDEREGS)(&Srb->Cdb[8]);

            IdePortOutPortByte(baseIoAddress1->Error,        prevReg->bFeaturesReg);
            IdePortOutPortByte(baseIoAddress1->BlockCount,   prevReg->bSectorCountReg);
            IdePortOutPortByte(baseIoAddress1->BlockNumber,  prevReg->bSectorNumberReg);
            IdePortOutPortByte(baseIoAddress1->CylinderLow,  prevReg->bCylLowReg);
            IdePortOutPortByte(baseIoAddress1->CylinderHigh, prevReg->bCylHighReg);

        } else{

            DebugPrint((0,
                        "ataPassThrough: no 48bit support\n"
                        ));

            deviceExtension->BytesLeft = 0;

            //
            // Clear interrupt expecting flag.
            //

            deviceExtension->ExpectingInterrupt = FALSE;

            return SRB_STATUS_BUSY;
        }

    }

    IdePortOutPortByte(baseIoAddress1->Error,        pIdeReg->bFeaturesReg);
    IdePortOutPortByte(baseIoAddress1->BlockCount,   pIdeReg->bSectorCountReg);
    IdePortOutPortByte(baseIoAddress1->BlockNumber,  pIdeReg->bSectorNumberReg);
    IdePortOutPortByte(baseIoAddress1->CylinderLow,  pIdeReg->bCylLowReg);
    IdePortOutPortByte(baseIoAddress1->CylinderHigh, pIdeReg->bCylHighReg);
    IdePortOutPortByte(baseIoAddress1->Command,      pIdeReg->bCommandReg);

    if ((Srb->SrbFlags & SRB_FLAGS_DATA_OUT) &&
        !SRB_USES_DMA(Srb)) {

        ULONG byteCount;
        ULONG i;

        if (deviceExtension->BytesLeft < 
            deviceExtension->DeviceParameters[Srb->TargetId].MaxBytePerPioInterrupt) {

            byteCount = deviceExtension->BytesLeft;

        } else {

            byteCount = deviceExtension->DeviceParameters[Srb->TargetId].MaxBytePerPioInterrupt;

        }
        //
        // Wait for BSY and DRQ.
        //

        WaitOnBusyUntil(baseIoAddress1,statusByte, 500);

        if (statusByte & IDE_STATUS_BUSY) {

            DebugPrint((0,
                        "ataPassThrough: Returning BUSY status %x\n",
                        statusByte
                        ));

            deviceExtension->BytesLeft = 0;

            //
            // Clear interrupt expecting flag.
            //

            deviceExtension->ExpectingInterrupt = FALSE;

            return SRB_STATUS_BUSY;
        }

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

            GetBaseStatus(baseIoAddress1, statusByte);

            if (statusByte & IDE_STATUS_DRQ) {
                break;
            }

            KeStallExecutionProcessor(200);
        }

        if (!(statusByte & IDE_STATUS_DRQ)) {

            DebugPrint((0,
                        "ataPassThrough: DRQ never asserted (%x)\n",
                        statusByte
                        ));

            deviceExtension->BytesLeft = 0;

            //
            // Clear interrupt expecting flag.
            //

            deviceExtension->ExpectingInterrupt = FALSE;

            return SRB_STATUS_BUSY;
        }

        //
        // Write next 256 words.
        //

        WriteBuffer(baseIoAddress1,
                    (PUSHORT)deviceExtension->DataBuffer,
                    byteCount / sizeof(USHORT));

        //
        // Adjust buffer address and words left count.
        //

        deviceExtension->BytesLeft -= byteCount;
        deviceExtension->DataBuffer += byteCount;
    }

    return status;
}