//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//  Copyright (C) Microsoft Corporation, 1998 - 1999
//
//  File:       util.c
//
//--------------------------------------------------------------------------

#include "ide.h"

#pragma alloc_text(NONPAGE, IdePortChannelEmpty)
#pragma alloc_text(PAGE, DigestResourceList)
#pragma alloc_text(PAGE, AtapiBuildIoAddress)
#pragma alloc_text(PAGE, IdeGetDeviceCapabilities)

#pragma alloc_text(NONPAGE, IdePortpWaitOnBusyEx)

#pragma alloc_text(PAGE, IdeCreateIdeDirectory)

#ifdef  DPC_FOR_EMPTY_CHANNEL
BOOLEAN
IdePortIdentifyDevice(
    IN PIDE_REGISTERS_1 CmdRegBase,
    IN PIDE_REGISTERS_2 CtrlRegBase,
    IN ULONG            MaxIdeDevice
    )
{
    UCHAR statusByte1;
    ULONG retryCount=4;
    BOOLEAN emptyChannel=TRUE;
    ULONG deviceNumber=0;
    ULONG i;
    
    retryCount = 4;
    emptyChannel = TRUE;
    deviceNumber = 0;

retryIdentifier:

    //
    // Select the master device
    //
    SelectIdeDevice(CmdRegBase, deviceNumber, 0);

    //
    // write out indentifier to readable and writable io registers
    //
    WRITE_PORT_UCHAR (CmdRegBase->CylinderHigh, SAMPLE_CYLINDER_HIGH_VALUE);
    WRITE_PORT_UCHAR (CmdRegBase->CylinderLow,  SAMPLE_CYLINDER_LOW_VALUE);

    //
    // Check if indentifier can be read back.
    //
    if ((READ_PORT_UCHAR (CmdRegBase->CylinderHigh) != SAMPLE_CYLINDER_HIGH_VALUE) ||
        (READ_PORT_UCHAR (CmdRegBase->CylinderLow)  != SAMPLE_CYLINDER_LOW_VALUE)) {

        statusByte1 = READ_PORT_UCHAR (CmdRegBase->Command);

        DebugPrint((2,
                    "IdePortChannelEmpty: status read back from Master (%x)\n",
                    statusByte1));

        if (statusByte1 & IDE_STATUS_BUSY) {

            i = 0;

            //
            // Could be the TEAC in a thinkpad. Their dos driver puts it in a sleep-mode that
            // warm boots don't clear.
            //

            do {
                KeStallExecutionProcessor(1000);
                statusByte1 = READ_PORT_UCHAR(CmdRegBase->Command);
                DebugPrint((3,
                            "IdePortChannelEmpty: First access to status %x\n",
                            statusByte1));
            } while ((statusByte1 & IDE_STATUS_BUSY) && ++i < 10);

            if (retryCount-- && (!(statusByte1 & IDE_STATUS_BUSY))) {
                goto retryIdentifier;
            }
        }

        //
        // Select slave.
        //
        deviceNumber++;

        SelectIdeDevice(CmdRegBase, deviceNumber, 0);

        //
        // write out indentifier to readable and writable io registers
        //
        WRITE_PORT_UCHAR (CmdRegBase->CylinderHigh, SAMPLE_CYLINDER_HIGH_VALUE);
        WRITE_PORT_UCHAR (CmdRegBase->CylinderLow,  SAMPLE_CYLINDER_LOW_VALUE);

        //
        // Check if indentifier can be read back.
        //
        if ((READ_PORT_UCHAR (CmdRegBase->CylinderHigh) != SAMPLE_CYLINDER_HIGH_VALUE) ||
            (READ_PORT_UCHAR (CmdRegBase->CylinderLow)  != SAMPLE_CYLINDER_LOW_VALUE)) {

            statusByte1 = READ_PORT_UCHAR (CmdRegBase->Command);

            DebugPrint((2,
                        "IdePortChannelEmpty: status read back from Slave (%x)\n",
                        statusByte1));

        } else {

            emptyChannel = FALSE;
        }

    } else {

        emptyChannel = FALSE;
    }

    deviceNumber++;

    if ( (deviceNumber < MaxIdeDevice) && emptyChannel ) {
        goto retryIdentifier;
    }

    return emptyChannel;

} //IdePortIdentifyDevice

