legide.c File Reference

#include <ntddk.h>
#include <ide.h>
#include <ata.h>
#include <scsi.h>
#include <reactos/drivers/ata/ata_shared.h>
#include <debug.h>

Include dependency graph for legide.c:

Go to the source code of this file.

Classes
struct	_ATA_LEGACY_CHANNEL

Macros
#define	NDEBUG
#define	ATAPORT_TAG   'PedI'
#define	IDE_DRIVE_SELECT   0xA0
#define	ATA_READ(Port)   READ_PORT_UCHAR((Port))
#define	ATA_WRITE(Port, Value)   WRITE_PORT_UCHAR((Port), (Value))
#define	ATA_IO_WAIT()   KeStallExecutionProcessor(1)
#define	ATA_TIME_BUSY_SELECT   3000
#define	ATA_TIME_BUSY_IDENTIFY   500000
#define	ATA_TIME_DRQ_CLEAR   1000
#define	ATA_TIME_RESET_SELECT   200000
#define	ATA_TIME_BUSY_RESET   1000000
#define	CHANNEL_PC98_RESOURCE_COUNT   12
#define	CHANNEL_PCAT_RESOURCE_COUNT   3

Typedefs
typedef struct _ATA_LEGACY_CHANNEL	ATA_LEGACY_CHANNEL
typedef struct _ATA_LEGACY_CHANNEL *	PATA_LEGACY_CHANNEL

Functions
static UCHAR	AtaWait (_In_ PIDE_REGISTERS Registers, _In_range_(>, 0) ULONG Timeout, _In_ UCHAR Mask, _In_ UCHAR Value)
static VOID	AtaLegacyFetchIdentifyData (_In_ PIDE_REGISTERS Registers)
static BOOLEAN	AtaLegacyIdentifyDevice (_In_ PIDE_REGISTERS Registers, _In_ ULONG DeviceNumber, _In_ UCHAR Command)
static BOOLEAN	AtaLegacyPerformSoftwareReset (_In_ PIDE_REGISTERS Registers, _In_ ULONG DeviceNumber)
static BOOLEAN	AtaLegacyFindAtaDevice (_In_ PIDE_REGISTERS Registers, _In_ ULONG DeviceNumber)
static BOOLEAN	AtaLegacyChannelPresent (_In_ PIDE_REGISTERS Registers)
static VOID	AtaLegacyMakePortResource (_Out_ PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor, _In_ ULONG IoBase, _In_ ULONG Length)
static VOID	AtaLegacyMakeInterruptResource (_Out_ PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor, _In_ ULONG Level)
static BOOLEAN	AtaLegacyChannelBuildResources (_In_ PATA_LEGACY_CHANNEL LegacyChannel, _Inout_ PCM_RESOURCE_LIST ResourceList)
static VOID	AtaLegacyChannelTranslateResources (_Inout_ PCM_RESOURCE_LIST ResourceList, _In_ PUCHAR CommandPortBase, _In_ PUCHAR ControlPortBase)
static PVOID	AtaLegacyTranslateBusAddress (_In_ ULONG Address, _In_ ULONG NumberOfBytes, _Out_ PBOOLEAN IsAddressMmio)
static BOOLEAN	AtaLegacyClaimHardwareResources (_In_ PDRIVER_OBJECT DriverObject, _In_ PCM_RESOURCE_LIST ResourceList, _In_ ULONG ResourceListSize)
static VOID	AtaLegacyReleaseHardwareResources (_In_ PDRIVER_OBJECT DriverObject)
static BOOLEAN	AtaLegacyDetectChannel (_In_ PDRIVER_OBJECT DriverObject, _In_ PPCIIDEX_LEGACY_CONTROLLER_INTERFACE ControllerInferface, _In_ PATA_LEGACY_CHANNEL LegacyChannel, _In_ PCM_RESOURCE_LIST ResourceList, _In_ ULONG ResourceListSize)
static NTSTATUS	AtaOpenRegistryKey (_Out_ PHANDLE KeyHandle, _In_ HANDLE RootKey, _In_ PUNICODE_STRING KeyName)
static BOOLEAN	AtaLegacyShouldDetectChannels (_In_ PUNICODE_STRING RegistryPath)
NTSTATUS NTAPI	DriverEntry (_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING RegistryPath)

Variables
DRIVER_INITIALIZE	DriverEntry

Macro Definition Documentation

ATA_IO_WAIT

#define ATA_IO_WAIT

(

)

KeStallExecutionProcessor(1)

Definition at line 33 of file legide.c.

ATA_READ

#define ATA_READ

(

Port

)

READ_PORT_UCHAR((Port))

Definition at line 31 of file legide.c.

ATA_TIME_BUSY_IDENTIFY

