|
|
/*++
Copyright (C) 1997-99 Microsoft Corporation
Module Name:
detect.c
Abstract:
This contain legacy detection routines
Author:
Joe Dai (joedai)
Environment:
kernel mode only
Notes:
Revision History:
--*/
#include "ideport.h"
#if !defined(NO_LEGACY_DRIVERS)
#ifdef ALLOC_PRAGMA
#pragma alloc_text(INIT, IdePortDetectLegacyController)
#pragma alloc_text(INIT, IdePortCreateDetectionList)
#pragma alloc_text(INIT, IdePortTranslateAddress)
#pragma alloc_text(INIT, IdePortFreeTranslatedAddress)
#pragma alloc_text(INIT, IdePortDetectAlias)
#endif // ALLOC_PRAGMA
NTSTATUSIdePortDetectLegacyController ( IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)/*++
Routine Description:
Detect legacy IDE controllers and report them to PnP
Arguments:
DriverObject - this driver's driver object
RegistryPath - this driver's registry path
Return Value:
NT Status
--*/{ ULONG cmResourceListSize; PCM_RESOURCE_LIST cmResourceList = NULL; PCM_FULL_RESOURCE_DESCRIPTOR cmFullResourceDescriptor; PCM_PARTIAL_RESOURCE_LIST cmPartialResourceList; PCM_PARTIAL_RESOURCE_DESCRIPTOR cmPartialDescriptors;
BOOLEAN conflictDetected; BOOLEAN resourceIsCmdPort;
PDEVICE_OBJECT detectedPhysicalDeviceObject; PFDO_EXTENSION fdoExtension = NULL;
UNICODE_STRING deviceClassName;
NTSTATUS status; PDETECTION_PORT detectionPort; ULONG numPort;
ULONG portNumber; ULONG deviceNumber; ULONG descriptorNumber; ULONG cmdAddressSpace; ULONG ctrlAddressSpace; PUCHAR cmdRegBase; PUCHAR ctrlRegBase; IDE_REGISTERS_1 baseIoAddress1; IDE_REGISTERS_2 baseIoAddress2; PHYSICAL_ADDRESS cmdRegMemoryBase; PHYSICAL_ADDRESS ctrlRegMemoryBase; UCHAR statusByte; ULONG baseIoAddress1Length; ULONG baseIoAddress2Length; ULONG maxIdeDevice;
UCHAR altMasterStatus; UCHAR altSlaveStatus;
#if !defined (ALWAYS_DO_LEGACY_DETECTION)
if (!IdePortOkToDetectLegacy(DriverObject)) {
//
// legacy detection is not enabled
//
return STATUS_SUCCESS; }#endif
//
// make up a list of popular legacy I/O ports
//
status = IdePortCreateDetectionList ( DriverObject, &detectionPort, &numPort ); if (!NT_SUCCESS(status)) {
goto GetOut; }
//
// Resource Requirement List
//
cmResourceListSize = sizeof (CM_RESOURCE_LIST) + sizeof (CM_PARTIAL_RESOURCE_DESCRIPTOR) * (((!IsNEC_98) ? 3 : 12) - 1); cmResourceList = ExAllocatePool (PagedPool, cmResourceListSize); if (cmResourceList == NULL){
status = STATUS_NO_MEMORY; goto GetOut;
}
RtlZeroMemory(cmResourceList, cmResourceListSize); RtlInitUnicodeString(&deviceClassName, L"ScsiAdapter");
for (portNumber=0; portNumber<numPort; portNumber++) {
//
// Build io address structure.
//
AtapiBuildIoAddress ( (PUCHAR)detectionPort[portNumber].CommandRegisterBase, (PUCHAR)detectionPort[portNumber].ControlRegisterBase, &baseIoAddress1, &baseIoAddress2, &baseIoAddress1Length, &baseIoAddress2Length, &maxIdeDevice, NULL);
//
// Build resource requirement list
//
cmResourceList->Count = 1;
cmFullResourceDescriptor = cmResourceList->List; cmFullResourceDescriptor->InterfaceType = Isa; cmFullResourceDescriptor->BusNumber = 0;
cmPartialResourceList = &cmFullResourceDescriptor->PartialResourceList; cmPartialResourceList->Version = 1; cmPartialResourceList->Revision = 1; cmPartialResourceList->Count = 3;
cmPartialDescriptors = cmPartialResourceList->PartialDescriptors;
cmPartialDescriptors[0].Type = CmResourceTypePort; cmPartialDescriptors[0].ShareDisposition = CmResourceShareDeviceExclusive; cmPartialDescriptors[0].Flags = CM_RESOURCE_PORT_IO | (!Is98LegacyIde(&baseIoAddress1)? CM_RESOURCE_PORT_10_BIT_DECODE : CM_RESOURCE_PORT_16_BIT_DECODE); cmPartialDescriptors[0].u.Port.Length = baseIoAddress1Length; cmPartialDescriptors[0].u.Port.Start.QuadPart = detectionPort[portNumber].CommandRegisterBase;
cmPartialDescriptors[1].Type = CmResourceTypePort; cmPartialDescriptors[1].ShareDisposition = CmResourceShareDeviceExclusive; cmPartialDescriptors[1].Flags = CM_RESOURCE_PORT_IO | (!Is98LegacyIde(&baseIoAddress1)? CM_RESOURCE_PORT_10_BIT_DECODE : CM_RESOURCE_PORT_16_BIT_DECODE); cmPartialDescriptors[1].u.Port.Length = 1; cmPartialDescriptors[1].u.Port.Start.QuadPart = detectionPort[portNumber].ControlRegisterBase;
cmPartialDescriptors[2].Type = CmResourceTypeInterrupt; cmPartialDescriptors[2].ShareDisposition = CmResourceShareDeviceExclusive; cmPartialDescriptors[2].Flags = CM_RESOURCE_INTERRUPT_LATCHED; cmPartialDescriptors[2].u.Interrupt.Level = detectionPort[portNumber].IrqLevel; cmPartialDescriptors[2].u.Interrupt.Vector = detectionPort[portNumber].IrqLevel; cmPartialDescriptors[2].u.Interrupt.Affinity = -1;
if (Is98LegacyIde(&baseIoAddress1)) {
ULONG resourceCount; ULONG commandRegisters;
commandRegisters = detectionPort[portNumber].CommandRegisterBase + 2; resourceCount = 3;
while (commandRegisters < (IDE_NEC98_COMMAND_PORT_ADDRESS + 0x10)) { cmPartialDescriptors[resourceCount].Type = CmResourceTypePort; cmPartialDescriptors[resourceCount].ShareDisposition = CmResourceShareDeviceExclusive; cmPartialDescriptors[resourceCount].Flags = CM_RESOURCE_PORT_IO | CM_RESOURCE_PORT_16_BIT_DECODE; cmPartialDescriptors[resourceCount].u.Port.Length = 1; cmPartialDescriptors[resourceCount].u.Port.Start.QuadPart = commandRegisters;
resourceCount++; commandRegisters += 2; }
cmPartialDescriptors[resourceCount].Type = CmResourceTypePort; cmPartialDescriptors[resourceCount].ShareDisposition = CmResourceShareDeviceExclusive; cmPartialDescriptors[resourceCount].Flags = CM_RESOURCE_PORT_IO | CM_RESOURCE_PORT_16_BIT_DECODE; cmPartialDescriptors[resourceCount].u.Port.Length = 2; cmPartialDescriptors[resourceCount].u.Port.Start.QuadPart = (ULONG_PTR)SELECT_IDE_PORT;
resourceCount++;
cmPartialDescriptors[resourceCount].Type = CmResourceTypePort; cmPartialDescriptors[resourceCount].ShareDisposition = CmResourceShareDeviceExclusive; cmPartialDescriptors[resourceCount].Flags = CM_RESOURCE_PORT_IO | CM_RESOURCE_PORT_16_BIT_DECODE; cmPartialDescriptors[resourceCount].u.Port.Length = 1; cmPartialDescriptors[resourceCount].u.Port.Start.QuadPart = (ULONG_PTR)SELECT_IDE_PORT + 3;
resourceCount++;
cmPartialResourceList->Count = resourceCount; }
//
// check to see if the resource is available
// if not, assume no legacy IDE controller
// is at the this location
//
for (deviceNumber=0; deviceNumber<2; deviceNumber++) {
status = IoReportResourceForDetection ( DriverObject, cmResourceList, cmResourceListSize, NULL, NULL, 0, &conflictDetected );
if (NT_SUCCESS(status) && !conflictDetected) {
//
// got our resources
//
break;
} else {
if (NT_SUCCESS(status)) {
IoReportResourceForDetection ( DriverObject, NULL, 0, NULL, NULL, 0, &conflictDetected );
status = STATUS_UNSUCCESSFUL; }
//
// try 16 bit decode
//
cmPartialDescriptors[0].Flags = CM_RESOURCE_PORT_IO | CM_RESOURCE_PORT_16_BIT_DECODE; cmPartialDescriptors[1].Flags = CM_RESOURCE_PORT_IO | CM_RESOURCE_PORT_16_BIT_DECODE;
if (Is98LegacyIde(&baseIoAddress1)) { ULONG k;
for (k=3; k<12; k++) { cmPartialDescriptors[k].Flags = CM_RESOURCE_PORT_IO | CM_RESOURCE_PORT_16_BIT_DECODE; } } } }
if (!NT_SUCCESS(status)) {
continue; }
//
// translate the i/o port via Hal
//
status = STATUS_SUCCESS;
if (Is98LegacyIde(&baseIoAddress1)) { for (descriptorNumber=3; descriptorNumber<12; descriptorNumber++) { cmdRegBase = NULL; cmdAddressSpace = IO_SPACE;
status = IdePortTranslateAddress ( cmFullResourceDescriptor->InterfaceType, cmFullResourceDescriptor->BusNumber, cmPartialDescriptors[descriptorNumber].u.Port.Start, cmPartialDescriptors[descriptorNumber].u.Port.Length, &cmdAddressSpace, &cmdRegBase, &cmdRegMemoryBase ); if (!NT_SUCCESS(status)) { break; } } }
if (NT_SUCCESS(status)) {
cmdRegBase = NULL; ctrlRegBase = NULL; cmdAddressSpace = IO_SPACE;
status = IdePortTranslateAddress ( cmFullResourceDescriptor->InterfaceType, cmFullResourceDescriptor->BusNumber, cmPartialDescriptors[0].u.Port.Start, cmPartialDescriptors[0].u.Port.Length, &cmdAddressSpace, &cmdRegBase, &cmdRegMemoryBase ); }
if (NT_SUCCESS(status)) {
ctrlRegBase = NULL; ctrlAddressSpace = IO_SPACE; status = IdePortTranslateAddress ( cmFullResourceDescriptor->InterfaceType, cmFullResourceDescriptor->BusNumber, cmPartialDescriptors[1].u.Port.Start, cmPartialDescriptors[1].u.Port.Length, &ctrlAddressSpace, &ctrlRegBase, &ctrlRegMemoryBase ); }
if (NT_SUCCESS(status)) {
//
// 2nd build io address structure.
//
AtapiBuildIoAddress ( cmdRegBase, ctrlRegBase, &baseIoAddress1, &baseIoAddress2, &baseIoAddress1Length, &baseIoAddress2Length, &maxIdeDevice, NULL);
//
// The IBM Aptiva ide channel with the external cdrom doesn't power up with any device selected
// we must select a device; otherwise, we get a 0xff from all IO ports
//
SelectIdeDevice(&baseIoAddress1, 0, 0); altMasterStatus = IdePortInPortByte(baseIoAddress2.DeviceControl);
SelectIdeDevice(&baseIoAddress1, 1, 0); altSlaveStatus = IdePortInPortByte(baseIoAddress2.DeviceControl);
if ((!Is98LegacyIde(&baseIoAddress1)) && (altMasterStatus == 0xff) && (altSlaveStatus == 0xff)) {
//
// the alternate status byte is 0xff,
// guessing we have a SCSI adapter (DPT) that emulate IDE controller
// say the channel is empty, let the real SCSI driver picks up
// the controller
//
status = STATUS_UNSUCCESSFUL;
//
// Note: The IDE port on SB16/AWE32 does not have the alternate status
// register. Because of this alternate status test, we will fail to
// detect this IDE port. However, this IDE port should be enumerated
// by ISA-PnP bus driver.
//
} else if (IdePortChannelEmpty (&baseIoAddress1, &baseIoAddress2, maxIdeDevice)) {
//
// channel looks empty
//
status = STATUS_UNSUCCESSFUL;
} else {
BOOLEAN deviceFound; IDENTIFY_DATA IdentifyData; ULONG i;
for (i=0; i<maxIdeDevice; i++) {
if (Is98LegacyIde(&baseIoAddress1)) { UCHAR driveHeadReg;
//
// Check master device only.
//
if ( i & 0x1 ) {
continue; }
//
// Check device is present.
//
SelectIdeDevice(&baseIoAddress1, i, 0); driveHeadReg = IdePortInPortByte(baseIoAddress1.DriveSelect);
if (driveHeadReg != ((i & 0x1) << 4 | 0xA0)) { //
// Bad controller.
//
continue; } }
//
// Is there a ATA device?
//
deviceFound = IssueIdentify( &baseIoAddress1, &baseIoAddress2, i, IDE_COMMAND_IDENTIFY, TRUE, &IdentifyData ); if (deviceFound) { break; }
//
// Is there a ATAPI device?
//
deviceFound = IssueIdentify( &baseIoAddress1, &baseIoAddress2, i, IDE_COMMAND_ATAPI_IDENTIFY, TRUE, &IdentifyData ); if (deviceFound) { break; } }
if (!deviceFound) {
status = STATUS_UNSUCCESSFUL; } } }
if (!NT_SUCCESS (status)) {
//
// if we didn't found anything,
// unmap the reosurce
//
if (cmdRegBase) {
IdePortFreeTranslatedAddress ( cmdRegBase, cmPartialDescriptors[0].u.Port.Length, cmdAddressSpace );
if (Is98LegacyIde(&baseIoAddress1)) { for (descriptorNumber=3; descriptorNumber<12; descriptorNumber++) { IdePortFreeTranslatedAddress ( cmdRegBase, cmPartialDescriptors[descriptorNumber].u.Port.Length, cmdAddressSpace ); } } }
if (ctrlRegBase) {
IdePortFreeTranslatedAddress ( ctrlRegBase, cmPartialDescriptors[1].u.Port.Length, ctrlAddressSpace ); }
} else {
//
// check for alias ports
//
if (cmPartialDescriptors[0].Flags & CM_RESOURCE_PORT_10_BIT_DECODE) {
if (!IdePortDetectAlias (&baseIoAddress1)) {
cmPartialDescriptors[0].Flags = CM_RESOURCE_PORT_IO | CM_RESOURCE_PORT_16_BIT_DECODE; cmPartialDescriptors[1].Flags = CM_RESOURCE_PORT_IO | CM_RESOURCE_PORT_16_BIT_DECODE;
if (Is98LegacyIde(&baseIoAddress1)) { for (descriptorNumber=3; descriptorNumber<12; descriptorNumber++) { cmPartialDescriptors[descriptorNumber].Flags = CM_RESOURCE_PORT_IO | CM_RESOURCE_PORT_16_BIT_DECODE; } } } } }
//
// release the resources we have grab, IoReportDetectedDevice()
// will grab them for us again when we call and it will grab them
// on behalf of the detected PDO.
//
IoReportResourceForDetection ( DriverObject, NULL, 0, NULL, NULL, 0, &conflictDetected );
if (NT_SUCCESS(status)) {
detectedPhysicalDeviceObject = NULL;
status = IoReportDetectedDevice(DriverObject, InterfaceTypeUndefined, -1, -1, cmResourceList, NULL, FALSE, &detectedPhysicalDeviceObject);
if (NT_SUCCESS (status)) {
//
// create a FDO and attach it to the detected PDO
//
status = ChannelAddChannel ( DriverObject, detectedPhysicalDeviceObject, &fdoExtension );
if (NT_SUCCESS (status)) {
PCM_FULL_RESOURCE_DESCRIPTOR fullResourceList; PCM_PARTIAL_RESOURCE_LIST partialResourceList; PCM_PARTIAL_RESOURCE_DESCRIPTOR partialDescriptors; ULONG i, j;
//
// translate resources
//
fullResourceList = cmResourceList->List; for (i=0; i<cmResourceList->Count; i++) {
partialResourceList = &(fullResourceList->PartialResourceList); partialDescriptors = fullResourceList->PartialResourceList.PartialDescriptors;
for (j=0; j<partialResourceList->Count; j++) {
resourceIsCmdPort = FALSE;
if (!Is98LegacyIde(&baseIoAddress1)) {
if ((partialDescriptors[j].Type == CmResourceTypePort) && (partialDescriptors[j].u.Port.Length == baseIoAddress1Length)) {
resourceIsCmdPort = TRUE; } } else {
if ((partialDescriptors[j].Type == CmResourceTypePort) && (partialDescriptors[j].u.Port.Start.QuadPart == IDE_NEC98_COMMAND_PORT_ADDRESS)) {
resourceIsCmdPort = TRUE;
} else if ((partialDescriptors[j].Type == CmResourceTypePort) && (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 (resourceIsCmdPort) {
if (cmdAddressSpace == MEMORY_SPACE) {
partialDescriptors[j].Type = CmResourceTypeMemory; partialDescriptors[j].u.Memory.Start = cmdRegMemoryBase; partialDescriptors[j].u.Memory.Length = partialDescriptors[j].u.Port.Length;
} else {
partialDescriptors[j].u.Port.Start.QuadPart = (ULONG_PTR) cmdRegBase; }
} else if ((partialDescriptors[j].Type == CmResourceTypePort) && (partialDescriptors[j].u.Port.Length == 1)) {
if (ctrlAddressSpace == MEMORY_SPACE) {
partialDescriptors[j].Type = CmResourceTypeMemory; partialDescriptors[j].u.Memory.Start = ctrlRegMemoryBase; partialDescriptors[j].u.Memory.Length = partialDescriptors[j].u.Port.Length;
} else {
partialDescriptors[j].u.Port.Start.QuadPart = (ULONG_PTR) ctrlRegBase; }
} else if (partialDescriptors[j].Type == CmResourceTypeInterrupt) {
partialDescriptors[j].u.Interrupt.Vector = HalGetInterruptVector(fullResourceList->InterfaceType, fullResourceList->BusNumber, partialDescriptors[j].u.Interrupt.Level, partialDescriptors[j].u.Interrupt.Vector, (PKIRQL) &partialDescriptors[j].u.Interrupt.Level, &partialDescriptors[j].u.Interrupt.Affinity); } } fullResourceList = (PCM_FULL_RESOURCE_DESCRIPTOR) (partialDescriptors + j); }
//
// start the FDO
//
status = ChannelStartChannel (fdoExtension, cmResourceList); // callee is keeping this if no error
}
if (!NT_SUCCESS (status)) {
//
// go through the remove sequence
//
if (fdoExtension) {
ChannelRemoveChannel (fdoExtension);
IoDetachDevice (fdoExtension->AttacheeDeviceObject);
IoDeleteDevice (fdoExtension->DeviceObject); }
DebugPrint ((0, "IdePort: Unable to start detected device\n")); ASSERT (FALSE);
} else {
IoInvalidateDeviceRelations ( fdoExtension->AttacheePdo, BusRelations ); } } } }
GetOut: if (cmResourceList) { ExFreePool (cmResourceList); }
if (detectionPort) { ExFreePool (detectionPort); }
return status;
} //IdePortDetectLegacyController
NTSTATUSIdePortCreateDetectionList ( IN PDRIVER_OBJECT DriverObject, OUT PDETECTION_PORT *DetectionPort, OUT PULONG NumPort)/*++
Routine Description:
create a list of popular legacy ports
Arguments:
DriverObject - this driver's driver object
DetectionPort - pointer to port list
NumPort - number of ports in the list
Return Value:
NT Status
--*/{ NTSTATUS status; CCHAR deviceBuffer[50]; ANSI_STRING ansiString; UNICODE_STRING subKeyPath; HANDLE subServiceKey;
PDETECTION_PORT detectionPort; ULONG numDevices; ULONG i; ULONG j;
CUSTOM_DEVICE_PARAMETER customDeviceParameter;
PCONFIGURATION_INFORMATION configurationInformation = IoGetConfigurationInformation();
numDevices = 0; status = STATUS_SUCCESS;
#ifdef DRIVER_PARAMETER_REGISTRY_SUPPORT
//
// look for non-standard legacy port setting in the registry
// 9
do { sprintf (deviceBuffer, "Parameters\\Device%d", numDevices); RtlInitAnsiString(&ansiString, deviceBuffer); status = RtlAnsiStringToUnicodeString(&subKeyPath, &ansiString, TRUE);
if (NT_SUCCESS(status)) {
subServiceKey = IdePortOpenServiceSubKey ( DriverObject, &subKeyPath );
RtlFreeUnicodeString (&subKeyPath);
if (subServiceKey) {
numDevices++; IdePortCloseServiceSubKey ( subServiceKey );
} else {
status = STATUS_UNSUCCESSFUL; } } } while (NT_SUCCESS(status));
#endif // DRIVER_PARAMETER_REGISTRY_SUPPORT
//
// always have at least 4 to return
//
detectionPort = ExAllocatePool ( PagedPool, (numDevices + 4) * sizeof (DETECTION_PORT) );
if (detectionPort) {
for (i = j = 0; i < numDevices; i++) {
#ifdef DRIVER_PARAMETER_REGISTRY_SUPPORT
//
// look for non-standard legacy port setting in the registry
//
sprintf (deviceBuffer, "Parameters\\Device%d", i); RtlInitAnsiString(&ansiString, deviceBuffer); status = RtlAnsiStringToUnicodeString(&subKeyPath, &ansiString, TRUE);
if (NT_SUCCESS(status)) {
subServiceKey = IdePortOpenServiceSubKey ( DriverObject, &subKeyPath );
RtlFreeUnicodeString (&subKeyPath);
if (subServiceKey) {
RtlZeroMemory ( &customDeviceParameter, sizeof (CUSTOM_DEVICE_PARAMETER) );
IdeParseDeviceParameters ( subServiceKey, &customDeviceParameter );
if (customDeviceParameter.CommandRegisterBase) {
detectionPort[j].CommandRegisterBase = customDeviceParameter.CommandRegisterBase;
detectionPort[j].ControlRegisterBase = customDeviceParameter.CommandRegisterBase + 0x206;
detectionPort[j].IrqLevel = customDeviceParameter.IrqLevel;
j++; }
IdePortCloseServiceSubKey ( subServiceKey ); } }#endif // DRIVER_PARAMETER_REGISTRY_SUPPORT
}
//
// populate the list with popular i/o ports
//
if ( !IsNEC_98 ) { if (configurationInformation->AtDiskPrimaryAddressClaimed == FALSE) {
detectionPort[j].CommandRegisterBase = 0x1f0; detectionPort[j].ControlRegisterBase = 0x1f0 + 0x206; detectionPort[j].IrqLevel = 14; j++; }
if (configurationInformation->AtDiskSecondaryAddressClaimed == FALSE) {
detectionPort[j].CommandRegisterBase = 0x170; detectionPort[j].ControlRegisterBase = 0x170 + 0x206; detectionPort[j].IrqLevel = 15; j++; }
detectionPort[j].CommandRegisterBase = 0x1e8; detectionPort[j].ControlRegisterBase = 0x1e8 + 0x206; detectionPort[j].IrqLevel = 11;// DEC Hi-Note hack
// detectionPort[j].ControlRegisterBase = 0x1e8 + 0x1f - 0x2;
// detectionPort[j].IrqLevel = 7;
// DEC Hi-Note hack
j++;
detectionPort[j].CommandRegisterBase = 0x168; detectionPort[j].ControlRegisterBase = 0x168 + 0x206; detectionPort[j].IrqLevel = 10; j++;
} else { // IsNEC_98
if ((configurationInformation->AtDiskPrimaryAddressClaimed == FALSE) && (configurationInformation->AtDiskSecondaryAddressClaimed == FALSE)) {
detectionPort[j].CommandRegisterBase = 0x640; detectionPort[j].ControlRegisterBase = 0x640 + 0x10c; //0x74c
detectionPort[j].IrqLevel = 9; j++; }
}
*NumPort = j; *DetectionPort = detectionPort; return STATUS_SUCCESS; } else {
*NumPort = 0; *DetectionPort = NULL; return STATUS_INSUFFICIENT_RESOURCES; }} // IdePortCreateDetectionList
NTSTATUSIdePortTranslateAddress ( IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber, IN PHYSICAL_ADDRESS StartAddress, IN LONG Length, IN OUT PULONG AddressSpace, OUT PVOID *TranslatedAddress, OUT PPHYSICAL_ADDRESS TranslatedMemoryAddress )/*++
Routine Description:
translate i/o address
Arguments:
InterfaceType - bus interface
BusNumber - bus number
StartAddress - address to translate
Length - number of byte to translate
AddressSpace - address space for the given address
Return Value:
AddressSpace - address space for the translated address
TranslatedAddress - translated address
TranslatedMemoryAddress - tranlated memory address if translated to memory space
NT Status
--*/{ PHYSICAL_ADDRESS translatedAddress;
ASSERT (Length); ASSERT (AddressSpace); ASSERT (TranslatedAddress);
*TranslatedAddress = NULL; TranslatedMemoryAddress->QuadPart = (ULONGLONG) NULL;
if (HalTranslateBusAddress(InterfaceType, BusNumber, StartAddress, AddressSpace, &translatedAddress)) {
if (*AddressSpace == IO_SPACE) {
*TranslatedAddress = (PVOID) translatedAddress.u.LowPart;
} else if (*AddressSpace == MEMORY_SPACE) {
//
// translated address is in memory space,
// need to map it to I/O space.
//
*TranslatedMemoryAddress = translatedAddress;
*TranslatedAddress = MmMapIoSpace( translatedAddress, Length, FALSE); } }
if (*TranslatedAddress) {
return STATUS_SUCCESS;
} else {
return STATUS_INVALID_PARAMETER; }} // IdePortTranslateAddress
VOIDIdePortFreeTranslatedAddress ( IN PVOID TranslatedAddress, IN LONG Length, IN ULONG AddressSpace )/*++
Routine Description:
free resources created for a translated address
Arguments:
TranslatedAddress - translated address
Length - number of byte to translated
AddressSpace - address space for the translated address
Return Value:
None
--*/{ if (TranslatedAddress) {
if (AddressSpace == MEMORY_SPACE) {
MmUnmapIoSpace ( TranslatedAddress, Length ); } } return;} // IdePortFreeTranslatedAddress
BOOLEANIdePortDetectAlias ( PIDE_REGISTERS_1 CmdRegBase ){ PIDE_REGISTERS_1 cmdRegBaseAlias; PUCHAR cylinderHighAlias; PUCHAR cylinderLowAlias;
//
// alias port
//
cylinderHighAlias = (PUCHAR) ((ULONG_PTR) CmdRegBase->CylinderHigh | (1 << 15)); cylinderLowAlias = (PUCHAR) ((ULONG_PTR) CmdRegBase->CylinderLow | (1 << 15));
IdePortOutPortByte (CmdRegBase->CylinderHigh, SAMPLE_CYLINDER_HIGH_VALUE); IdePortOutPortByte (CmdRegBase->CylinderLow, SAMPLE_CYLINDER_LOW_VALUE);
//
// Check if indentifier can be read back via the alias port
//
if ((IdePortInPortByte (cylinderHighAlias) != SAMPLE_CYLINDER_HIGH_VALUE) || (IdePortInPortByte (cylinderLowAlias) != SAMPLE_CYLINDER_LOW_VALUE)) {
return FALSE;
} else {
return TRUE; }}
#endif // NO_LEGACY_DRIVERS
|