ULONG
IdePortChannelEmptyQuick (
    IN PIDE_REGISTERS_1 CmdRegBase,
    IN PIDE_REGISTERS_2 CtrlRegBase,
    IN ULONG            MaxIdeDevice,
    IN PULONG           CurrentDevice,
    IN PULONG           moreWait,
    IN PULONG           NoRetry
)
{
    //
    // try EXECUTE_DIAGNOSTICS. No.
    //

    //
    // statusByte1 needs to be initialized to ff
    //
    UCHAR statusByte1=0xff;

    UCHAR statusByte2;
    ULONG i;
    BOOLEAN allStatusBytesAllFs;

    allStatusBytesAllFs = TRUE;

    DebugPrint((1, "ChannelEmptyQuick: wait=%d, Device=%d\n",
                    *moreWait, *CurrentDevice));
    if (*moreWait) {

        (*moreWait)--;

        SelectIdeDevice(CmdRegBase, (*CurrentDevice), 0);

        IdePortWaitOnBusyExK (CmdRegBase, statusByte1, 0xff);

        DebugPrint((1, "ATAPI: Status after first retry=%x\n", statusByte1));

        if (statusByte1==0xff) {
            (*CurrentDevice)++;
            *moreWait=0;
        }
    }

    if (*moreWait && (statusByte1 & IDE_STATUS_BUSY)) {
        
        return STATUS_RETRY;
    }

    if (!(*NoRetry) && (statusByte1 & IDE_STATUS_BUSY) && 
        ((statusByte1 != 0xfe) &&
         (statusByte1 != 0xff))) {

        DebugPrint((1,
                    "ATAPI: IdePortChannelEmpty: channel looks busy 0x%x.  try a reset\n",
                    statusByte1));

        //
        // channel look hung or busy
        //
        // try a hard reset to bring it to idle
        WRITE_PORT_UCHAR (CtrlRegBase->DeviceControl, IDE_DC_RESET_CONTROLLER);

        //
        // ATA-2 spec requires a minimum of 5 microsec stall here
        //
        KeStallExecutionProcessor (10);

        WRITE_PORT_UCHAR (CtrlRegBase->DeviceControl, IDE_DC_REENABLE_CONTROLLER);

        i=*CurrentDevice;
        SelectIdeDevice(CmdRegBase, i, 0);
        IdePortWaitOnBusyExK (CmdRegBase, statusByte1, 0xff);
        if ((statusByte1 & IDE_STATUS_BUSY) && (statusByte1 != 0xff)) {
            *moreWait=2; //wait for 2 more timer ticks
            *NoRetry=1;
            return STATUS_RETRY;
        }
    }

    if (statusByte1 != 0xFF) {
        allStatusBytesAllFs = FALSE;
        (*CurrentDevice)++;
    }

    for (i=*CurrentDevice; i<MaxIdeDevice && allStatusBytesAllFs; i++) {

        //
        // make sure device is not busy
        //

        //
        // Select the master device
        //
        SelectIdeDevice(CmdRegBase, i, 0);

        if (Is98LegacyIde(CmdRegBase)) {
            if (READ_PORT_UCHAR(CmdRegBase->DriveSelect) != (((i & 0x1) << 4) | 0xA0)) {
                //
                // Bad controller.
                //
                continue;
            }
        }

        GetStatus(CmdRegBase, statusByte1);
        DebugPrint((1, "ATAPI:status for device %d after GetStatus=%x\n",i, statusByte1));

        if (statusByte1 == 0xff) {
            continue;
        }

        if (statusByte1 == 0xfe) {
            continue;
        }

        IdePortWaitOnBusyExK (CmdRegBase, statusByte1, 0xff);

        if ((statusByte1 & 0xfe) == 0xfe) {
            continue;
        }

        if (statusByte1 & IDE_STATUS_BUSY) {
            DebugPrint((1, "ATAPI: Re-init the counts:device=%d, status=%x",
                                i, statusByte1));
            *CurrentDevice=i;
            *moreWait=2;
            *NoRetry=0;
            return STATUS_RETRY;
        }

        if (statusByte1 != 0xFF) {
            allStatusBytesAllFs = FALSE;
        }
    }

    if (allStatusBytesAllFs) {

        //
        // all status bytes are 0xff,
        // no controller at this location
        //
        return 1;
    }

    i=(IdePortIdentifyDevice(CmdRegBase, CtrlRegBase, MaxIdeDevice)) ? 1: 0;
    return i;

}//IdePortChannelEmptyQuick


#endif