#define ATA_TIME_BUSY_IDENTIFY   500000

Definition at line 36 of file legide.c.

ATA_TIME_BUSY_RESET

#define ATA_TIME_BUSY_RESET   1000000

Definition at line 39 of file legide.c.

ATA_TIME_BUSY_SELECT

#define ATA_TIME_BUSY_SELECT   3000

Definition at line 35 of file legide.c.

ATA_TIME_DRQ_CLEAR

#define ATA_TIME_DRQ_CLEAR   1000

Definition at line 37 of file legide.c.

ATA_TIME_RESET_SELECT

#define ATA_TIME_RESET_SELECT   200000

Definition at line 38 of file legide.c.

ATA_WRITE

#define ATA_WRITE	(		Port,
			Value
	)		WRITE_PORT_UCHAR((Port), (Value))

Definition at line 32 of file legide.c.

ATAPORT_TAG

#define ATAPORT_TAG   'PedI'

Definition at line 27 of file legide.c.

CHANNEL_PC98_RESOURCE_COUNT

#define CHANNEL_PC98_RESOURCE_COUNT   12

CHANNEL_PCAT_RESOURCE_COUNT

#define CHANNEL_PCAT_RESOURCE_COUNT   3

IDE_DRIVE_SELECT

#define IDE_DRIVE_SELECT   0xA0

Definition at line 29 of file legide.c.

NDEBUG

#define NDEBUG

Definition at line 22 of file legide.c.

Typedef Documentation

ATA_LEGACY_CHANNEL

typedef struct _ATA_LEGACY_CHANNEL ATA_LEGACY_CHANNEL

PATA_LEGACY_CHANNEL

typedef struct _ATA_LEGACY_CHANNEL * PATA_LEGACY_CHANNEL

Function Documentation

AtaLegacyChannelBuildResources()

static BOOLEAN AtaLegacyChannelBuildResources ( _In_ PATA_LEGACY_CHANNEL  LegacyChannel, _Inout_ PCM_RESOURCE_LIST  ResourceList  )

static

Definition at line 338 of file legide.c.

{
    PCONFIGURATION_INFORMATION ConfigInfo = IoGetConfigurationInformation();
    PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor;
    ULONG i;
 
    Descriptor = &ResourceList->List[0].PartialResourceList.PartialDescriptors[0];
 
    if (IsNEC_98)
    {
        if (ConfigInfo->AtDiskPrimaryAddressClaimed || ConfigInfo->AtDiskSecondaryAddressClaimed)
            return FALSE;
 
#define CHANNEL_PC98_RESOURCE_COUNT    12
        /*
         * Make a resource list for the internal IDE interface:
         *
         * [ShareDisposition 1, Flags 11] IO:  Start 0:640, Len 1
         * [ShareDisposition 1, Flags 11] IO:  Start 0:74C, Len 1
         * [ShareDisposition 1, Flags 1]  INT: Lev 9 Vec 9 Aff FFFFFFFF
         * [ShareDisposition 1, Flags 11] IO:  Start 0:642, Len 1
         * [ShareDisposition 1, Flags 11] IO:  Start 0:644, Len 1
         * [ShareDisposition 1, Flags 11] IO:  Start 0:646, Len 1
         * [ShareDisposition 1, Flags 11] IO:  Start 0:648, Len 1
         * [ShareDisposition 1, Flags 11] IO:  Start 0:64A, Len 1
         * [ShareDisposition 1, Flags 11] IO:  Start 0:64C, Len 1
         * [ShareDisposition 1, Flags 11] IO:  Start 0:64E, Len 1
         * [ShareDisposition 1, Flags 11] IO:  Start 0:432, Len 2
         * [ShareDisposition 1, Flags 11] IO:  Start 0:435, Len 1
         */
        AtaLegacyMakePortResource(Descriptor++, 0x640, 1);
        AtaLegacyMakePortResource(Descriptor++, 0x74C, 1);
        AtaLegacyMakeInterruptResource(Descriptor++, 9);
        for (i = 0; i < 7; ++i)
        {
            AtaLegacyMakePortResource(Descriptor++, 0x642 + i * 2, 1);
        }
        AtaLegacyMakePortResource(Descriptor++, 0x432, 2);
        AtaLegacyMakePortResource(Descriptor++, 0x435, 1);
    }
    else
    {
        if (LegacyChannel->IoBase == 0x1F0 && ConfigInfo->AtDiskPrimaryAddressClaimed)
            return FALSE;
 
        if (LegacyChannel->IoBase == 0x170 && ConfigInfo->AtDiskSecondaryAddressClaimed)
            return FALSE;
 
#define CHANNEL_PCAT_RESOURCE_COUNT    3
        /*
         * For example, the following resource list is created for the primary IDE channel:
         *
         * [ShareDisposition 1, Flags 11] IO:  Start 0:1F0, Len 8
         * [ShareDisposition 1, Flags 11] IO:  Start 0:3F6, Len 1
         * [ShareDisposition 1, Flags 1]  INT: Lev A Vec A Aff FFFFFFFF
         */
        AtaLegacyMakePortResource(Descriptor++, LegacyChannel->IoBase, 8);
        AtaLegacyMakePortResource(Descriptor++, LegacyChannel->IoBase + 0x206, 1);
        AtaLegacyMakeInterruptResource(Descriptor++, LegacyChannel->Irq);
    }
 
    return TRUE;
}