BOOLEAN
IdePortChannelEmpty (
    IN PIDE_REGISTERS_1 CmdRegBase,
    IN PIDE_REGISTERS_2 CtrlRegBase,
    IN ULONG            MaxIdeDevice
)
/*++

Routine Description:

    quickly check whether a IDE channel exist at the given io location

Arguments:

    CmdRegBase - command registers

    CtrlRegBase - control registers

    MaxIdeDevice - number of max devices

Return Value:

    TRUE - Yes, the channel is empty
    FALSE - No, the channel is not empty

--*/
{

    UCHAR statusByte1;
    UCHAR statusByte2;
    ULONG retryCount;
    ULONG i;
    BOOLEAN emptyChannel;
    ULONG deviceNumber;
    BOOLEAN allStatusBytesAllFs;

    allStatusBytesAllFs = TRUE;
    for (i=0; i<MaxIdeDevice; i++) {

        //
        // make sure device is not busy
        //

        //
        // Select the master device
        //
        SelectIdeDevice(CmdRegBase, i, 0);

        if (Is98LegacyIde(CmdRegBase)) {
            if (READ_PORT_UCHAR(CmdRegBase->DriveSelect) != (((i & 0x1) << 4) | 0xA0)) {
                //
                // Bad controller.
                //
                continue;
            }
        }

        GetStatus(CmdRegBase, statusByte1);

        if (statusByte1 == 0xff) {
            continue;
        }

        if (statusByte1 == 0xfe) {
            continue;
        }

        IdePortWaitOnBusyEx (CmdRegBase, &statusByte1, 0xff);

        if ((statusByte1 & IDE_STATUS_BUSY) &&
            ((statusByte1 != 0xfe) &&
             (statusByte1 != 0xff))) {

            DebugPrint((1,
                        "IdePortChannelEmpty: channel looks busy 0x%x.  try a reset\n",
                        statusByte1));


            //
            // channel look hung or busy
            //
            // try a hard reset to bring it to idle
            WRITE_PORT_UCHAR (CtrlRegBase->DeviceControl, IDE_DC_RESET_CONTROLLER);
            
            //
            // ATA-2 spec requires a minimum of 5 microsec stall here
            //
            KeStallExecutionProcessor (10);
    
            WRITE_PORT_UCHAR (CtrlRegBase->DeviceControl, IDE_DC_REENABLE_CONTROLLER);
    
            SelectIdeDevice(CmdRegBase, i, 0);
            IdePortWaitOnBusyEx (CmdRegBase, &statusByte1, 0xff);
        }

        if (statusByte1 != 0xFF) {
            allStatusBytesAllFs = FALSE;
        }
    }

    if (allStatusBytesAllFs) {

        //
        // all status bytes are 0xff,
        // no controller at this location
        //
        return TRUE;
    }

#ifdef DPC_FOR_EMPTY_CHANNEL
    return IdePortIdentifyDevice(CmdRegBase, CtrlRegBase, MaxIdeDevice);
#endif
    retryCount = 4;
    emptyChannel = TRUE;
    deviceNumber = 0;

retryIdentifier:

    //
    // Select the master device
    //
    SelectIdeDevice(CmdRegBase, deviceNumber, 0);

    //
    // write out indentifier to readable and writable io registers
    //
    WRITE_PORT_UCHAR (CmdRegBase->CylinderHigh, SAMPLE_CYLINDER_HIGH_VALUE);
    WRITE_PORT_UCHAR (CmdRegBase->CylinderLow,  SAMPLE_CYLINDER_LOW_VALUE);

    //
    // Check if indentifier can be read back.
    //
    if ((READ_PORT_UCHAR (CmdRegBase->CylinderHigh) != SAMPLE_CYLINDER_HIGH_VALUE) ||
        (READ_PORT_UCHAR (CmdRegBase->CylinderLow)  != SAMPLE_CYLINDER_LOW_VALUE)) {

        statusByte1 = READ_PORT_UCHAR (CmdRegBase->Command);

        DebugPrint((2,
                    "IdePortChannelEmpty: status read back from Master (%x)\n",
                    statusByte1));

        if (statusByte1 & IDE_STATUS_BUSY) {

            i = 0;

            //
            // Could be the TEAC in a thinkpad. Their dos driver puts it in a sleep-mode that
            // warm boots don't clear.
            //

            do {
                KeStallExecutionProcessor(1000);
                statusByte1 = READ_PORT_UCHAR(CmdRegBase->Command);
                DebugPrint((3,
                            "IdePortChannelEmpty: First access to status %x\n",
                            statusByte1));
            } while ((statusByte1 & IDE_STATUS_BUSY) && ++i < 10);

            if (retryCount-- && (!(statusByte1 & IDE_STATUS_BUSY))) {
                goto retryIdentifier;
            }
        }

        //
        // Select slave.
        //
        deviceNumber++;

        SelectIdeDevice(CmdRegBase, deviceNumber, 0);

        //
        // write out indentifier to readable and writable io registers
        //
        WRITE_PORT_UCHAR (CmdRegBase->CylinderHigh, SAMPLE_CYLINDER_HIGH_VALUE);
        WRITE_PORT_UCHAR (CmdRegBase->CylinderLow,  SAMPLE_CYLINDER_LOW_VALUE);

        //
        // Check if indentifier can be read back.
        //
        if ((READ_PORT_UCHAR (CmdRegBase->CylinderHigh) != SAMPLE_CYLINDER_HIGH_VALUE) ||
            (READ_PORT_UCHAR (CmdRegBase->CylinderLow)  != SAMPLE_CYLINDER_LOW_VALUE)) {

            statusByte1 = READ_PORT_UCHAR (CmdRegBase->Command);

            DebugPrint((2,
                        "IdePortChannelEmpty: status read back from Slave (%x)\n",
                        statusByte1));

        } else {

            emptyChannel = FALSE;
        }

    } else {

        emptyChannel = FALSE;
    }

    deviceNumber++;

    if ( (deviceNumber < MaxIdeDevice) && emptyChannel ) {
        goto retryIdentifier;
    }

    return emptyChannel;

} //IdePortChannelEmpty