Referenced by AtaLegacyDetectChannel().

AtaLegacyChannelPresent()

static BOOLEAN AtaLegacyChannelPresent ( _In_ PIDE_REGISTERS  Registers )

static

Definition at line 280 of file legide.c.

{
    ULONG i;
 
    /* Check for the PC-98 on-board IDE interface */
    if (IsNEC_98)
        return (ATA_READ((PUCHAR)0x432) != 0xFF);
 
    /*
     * The only reliable way to detect the legacy IDE channel
     * is to check for devices attached to the bus.
     */
    for (i = 0; i < MAX_IDE_DEVICE; ++i)
    {
        if (AtaLegacyFindAtaDevice(Registers, i))
        {
            DPRINT("Found IDE device\n");
            return TRUE;
        }
    }
 
    return FALSE;
}

Referenced by AtaLegacyDetectChannel().

AtaLegacyChannelTranslateResources()

static VOID AtaLegacyChannelTranslateResources ( _Inout_ PCM_RESOURCE_LIST  ResourceList, _In_ PUCHAR  CommandPortBase, _In_ PUCHAR  ControlPortBase  )

static

Definition at line 407 of file legide.c.

{
    PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor;
    KIRQL Irql;
 
    Descriptor = &ResourceList->List[0].PartialResourceList.PartialDescriptors[0];
 
    /* Move on to the interrupt descriptor */
    if (IsNEC_98)
    {
        Descriptor += 2;
    }
    else
    {
        Descriptor->u.Port.Start.QuadPart = (ULONG_PTR)CommandPortBase;
        ++Descriptor;
 
        Descriptor->u.Port.Start.QuadPart = (ULONG_PTR)ControlPortBase;
        ++Descriptor;
    }
    ASSERT(Descriptor->Type == CmResourceTypeInterrupt);
 
    Descriptor->u.Interrupt.Vector = HalGetInterruptVector(Isa,
                                                           0,
                                                           Descriptor->u.Interrupt.Level,
                                                           Descriptor->u.Interrupt.Vector,
                                                           &Irql,
                                                           &Descriptor->u.Interrupt.Affinity);
    Descriptor->u.Interrupt.Level = Irql;
}

Referenced by AtaLegacyDetectChannel().

AtaLegacyClaimHardwareResources()

static BOOLEAN AtaLegacyClaimHardwareResources ( _In_ PDRIVER_OBJECT  DriverObject, _In_ PCM_RESOURCE_LIST  ResourceList, _In_ ULONG  ResourceListSize  )

static

Definition at line 475 of file legide.c.

{
    NTSTATUS Status;
    BOOLEAN ConflictDetected;
 
    Status = IoReportResourceForDetection(DriverObject,
                                          ResourceList,
                                          ResourceListSize,
                                          NULL,
                                          NULL,
                                          0,
                                          &ConflictDetected);
    /* HACK: We really need to fix a number of resource bugs in the kernel */
    if (IsNEC_98)
        return TRUE;
 
    if (!NT_SUCCESS(Status) || ConflictDetected)
        return FALSE;
 
    return TRUE;
}

Referenced by AtaLegacyDetectChannel().

AtaLegacyDetectChannel()

static BOOLEAN AtaLegacyDetectChannel ( _In_ PDRIVER_OBJECT  DriverObject, _In_ PPCIIDEX_LEGACY_CONTROLLER_INTERFACE  ControllerInferface, _In_ PATA_LEGACY_CHANNEL  LegacyChannel, _In_ PCM_RESOURCE_LIST  ResourceList, _In_ ULONG  ResourceListSize  )

static

Definition at line 514 of file legide.c.

{
    BOOLEAN IsAddressMmio[2];
    PDEVICE_OBJECT PhysicalDeviceObject;
    PVOID ControllerContext;
    IDE_REGISTERS Registers;
    NTSTATUS Status;
    ULONG Spare;
 
    DPRINT("IDE Channel IO %lx, Irq %lu\n", LegacyChannel->IoBase, LegacyChannel->Irq);
 
    if (!AtaLegacyChannelBuildResources(LegacyChannel, ResourceList))
    {
        DPRINT("Failed to build the resource list\n");
        return FALSE;
    }
 
    if (!AtaLegacyClaimHardwareResources(DriverObject, ResourceList, ResourceListSize))
    {
        DPRINT("Failed to claim resources\n");
        return FALSE;
    }
 
    Status = STATUS_SUCCESS;
    IsAddressMmio[0] = FALSE;
    IsAddressMmio[1] = FALSE;
 
    if (IsNEC_98)
    {
        /* No translation required for the C-Bus I/O space */
        Registers.Data = (PVOID)0x640;
        Registers.Control = (PVOID)0x74C;
 
        Spare = 2;
    }
    else
    {
        Registers.Data = AtaLegacyTranslateBusAddress(LegacyChannel->IoBase,
                                                      8,
                                                      &IsAddressMmio[0]);
        if (!Registers.Data)
        {
            DPRINT("Failed to map command port\n");
 
            Status = STATUS_UNSUCCESSFUL;
            goto ReleaseResources;
        }
 
        Registers.Control = AtaLegacyTranslateBusAddress(LegacyChannel->IoBase + 0x206,
                                                         1,
                                                         &IsAddressMmio[1]);
        if (!Registers.Control)
        {
            DPRINT("Failed to map control port\n");
 
            Status = STATUS_UNSUCCESSFUL;
            goto ReleaseResources;
        }
 
        Spare = 1;
    }
    Registers.Error       = (PVOID)((ULONG_PTR)Registers.Data + 1 * Spare);
    Registers.SectorCount = (PVOID)((ULONG_PTR)Registers.Data + 2 * Spare);
    Registers.LbaLow      = (PVOID)((ULONG_PTR)Registers.Data + 3 * Spare);
    Registers.LbaMid      = (PVOID)((ULONG_PTR)Registers.Data + 4 * Spare);
    Registers.LbaHigh     = (PVOID)((ULONG_PTR)Registers.Data + 5 * Spare);
    Registers.Device      = (PVOID)((ULONG_PTR)Registers.Data + 6 * Spare);
    Registers.Status      = (PVOID)((ULONG_PTR)Registers.Data + 7 * Spare);
 
    if (!AtaLegacyChannelPresent(&Registers))
    {
        DPRINT("No IDE devices found\n");
        Status = STATUS_UNSUCCESSFUL;
    }
 
ReleaseResources:
    AtaLegacyReleaseHardwareResources(DriverObject);
 
    if (!NT_SUCCESS(Status))
        goto Cleanup;
 
    PhysicalDeviceObject = NULL;
    Status = IoReportDetectedDevice(DriverObject,
                                    InterfaceTypeUndefined,
                                    (ULONG)-1,
                                    (ULONG)-1,
                                    ResourceList,
                                    NULL,
                                    0,
                                    &PhysicalDeviceObject);
    if (!NT_SUCCESS(Status))
    {
        DPRINT("IoReportDetectedDevice() failed with status 0x%lx\n", Status);
        goto Cleanup;
    }
 
    if (ControllerInferface->Version != PCIIDEX_INTERFACE_VERSION)
    {
        /* ReactOS-specific: Retrieve the interface for legacy device detection */
        Status = PciIdeXInitialize(DriverObject,
                                   NULL,
                                   (PVOID)ControllerInferface,
                                   PCIIDEX_GET_CONTROLLER_INTERFACE_SIGNATURE);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("Failed to register the legacy channel 0x%lx, status 0x%lx\n",
                LegacyChannel->IoBase, Status);
            goto Cleanup;
        }
 
        if (ControllerInferface->Version != PCIIDEX_INTERFACE_VERSION)
        {
            DPRINT1("Unknown interface version 0x%lx\n", ControllerInferface->Version);
            Status = STATUS_REVISION_MISMATCH;
            goto Cleanup;
        }
    }
 
    Status = ControllerInferface->AddDevice(DriverObject, PhysicalDeviceObject, &ControllerContext);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to add the legacy channel 0x%lx, status 0x%lx\n",
            LegacyChannel->IoBase, Status);
        goto Cleanup;
    }
 
    AtaLegacyChannelTranslateResources(ResourceList, Registers.Data, Registers.Control);
 
    Status = ControllerInferface->StartDevice(ControllerContext, ResourceList);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to start the legacy channel 0x%lx, status 0x%lx\n",
            LegacyChannel->IoBase, Status);
 
        ControllerInferface->RemoveDevice(ControllerContext);
    }
 