NTSTATUS
DigestResourceList (
    IN OUT PIDE_RESOURCE                IdeResource,
    IN  PCM_RESOURCE_LIST               ResourceList,
    OUT PCM_PARTIAL_RESOURCE_DESCRIPTOR *IrqPartialDescriptors
    )
{
    NTSTATUS                        status;

    PCM_FULL_RESOURCE_DESCRIPTOR    fullResourceList;
    PCM_PARTIAL_RESOURCE_LIST       partialResourceList;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR partialDescriptors;
    ULONG                           resourceListSize;
    ULONG                           i;
    ULONG                           j;

    BOOLEAN                         foundCommandBase;
    BOOLEAN                         foundControlBase;
    BOOLEAN                         foundIrqLevel;
    BOOLEAN                         resourceIsCommandPort;

    BOOLEAN                         AtdiskPrimaryClaimed;
    BOOLEAN                         AtdiskSecondaryClaimed;

    PHYSICAL_ADDRESS                tranlatedAddress;

    IDE_REGISTERS_1                 baseIoAddress1;
    ULONG                           baseIoAddress1Length;


    fullResourceList = ResourceList->List;
    resourceListSize = 0;

    DebugPrint ((5, "IdePort: DigestResourceList()\n"));

    foundCommandBase       = FALSE;
    foundControlBase       = FALSE;
    foundIrqLevel          = FALSE;
    *IrqPartialDescriptors = NULL;
    status                 = STATUS_SUCCESS;

    AtdiskPrimaryClaimed    = FALSE;
    AtdiskSecondaryClaimed  = FALSE;

    for (i = 0;
         (i < ResourceList->Count) && NT_SUCCESS(status);
         i++) {

        partialResourceList = &(fullResourceList->PartialResourceList);
        partialDescriptors  = fullResourceList->PartialResourceList.PartialDescriptors;

        AtapiBuildIoAddress ((PUCHAR)partialDescriptors[0].u.Port.Start.QuadPart,
                             0,
                             &baseIoAddress1,
                             NULL,
                             &baseIoAddress1Length,
                             NULL,
                             NULL,
                             NULL);

        for (j = 0;
             (j < partialResourceList->Count) && NT_SUCCESS(status);
             j++) {

            resourceIsCommandPort = FALSE;

            if (!Is98LegacyIde(&baseIoAddress1)) {

                if (((partialDescriptors[j].Type == CmResourceTypePort) ||
                    (partialDescriptors[j].Type == CmResourceTypeMemory)) &&
                    (partialDescriptors[j].u.Port.Length == baseIoAddress1Length)) {

                    resourceIsCommandPort = TRUE;

                }
            } else {

                if (((partialDescriptors[j].Type == CmResourceTypePort) ||
                    (partialDescriptors[j].Type == CmResourceTypeMemory)) &&
                    (partialDescriptors[j].u.Port.Start.QuadPart == IDE_NEC98_COMMAND_PORT_ADDRESS)){

                    resourceIsCommandPort = TRUE;

                } else if (((partialDescriptors[j].Type == CmResourceTypePort) ||
                            (partialDescriptors[j].Type == CmResourceTypeMemory)) &&
                           (partialDescriptors[j].u.Port.Start.QuadPart != IDE_NEC98_COMMAND_PORT_ADDRESS) &&
                           (partialDescriptors[j].u.Port.Start.QuadPart != (IDE_NEC98_COMMAND_PORT_ADDRESS + 0x10C))) {

                    //
                    // This is not the base port address for Legacy ide on NEC98;
                    //

                    continue;
                }
            }

            if (resourceIsCommandPort) {

                if (foundCommandBase) {

                    //
                    // got this before, just ignore it
                    //
                    // status = STATUS_INVALID_PARAMETER;

                } else {

                    if (!Is98LegacyIde(&baseIoAddress1)) {

                        if (partialDescriptors[j].u.Port.Start.QuadPart == IDE_STANDARD_PRIMARY_ADDRESS) {

                            AtdiskPrimaryClaimed = TRUE;

                        } else if (partialDescriptors[j].u.Port.Start.QuadPart == IDE_STANDARD_SECONDARY_ADDRESS) {

                            AtdiskSecondaryClaimed = TRUE;
                        }

                    } else {

                        AtdiskPrimaryClaimed = TRUE;
                        AtdiskSecondaryClaimed = TRUE;
                    }

                    if (partialDescriptors[j].Type == CmResourceTypePort) {

                        IdeResource->TranslatedCommandBaseAddress =
                            (PUCHAR)(ULONG_PTR)partialDescriptors[j].u.Port.Start.QuadPart;

                        IdeResource->CommandBaseAddressSpace = IO_SPACE;

                    } else if (partialDescriptors[j].Type == CmResourceTypeMemory) {

                        IdeResource->TranslatedCommandBaseAddress = MmMapIoSpace(
                                                                        partialDescriptors[j].u.Port.Start,
                                                                        baseIoAddress1Length,
                                                                        FALSE);

                        IdeResource->CommandBaseAddressSpace = MEMORY_SPACE;

                    } else {

                        IdeResource->TranslatedCommandBaseAddress = FALSE;
                        ASSERT (FALSE);
                    }

                    if (IdeResource->TranslatedCommandBaseAddress) {

                        foundCommandBase = TRUE;

                    } else {

                        status = STATUS_INVALID_PARAMETER;
                    }
                }

            } else if (((partialDescriptors[j].Type == CmResourceTypePort) ||
                        (partialDescriptors[j].Type == CmResourceTypeMemory)) &&
                        ((partialDescriptors[j].u.Port.Length == 1) ||
                        (partialDescriptors[j].u.Port.Length == 2) ||
                        (partialDescriptors[j].u.Port.Length == 4))) {

                if (foundControlBase) {

                    //
                    // got this before, just ignore it
                    //
                    // status = STATUS_INVALID_PARAMETER;

                } else {

                    PHYSICAL_ADDRESS p;
                    //
                    // Probably the control block register
                    //

                    p = partialDescriptors[j].u.Port.Start;

                    if (partialDescriptors[j].u.Port.Length == 4) {

                        p.QuadPart += 2;
                    }

                    if (partialDescriptors[j].Type == CmResourceTypePort) {

                        IdeResource->TranslatedControlBaseAddress =
                            (PUCHAR)(ULONG_PTR)partialDescriptors[j].u.Port.Start.QuadPart;

                        IdeResource->ControlBaseAddressSpace = IO_SPACE;

                    } else if (partialDescriptors[j].Type == CmResourceTypeMemory) {

                        IdeResource->TranslatedControlBaseAddress = MmMapIoSpace(
                                                                         p,
                                                                         1,
                                                                         FALSE);

                        IdeResource->ControlBaseAddressSpace = MEMORY_SPACE;

                    } else {

                        IdeResource->TranslatedControlBaseAddress = FALSE;
                        ASSERT (FALSE);
                    }

                    if (IdeResource->TranslatedControlBaseAddress) {

                        foundControlBase = TRUE;

                    } else {

                        status = STATUS_INVALID_PARAMETER;
                    }
                }

            } else if (partialDescriptors[j].Type == CmResourceTypeInterrupt) {

                if (foundIrqLevel) {

                    //
                    // got this before, just ignore it
                    //
                    // status = STATUS_INVALID_PARAMETER;

                } else {

                    //
                    // Probably the device IRQ
                    //

                    //
                    // May want to disable device interrupt here
                    //

                    //
                    // Save interrupt level.
                    //

                    IdeResource->InterruptLevel = partialDescriptors[j].u.Interrupt.Level;
                    IdeResource->InterruptMode  = partialDescriptors[j].Flags & CM_RESOURCE_INTERRUPT_LATCHED ?
                                                       Latched :
                                                       LevelSensitive;

                    *IrqPartialDescriptors       = partialDescriptors + j;

                    foundIrqLevel = TRUE;
                }

            } else if (((partialDescriptors[j].Type == CmResourceTypePort) ||
                        (partialDescriptors[j].Type == CmResourceTypeMemory)) &&
                        ((partialDescriptors[j].u.Port.Length >= 16) &&
                         (partialDescriptors[j].u.Port.Length <= 32)) ) {

                if (foundControlBase || foundCommandBase) {

                    //
                    // got this before, just ignore it
                    //
                    // status = STATUS_INVALID_PARAMETER;

                } else {

                    PHYSICAL_ADDRESS ctrlAddr;

                    //
                    // Probably a pcmcia device that has its command and control
                    // registers lumped into one I/O range
                    //
                    // We are guessing the control block register is the second
                    // from the last i/o space.  Some standard!
                    //

                    ctrlAddr.QuadPart = partialDescriptors[j].u.Port.Start.QuadPart +
                                        partialDescriptors[j].u.Port.Length - 2;

                    if (partialDescriptors[j].Type == CmResourceTypePort) {

                        IdeResource->TranslatedCommandBaseAddress =
                            (PUCHAR)(ULONG_PTR)partialDescriptors[j].u.Port.Start.QuadPart;

                        IdeResource->CommandBaseAddressSpace = IO_SPACE;

                        IdeResource->TranslatedControlBaseAddress =
                            (PUCHAR)(ULONG_PTR)ctrlAddr.QuadPart;

                        IdeResource->ControlBaseAddressSpace = IO_SPACE;

                    } else if (partialDescriptors[j].Type == CmResourceTypeMemory) {

                        IdeResource->TranslatedCommandBaseAddress = MmMapIoSpace(
                                                                         partialDescriptors[j].u.Port.Start,
                                                                         baseIoAddress1Length,
                                                                         FALSE);

                        IdeResource->CommandBaseAddressSpace = MEMORY_SPACE;

                        IdeResource->TranslatedControlBaseAddress = MmMapIoSpace(
                                                                         ctrlAddr,
                                                                         1,
                                                                         FALSE);

                        IdeResource->ControlBaseAddressSpace = MEMORY_SPACE;

                    } else {

                        IdeResource->TranslatedCommandBaseAddress = FALSE;
                        IdeResource->TranslatedControlBaseAddress = FALSE;
                        ASSERT (FALSE);
                    }

                    if (IdeResource->TranslatedCommandBaseAddress) {

                        foundCommandBase = TRUE;

                    } else {

                        status = STATUS_INVALID_PARAMETER;
                    }

                    if (IdeResource->TranslatedControlBaseAddress) {

                        foundControlBase = TRUE;

                    } else {

                        status = STATUS_INVALID_PARAMETER;
                    }
                }
            }
        }
        fullResourceList = (PCM_FULL_RESOURCE_DESCRIPTOR) (partialDescriptors + partialResourceList->Count);
    }

    if (foundCommandBase && foundControlBase && NT_SUCCESS(status)) {

        IdeResource->AtdiskPrimaryClaimed   = AtdiskPrimaryClaimed;
        IdeResource->AtdiskSecondaryClaimed = AtdiskSecondaryClaimed;

        return STATUS_SUCCESS;

    } else {

        DebugPrint((0, "IdePort: pnp manager gave me bad ressources!\n"));

        if (foundCommandBase &&
            (IdeResource->CommandBaseAddressSpace == MEMORY_SPACE)) {

            MmUnmapIoSpace (
                IdeResource->TranslatedCommandBaseAddress,
                baseIoAddress1Length
                );

            IdeResource->TranslatedCommandBaseAddress = 0;
        }

        if (foundControlBase &&
            (IdeResource->ControlBaseAddressSpace == MEMORY_SPACE)) {

            MmUnmapIoSpace (
                IdeResource->TranslatedControlBaseAddress,
                1
                );

            IdeResource->TranslatedControlBaseAddress = 0;
        }

        return STATUS_INVALID_PARAMETER;
    }
} // DigestResourceList