Cleanup:
    if (IsAddressMmio[0] && Registers.Data)
    {
        MmUnmapIoSpace(Registers.Data, 8);
    }
 
    if (IsAddressMmio[1] && Registers.Control)
    {
        MmUnmapIoSpace(Registers.Control, 1);
    }
 
    return NT_SUCCESS(Status);
}

Referenced by DriverEntry().

AtaLegacyFetchIdentifyData()

static VOID AtaLegacyFetchIdentifyData ( _In_ PIDE_REGISTERS  Registers )

static

Definition at line 82 of file legide.c.

{
    USHORT Buffer[256];
 
    READ_PORT_BUFFER_USHORT((PUSHORT)Registers->Data, Buffer, RTL_NUMBER_OF(Buffer));
}

Referenced by AtaLegacyIdentifyDevice().

AtaLegacyFindAtaDevice()

static BOOLEAN AtaLegacyFindAtaDevice ( _In_ PIDE_REGISTERS  Registers, _In_ ULONG  DeviceNumber  )

static

Definition at line 213 of file legide.c.

{
    UCHAR IdeStatus, SignatureLow, SignatureHigh;
 
    /* Select the device */
    ATA_WRITE(Registers->Device, ((DeviceNumber << 4) | IDE_DRIVE_SELECT));
    ATA_IO_WAIT();
 
    /* Do a quick check first */
    IdeStatus = ATA_READ(Registers->Status);
    if (IdeStatus == 0xFF || IdeStatus == 0x7F)
        return FALSE;
 
    /* Look at controller */
    ATA_WRITE(Registers->ByteCountLow, 0x55);
    ATA_WRITE(Registers->ByteCountLow, 0xAA);
    ATA_WRITE(Registers->ByteCountLow, 0x55);
    if (ATA_READ(Registers->ByteCountLow) != 0x55)
        return FALSE;
    ATA_WRITE(Registers->ByteCountHigh, 0xAA);
    ATA_WRITE(Registers->ByteCountHigh, 0x55);
    ATA_WRITE(Registers->ByteCountHigh, 0xAA);
    if (ATA_READ(Registers->ByteCountHigh) != 0xAA)
        return FALSE;
 
    /* Wait for busy to clear */
    IdeStatus = AtaWait(Registers, ATA_TIME_BUSY_SELECT, IDE_STATUS_BUSY, 0);
    if (IdeStatus & IDE_STATUS_BUSY)
    {
        DPRINT1("Device is busy, attempting to recover %02x\n", IdeStatus);
 
        if (!AtaLegacyPerformSoftwareReset(Registers, DeviceNumber))
        {
            DPRINT1("Failed to reset device %02x\n", ATA_READ(Registers->Status));
            return FALSE;
        }
    }
 
    /* Check for ATA */
    if (AtaLegacyIdentifyDevice(Registers, DeviceNumber, IDE_COMMAND_IDENTIFY))
        return TRUE;
 
    SignatureLow = ATA_READ(Registers->SignatureLow);
    SignatureHigh = ATA_READ(Registers->SignatureHigh);
 
    DPRINT("SL = 0x%02x, SH = 0x%02x\n", SignatureLow, SignatureHigh);
 
    /* Check for ATAPI */
    if (SignatureLow == 0x14 && SignatureHigh == 0xEB)
        return TRUE;
 
    /*
     * ATAPI devices abort the IDENTIFY command and return an ATAPI signature
     * in the task file registers. However the NEC CDR-260 drive doesn't return
     * the correct signature, but instead shows up with zeroes.
     * This drive also reports an ATA signature after device reset.
     * To overcome this behavior, we try the ATAPI IDENTIFY command.
     * It should be successfully completed or failed (aborted or time-out).
     */
    return AtaLegacyIdentifyDevice(Registers, DeviceNumber, IDE_COMMAND_ATAPI_IDENTIFY);
}

Referenced by AtaLegacyChannelPresent().

AtaLegacyIdentifyDevice()

static BOOLEAN AtaLegacyIdentifyDevice ( _In_ PIDE_REGISTERS  Registers, _In_ ULONG  DeviceNumber, _In_ UCHAR  Command  )

static

Definition at line 93 of file legide.c.