VOID
AtapiBuildIoAddress (
    IN  PUCHAR            CmdBaseAddress,
    IN  PUCHAR            CtrlBaseAddress,
    OUT PIDE_REGISTERS_1  BaseIoAddress1,
    OUT PIDE_REGISTERS_2  BaseIoAddress2,
    OUT PULONG            BaseIoAddress1Length,
    OUT PULONG            BaseIoAddress2Length,
    OUT PULONG            MaxIdeDevice,
    OUT PULONG            MaxIdeTargetId
)
{
    PUCHAR      baseIoAddress;
    BOOLEAN     LegacyIdeOfNec98;

    LegacyIdeOfNec98 = FALSE;

    if (IsNEC_98) {
        if (CmdBaseAddress == (PUCHAR)IDE_NEC98_COMMAND_PORT_ADDRESS) {
            LegacyIdeOfNec98 = TRUE;
        }
    }

    if (!LegacyIdeOfNec98) {

        //
        // Build command registers.
        //

        baseIoAddress       = CmdBaseAddress;

        if (BaseIoAddress1) {
            BaseIoAddress1->RegistersBaseAddress = baseIoAddress;

            BaseIoAddress1->Data         = (PUSHORT)baseIoAddress;
            BaseIoAddress1->Error        = baseIoAddress + 1;
            BaseIoAddress1->BlockCount   = baseIoAddress + 2;
            BaseIoAddress1->BlockNumber  = baseIoAddress + 3;
            BaseIoAddress1->CylinderLow  = baseIoAddress + 4;
            BaseIoAddress1->CylinderHigh = baseIoAddress + 5;
            BaseIoAddress1->DriveSelect  = baseIoAddress + 6;
            BaseIoAddress1->Command      = baseIoAddress + 7;

        }

        //
        // Build control registers.
        //

        baseIoAddress = CtrlBaseAddress;

        if (BaseIoAddress2) {

            BaseIoAddress2->RegistersBaseAddress     = baseIoAddress;

            BaseIoAddress2->DeviceControl            = baseIoAddress;
            BaseIoAddress2->DriveAddress             = baseIoAddress + 1;
        }

        if (BaseIoAddress1Length) {
            *BaseIoAddress1Length                    = 8;
        }

        if (BaseIoAddress2Length) {
            *BaseIoAddress2Length                    = 1;
        }

        if (MaxIdeDevice) {
            *MaxIdeDevice                           = MAX_IDE_DEVICE;
        }

        if (MaxIdeTargetId) {
            *MaxIdeTargetId                         = MAX_IDE_DEVICE;
        }

    } else {

        //
        // Build command registers.
        //

        baseIoAddress = CmdBaseAddress;

        if (BaseIoAddress1) {
            BaseIoAddress1->RegistersBaseAddress = baseIoAddress;

            BaseIoAddress1->Data         = (PUSHORT)baseIoAddress;
            BaseIoAddress1->Error        = baseIoAddress + 2;
            BaseIoAddress1->BlockCount   = baseIoAddress + 4;
            BaseIoAddress1->BlockNumber  = baseIoAddress + 6;
            BaseIoAddress1->CylinderLow  = baseIoAddress + 8;
            BaseIoAddress1->CylinderHigh = baseIoAddress + 10;
            BaseIoAddress1->DriveSelect  = baseIoAddress + 12;
            BaseIoAddress1->Command      = baseIoAddress + 14;
        }

        //
        // Build control registers.
        //

        baseIoAddress = CtrlBaseAddress;

        if (BaseIoAddress2) {

            BaseIoAddress2->RegistersBaseAddress     = baseIoAddress;

            BaseIoAddress2->DeviceControl            = baseIoAddress;
            BaseIoAddress2->DriveAddress             = baseIoAddress + 2;
        }

        if (BaseIoAddress1Length) {
            *BaseIoAddress1Length                    = 1;
        }

        if (BaseIoAddress2Length) {
            *BaseIoAddress2Length                    = 1;
        }

        if (MaxIdeDevice) {
            *MaxIdeDevice                           = MAX_IDE_DEVICE * MAX_IDE_LINE;
        }

        if (MaxIdeTargetId) {
            *MaxIdeTargetId                         = MAX_IDE_DEVICE * MAX_IDE_LINE;
        }
    }

    return;

} // AtapiBuildIoAddress

NTSTATUS
IdePortpWaitOnBusyEx (
    IN PIDE_REGISTERS_1 CmdRegBase,
    IN OUT PUCHAR       Status,
    IN UCHAR            BadStatus
#if DBG
    ,
    IN PCSTR            FileName,
    IN ULONG            LineNumber
#endif
)
{
    UCHAR status;
    ULONG sec;
    ULONG i;

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

        /**/
        /* one second loop */
        /**/

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

            GetStatus(CmdRegBase, status);
            
            if (status == BadStatus) {

                break;

            } else if (status & IDE_STATUS_BUSY) {

                KeStallExecutionProcessor(5);
                continue;

            } else {

                break;
            }
        }

        if (status == BadStatus) {

           break;

        } else if (status & IDE_STATUS_BUSY) {

            DebugPrint ((1, "ATAPI: after 1 sec wait, device is still busy with 0x%x status = 0x%x\n", CmdRegBase->RegistersBaseAddress, (ULONG) (status)));

        } else {

            break;
        }
    }

    *Status = status;

    if ((status & IDE_STATUS_BUSY) && (status != BadStatus)) {

        DebugPrint ((0, "WaitOnBusy failed in %s line %u. 0x%x status = 0x%x\n", FileName, LineNumber, CmdRegBase->RegistersBaseAddress, (ULONG) (status)));

        return STATUS_UNSUCCESSFUL;
    }

    return STATUS_SUCCESS;
} // IdePortpWaitOnBusyEx