{
    UCHAR IdeStatus;
 
    /* Select the device */
    ATA_WRITE(Registers->Device, ((DeviceNumber << 4) | IDE_DRIVE_SELECT));
    ATA_IO_WAIT();
    IdeStatus = AtaWait(Registers, ATA_TIME_BUSY_SELECT, IDE_STATUS_BUSY, 0);
    if (IdeStatus & IDE_STATUS_BUSY)
    {
        DPRINT("Timeout, status 0x%02x\n", IdeStatus);
        return FALSE;
    }
 
    ATA_WRITE(Registers->Features, 0);
    ATA_WRITE(Registers->SectorCount, 0);
    ATA_WRITE(Registers->LbaLow, 0);
    ATA_WRITE(Registers->LbaMid, 0);
    ATA_WRITE(Registers->LbaHigh, 0);
    ATA_WRITE(Registers->Command, Command);
 
    /* Need to wait for a valid status */
    ATA_IO_WAIT();
 
    /* Now wait for busy to clear */
    IdeStatus = AtaWait(Registers, ATA_TIME_BUSY_IDENTIFY, IDE_STATUS_BUSY, 0);
    if (IdeStatus & IDE_STATUS_BUSY)
    {
        DPRINT("Timeout, status 0x%02x\n", IdeStatus);
        return FALSE;
    }
    if (IdeStatus & ((IDE_STATUS_ERROR | IDE_STATUS_DEVICE_FAULT)))
    {
        DPRINT("Command 0x%02x aborted, status 0x%02x, error 0x%02x\n",
              Command,
              IdeStatus,
              ATA_READ(Registers->Error));
        return FALSE;
    }
    if (!(IdeStatus & IDE_STATUS_DRQ))
    {
        DPRINT1("DRQ not set, status 0x%02x\n", IdeStatus);
        return FALSE;
    }
 
    /* Complete the data transfer */
    AtaLegacyFetchIdentifyData(Registers);
 
    /* All data has been transferred, wait for DRQ to clear */
    IdeStatus = AtaWait(Registers,
                        ATA_TIME_DRQ_CLEAR,
                        IDE_STATUS_BUSY | IDE_STATUS_DRQ,
                        0);
    if (IdeStatus & (IDE_STATUS_BUSY | IDE_STATUS_DRQ))
    {
        DPRINT1("DRQ not cleared, status 0x%02x\n", IdeStatus);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by AtaLegacyFindAtaDevice().

AtaLegacyMakeInterruptResource()

static VOID AtaLegacyMakeInterruptResource ( _Out_ PCM_PARTIAL_RESOURCE_DESCRIPTOR  Descriptor, _In_ ULONG  Level  )

static

Definition at line 323 of file legide.c.

{
    Descriptor->Type = CmResourceTypeInterrupt;
    Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
    Descriptor->Flags = CM_RESOURCE_INTERRUPT_LATCHED;
    Descriptor->u.Interrupt.Level = Level;
    Descriptor->u.Interrupt.Vector = Level;
    Descriptor->u.Interrupt.Affinity = (KAFFINITY)-1;
}

Referenced by AtaLegacyChannelBuildResources().

AtaLegacyMakePortResource()

static VOID AtaLegacyMakePortResource ( _Out_ PCM_PARTIAL_RESOURCE_DESCRIPTOR  Descriptor, _In_ ULONG  IoBase, _In_ ULONG  Length  )

static

Definition at line 308 of file legide.c.

{
    Descriptor->Type = CmResourceTypePort;
    Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
    Descriptor->Flags = CM_RESOURCE_PORT_IO | CM_RESOURCE_PORT_16_BIT_DECODE;
    Descriptor->u.Port.Start.u.LowPart = IoBase;
    Descriptor->u.Port.Length = Length;
}

Referenced by AtaLegacyChannelBuildResources().

AtaLegacyPerformSoftwareReset()

static BOOLEAN AtaLegacyPerformSoftwareReset ( _In_ PIDE_REGISTERS  Registers, _In_ ULONG  DeviceNumber  )

static

Definition at line 161 of file legide.c.

{
    UCHAR IdeStatus;
    ULONG i;
 
    /* Perform a software reset */
    ATA_WRITE(Registers->Control, IDE_DC_RESET_CONTROLLER);
    KeStallExecutionProcessor(20);
    ATA_WRITE(Registers->Control, IDE_DC_DISABLE_INTERRUPTS);
    KeStallExecutionProcessor(20);
 
    /* The reset will cause the master device to be selected */
    if ((DeviceNumber & 1) != 0)
    {
        for (i = ATA_TIME_RESET_SELECT; i > 0; i--)
        {
            /* Select the device again */
            ATA_WRITE(Registers->Device, ((DeviceNumber << 4) | IDE_DRIVE_SELECT));
            ATA_IO_WAIT();
 
            /* Check whether the selection was successful */
            ATA_WRITE(Registers->ByteCountLow, 0xAA);
            ATA_WRITE(Registers->ByteCountLow, 0x55);
            ATA_WRITE(Registers->ByteCountLow, 0xAA);
            if (ATA_READ(Registers->ByteCountLow) == 0xAA)
                break;
 
            KeStallExecutionProcessor(10);
        }
        if (i == 0)
        {
            DPRINT("Selection timeout\n");
            return FALSE;
        }
    }
 
    /* Now wait for busy to clear */
    IdeStatus = AtaWait(Registers, ATA_TIME_BUSY_RESET, IDE_STATUS_BUSY, 0);
    if (IdeStatus & IDE_STATUS_BUSY)
    {
        DPRINT1("Timeout, status 0x%02x\n", IdeStatus);
        return FALSE;
    }
 
    return FALSE;
}

Referenced by AtaLegacyFindAtaDevice().

AtaLegacyReleaseHardwareResources()

static VOID AtaLegacyReleaseHardwareResources ( _In_ PDRIVER_OBJECT  DriverObject )

static

Definition at line 503 of file legide.c.

{
    BOOLEAN Dummy;
 
    IoReportResourceForDetection(DriverObject, NULL, 0, NULL, NULL, 0, &Dummy);
}

Referenced by AtaLegacyDetectChannel().

AtaLegacyShouldDetectChannels()

static BOOLEAN AtaLegacyShouldDetectChannels ( _In_ PUNICODE_STRING  RegistryPath )

static

Definition at line 693 of file legide.c.

{
    NTSTATUS Status;
    ULONG KeyValue;
    BOOLEAN PerformDetection;
    HANDLE SoftKeyHandle, ParamsKeyHandle;
    RTL_QUERY_REGISTRY_TABLE QueryTable[2];
    UNICODE_STRING ParametersKeyName = RTL_CONSTANT_STRING(L"Parameters");
    static const WCHAR MapperKeyPath[] =
        L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Pnp";
 
    PAGED_CODE();
 
    /*
     * Read the firmware mapper key. If the firmware mapper is disabled,
     * it is the responsibility of PnP drivers (ACPI, PCI, and others)
     * to detect and enumerate IDE channels.
     */
    KeyValue = 0;
    RtlZeroMemory(QueryTable, sizeof(QueryTable));
    QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
    QueryTable[0].Name = L"DisableFirmwareMapper";
    QueryTable[0].EntryContext = &KeyValue;
    Status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE, MapperKeyPath, QueryTable, NULL, NULL);
    if (NT_SUCCESS(Status) && (KeyValue != 0))
    {
        DPRINT("Skipping legacy detection on a PnP system\n");
        return FALSE;
    }
 
    /* Open the driver's software key */
    Status = AtaOpenRegistryKey(&SoftKeyHandle, NULL, RegistryPath);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to open the '%wZ' key, status 0x%lx\n", RegistryPath, Status);
        return FALSE;
    }
 
    /* Open the 'Parameters' key */
    Status = AtaOpenRegistryKey(&ParamsKeyHandle, SoftKeyHandle, &ParametersKeyName);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to open the 'Parameters' key, status 0x%lx\n", Status);
 
        ZwClose(SoftKeyHandle);
        return FALSE;
    }
 
    /* Check whether it is the first time we detect IDE channels */
    KeyValue = 0;
    RtlZeroMemory(QueryTable, sizeof(QueryTable));
    QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED;
    QueryTable[0].Name = L"LegacyDetection";
    QueryTable[0].EntryContext = &KeyValue;
    RtlQueryRegistryValues(RTL_REGISTRY_HANDLE,
                           (PWSTR)ParamsKeyHandle,
                           QueryTable,
                           NULL,
                           NULL);
    PerformDetection = (KeyValue != 0);
 
    /* Do not detect devices again on subsequent boots after driver installation */
    if (PerformDetection)
    {
        KeyValue = 0;
        RtlWriteRegistryValue(RTL_REGISTRY_HANDLE,
                              (PWSTR)ParamsKeyHandle,
                              L"LegacyDetection",
                              REG_DWORD,
                              &KeyValue,
                              sizeof(KeyValue));
    }
 
    ZwClose(ParamsKeyHandle);
    ZwClose(SoftKeyHandle);
 
    return PerformDetection;
}

Referenced by DriverEntry().

AtaLegacyTranslateBusAddress()

static PVOID AtaLegacyTranslateBusAddress ( _In_ ULONG  Address, _In_ ULONG  NumberOfBytes, _Out_ PBOOLEAN  IsAddressMmio  )

static

Definition at line 444 of file legide.c.

{
    ULONG AddressSpace;
    BOOLEAN Success;
    PHYSICAL_ADDRESS BusAddress, TranslatedAddress;
 
    BusAddress.QuadPart = Address;
    AddressSpace = 1; // I/O space
    Success = HalTranslateBusAddress(Isa, 0, BusAddress, &AddressSpace, &TranslatedAddress);
    if (!Success)
        return NULL;
 
    /* I/O space */
    if (AddressSpace != 0)
    {
        *IsAddressMmio = FALSE;
        return (PVOID)(ULONG_PTR)TranslatedAddress.QuadPart;
    }
    else
    {
        *IsAddressMmio = TRUE;
        return MmMapIoSpace(TranslatedAddress, NumberOfBytes, MmNonCached);
    }
}

Referenced by AtaLegacyDetectChannel().

AtaOpenRegistryKey()

static NTSTATUS AtaOpenRegistryKey ( _Out_ PHANDLE  KeyHandle, _In_ HANDLE  RootKey, _In_ PUNICODE_STRING  KeyName  )