static PVOID IdeDirectory = NULL;
VOID
IdeCreateIdeDirectory(
    VOID
    )
{
    UNICODE_STRING unicodeDirectoryName;
    OBJECT_ATTRIBUTES objectAttributes;

    HANDLE directory;

    NTSTATUS status;

    PAGED_CODE();

    RtlInitUnicodeString(
        &unicodeDirectoryName,
        DEVICE_OJBECT_BASE_NAME);

    InitializeObjectAttributes(
        &objectAttributes,
        &unicodeDirectoryName,
        OBJ_CASE_INSENSITIVE | OBJ_PERMANENT,
        NULL,
        NULL);

    status = ZwCreateDirectoryObject(&directory,
                                     DIRECTORY_ALL_ACCESS,
                                     &objectAttributes);

    if(NT_SUCCESS(status)) {

        ObReferenceObjectByHandle(directory,
                                  FILE_READ_ATTRIBUTES,
                                  NULL,
                                  KernelMode,
                                  &IdeDirectory,
                                  NULL);
        ZwClose(directory);

    }
    return;
}

NTSTATUS
IdeGetDeviceCapabilities(
    IN  PDEVICE_OBJECT          DeviceObject,
    IN  PDEVICE_CAPABILITIES    DeviceCapabilities
    )