static

Definition at line 673 of file legide.c.

{
    OBJECT_ATTRIBUTES ObjectAttributes;
 
    PAGED_CODE();
 
    InitializeObjectAttributes(&ObjectAttributes,
                               KeyName,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               RootKey,
                               NULL);
    return ZwOpenKey(KeyHandle, KEY_ALL_ACCESS, &ObjectAttributes);
}

Referenced by AtaLegacyShouldDetectChannels().

AtaWait()

static UCHAR AtaWait ( _In_ PIDE_REGISTERS  Registers, _In_range_(>, 0) ULONG  Timeout, _In_ UCHAR  Mask, _In_ UCHAR  Value  )

static

Definition at line 55 of file legide.c.

{
    UCHAR IdeStatus;
    ULONG i;
 
    for (i = 0; i < Timeout; ++i)
    {
        IdeStatus = ATA_READ(Registers->Status);
        if ((IdeStatus & Mask) == Value)
            break;
 
        if (IdeStatus == 0xFF)
            break;
 
        KeStallExecutionProcessor(10);
    }
 
    return IdeStatus;
}

Referenced by AtaLegacyFindAtaDevice(), AtaLegacyIdentifyDevice(), and AtaLegacyPerformSoftwareReset().

DriverEntry()

NTSTATUS NTAPI DriverEntry	(	_In_ PDRIVER_OBJECT	DriverObject,
		_In_ PUNICODE_STRING	RegistryPath
	)

Definition at line 776 of file legide.c.

{
    PCIIDEX_LEGACY_CONTROLLER_INTERFACE ControllerInferface = { 0 };
    ATA_LEGACY_CHANNEL LegacyChannel[4 + 1] = { 0 };
    PCM_RESOURCE_LIST ResourceList;
    ULONG i, ListSize, ResourceCount;
    NTSTATUS Status;
 
    if (!AtaLegacyShouldDetectChannels(RegistryPath))
        return STATUS_CANCELLED;
 
    if (IsNEC_98)
    {
        /* Internal IDE interface */
        LegacyChannel[0].IoBase = 0x640;
        LegacyChannel[0].Irq = 9;
 
        ResourceCount = CHANNEL_PC98_RESOURCE_COUNT;
    }
    else
    {
        /* Primary IDE channel */
        LegacyChannel[0].IoBase = 0x1F0;
        LegacyChannel[0].Irq = 14;
 
        /* Secondary IDE channel */
        LegacyChannel[1].IoBase = 0x170;
        LegacyChannel[1].Irq = 15;
 
        /* Tertiary IDE channel */
        LegacyChannel[2].IoBase = 0x1E8;
        LegacyChannel[2].Irq = 11;
 
        /* Quaternary IDE channel */
        LegacyChannel[3].IoBase = 0x168;
        LegacyChannel[3].Irq = 10;
 
        ResourceCount = CHANNEL_PCAT_RESOURCE_COUNT;
    }
 
    ListSize = FIELD_OFFSET(CM_RESOURCE_LIST, List[0].PartialResourceList.PartialDescriptors) +
               sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR) * ResourceCount;
 
    ResourceList = ExAllocatePoolZero(PagedPool, ListSize, ATAPORT_TAG);
    if (!ResourceList)
    {
        DPRINT1("Failed to allocate the resource list\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    ResourceList->Count = 1;
    ResourceList->List[0].InterfaceType = Isa;
    ResourceList->List[0].BusNumber = 0;
    ResourceList->List[0].PartialResourceList.Version = 1;
    ResourceList->List[0].PartialResourceList.Revision = 1;
    ResourceList->List[0].PartialResourceList.Count = ResourceCount;
 
    Status = STATUS_NOT_FOUND;
 
    for (i = 0; LegacyChannel[i].IoBase != 0; ++i)
    {
        if (AtaLegacyDetectChannel(DriverObject,
                                   &ControllerInferface,
                                   &LegacyChannel[i],
                                   ResourceList,
                                   ListSize))
        {
            Status = STATUS_SUCCESS;
        }
    }
 
    ExFreePoolWithTag(ResourceList, ATAPORT_TAG);
    return Status;
}

Variable Documentation

DriverEntry

DRIVER_INITIALIZE DriverEntry

Definition at line 48 of file legide.c.