/*++

Routine Description:

    This routine sends the get capabilities irp to the given stack

Arguments:

    DeviceObject        A device object in the stack whose capabilities we want
    DeviceCapabilites   Where to store the answer

Return Value:

    NTSTATUS

--*/
{
    IO_STATUS_BLOCK     ioStatus;
    KEVENT              pnpEvent;
    NTSTATUS            status;
    PDEVICE_OBJECT      targetObject;
    PIO_STACK_LOCATION  irpStack;
    PIRP                pnpIrp;

    PAGED_CODE();

    //
    // Initialize the capabilities that we will send down
    //
    RtlZeroMemory( DeviceCapabilities, sizeof(DEVICE_CAPABILITIES) );
    DeviceCapabilities->Size = sizeof(DEVICE_CAPABILITIES);
    DeviceCapabilities->Version = 1;
    DeviceCapabilities->Address = -1;
    DeviceCapabilities->UINumber = -1;
    //
    // Initialize the event
    //
    KeInitializeEvent( &pnpEvent, SynchronizationEvent, FALSE );

    //
    // Get the irp that we will send the request to
    //
    targetObject = IoGetAttachedDeviceReference( DeviceObject );

    //
    // Build an Irp
    //
    pnpIrp = IoBuildSynchronousFsdRequest(
        IRP_MJ_PNP,
        targetObject,
        NULL,
        0,
        NULL,
        &pnpEvent,
        &ioStatus
        );
    if (pnpIrp == NULL) {

        status = STATUS_INSUFFICIENT_RESOURCES;
        goto IdeGetDeviceCapabilitiesExit;

    }

    //
    // Pnp Irps all begin life as STATUS_NOT_SUPPORTED;
    //
    pnpIrp->IoStatus.Status = STATUS_NOT_SUPPORTED;
    pnpIrp->IoStatus.Information = 0;

    //
    // Get the top of stack
    //
    irpStack = IoGetNextIrpStackLocation( pnpIrp );
    if (irpStack == NULL) {

        status = STATUS_INVALID_PARAMETER;
        goto IdeGetDeviceCapabilitiesExit;

    }

    //
    // Set the top of stack
    //
    RtlZeroMemory( irpStack, sizeof(IO_STACK_LOCATION ) );
    irpStack->MajorFunction = IRP_MJ_PNP;
    irpStack->MinorFunction = IRP_MN_QUERY_CAPABILITIES;
    irpStack->Parameters.DeviceCapabilities.Capabilities = DeviceCapabilities;

    //
    // Make sure that there are no completion routines set
    //
    IoSetCompletionRoutine(
        pnpIrp,
        NULL,
        NULL,
        FALSE,
        FALSE,
        FALSE
        );

    //
    // Call the driver
    //
    status = IoCallDriver( targetObject, pnpIrp );
    if (status == STATUS_PENDING) {

        //
        // Block until the irp comes back
        //
        KeWaitForSingleObject(
            &pnpEvent,
            Executive,
            KernelMode,
            FALSE,
            NULL
            );
        status = ioStatus.Status;

    }

IdeGetDeviceCapabilitiesExit:
    //
    // Done with reference
    //
    ObDereferenceObject( targetObject );

    //
    // Done
    //
    return status;
}