|
|
/*++
Copyright (c) 1997 Microsoft Corporation
Module Name:
translate.c
Abstract:
This file implements translator interfaces for busses enumerated by ACPI.
The actual translation information about this bus is gotten from the _CRS associated with the bus. We put the data into an IO_RESOURCE_REQUIREMENTS_LIST as device private data of the following form:
DevicePrivate.Data[0]: child's CM_RESOURCE_TYPE DevicePrivate.Data[1]: child's start address [31:0] DevicePrivate.Data[2]: child's start address [63:32]
The descriptor that describes child-side translation immediately follows the one that describes the parent-side resources.
The Flags field of the IO_RESOURCE_REQUIREMENTS_LIST may have the TRANSLATION_RANGE_SPARSE bit set.
Author:
Jake Oshins 7-Nov-97
Environment:
NT Kernel Model Driver only
--*/
#include "pch.h"
NTSTATUSFindTranslationRange( IN PHYSICAL_ADDRESS Start, IN LONGLONG Length, IN PBRIDGE_TRANSLATOR Translator, IN RESOURCE_TRANSLATION_DIRECTION Direction, IN UCHAR ResType, OUT PBRIDGE_WINDOW *Window );
NTSTATUSTranslateBridgeResources( IN PVOID Context, IN PCM_PARTIAL_RESOURCE_DESCRIPTOR Source, IN RESOURCE_TRANSLATION_DIRECTION Direction, IN ULONG AlternativesCount, OPTIONAL IN IO_RESOURCE_DESCRIPTOR Alternatives[], OPTIONAL IN PDEVICE_OBJECT PhysicalDeviceObject, OUT PCM_PARTIAL_RESOURCE_DESCRIPTOR Target );
NTSTATUSTranslateBridgeRequirements( IN PVOID Context, IN PIO_RESOURCE_DESCRIPTOR Source, IN PDEVICE_OBJECT PhysicalDeviceObject, OUT PULONG TargetCount, OUT PIO_RESOURCE_DESCRIPTOR *Target );
NTSTATUSBuildTranslatorRanges( IN PBRIDGE_TRANSLATOR Translator, OUT ULONG *BridgeWindowCount, OUT PBRIDGE_WINDOW *Window );
#define MAX(a, b) \
((a) > (b) ? (a) : (b))
#define MIN(a, b) \
((a) < (b) ? (a) : (b))
HAL_PORT_RANGE_INTERFACE HalPortRangeInterface;
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, TranslateEjectInterface)
#pragma alloc_text(PAGE, TranslateBridgeResources)
#pragma alloc_text(PAGE, TranslateBridgeRequirements)
#pragma alloc_text(PAGE, FindTranslationRange)
#pragma alloc_text(PAGE, AcpiNullReference)
#pragma alloc_text(PAGE, BuildTranslatorRanges)
#endif
NTSTATUSTranslateEjectInterface( PDEVICE_OBJECT DeviceObject, PIRP Irp ){ PIO_RESOURCE_REQUIREMENTS_LIST ioList = NULL; PIO_RESOURCE_DESCRIPTOR transDesc; PIO_RESOURCE_DESCRIPTOR parentDesc; PTRANSLATOR_INTERFACE transInterface; PBRIDGE_TRANSLATOR bridgeTrans = NULL; PIO_STACK_LOCATION irpSp; PDEVICE_EXTENSION devExtension; BOOLEAN foundTranslations = FALSE; NTSTATUS status; PUCHAR crsBuf = NULL; ULONG descCount; ULONG parentResType; ULONG childResType; ULONG crsBufSize; PHYSICAL_ADDRESS parentStart; PHYSICAL_ADDRESS childStart;
PAGED_CODE();
devExtension = ACPIInternalGetDeviceExtension(DeviceObject);
ASSERT(devExtension); ASSERT(devExtension->AcpiObject);
irpSp = IoGetCurrentIrpStackLocation(Irp); ASSERT(irpSp->Parameters.QueryInterface.Size >= sizeof(TRANSLATOR_INTERFACE));
transInterface = (PTRANSLATOR_INTERFACE)irpSp->Parameters.QueryInterface.Interface; ASSERT(transInterface);
//
// Get the resources for this bus.
//
status = ACPIGetBufferSync( devExtension, PACKED_CRS, &crsBuf, &crsBufSize ); if (!NT_SUCCESS(status)) {
//
// This bus has no _CRS. So it doesn't need a translator.
//
status = Irp->IoStatus.Status; goto TranslateEjectInterfaceExit;
}
//
// Turn it into something meaningful.
//
status = PnpBiosResourcesToNtResources( crsBuf, PNP_BIOS_TO_IO_NO_CONSUMED_RESOURCES, &ioList ); if (!NT_SUCCESS(status)) { goto TranslateEjectInterfaceExit; }
//
// This was a leagal _CRS but it contained no resources that are useful to the OS.
//
if (!ioList) { status = Irp->IoStatus.Status; goto TranslateEjectInterfaceExit; }
//
// Cycle through the descriptors looking for device private data
// that contains translation information.
//
for (descCount = 0; descCount < ioList->List[0].Count; descCount++) {
transDesc = &ioList->List[0].Descriptors[descCount];
if (transDesc->Type == CmResourceTypeDevicePrivate) {
//
// Translation information is contained in
// a device private resource that has
// TRANSLATION_DATA_PARENT_ADDRESS in the
// flags field.
//
if (transDesc->Flags & TRANSLATION_DATA_PARENT_ADDRESS) {
// The first descriptor cannot be a translation descriptor
ASSERT(descCount != 0);
//
// The translation descriptor should follow the descriptor
// that it is trying to modify. The first, normal,
// descriptor is for the child-relative resources. The
// second, device private, descriptor is modifies the
// child-relative resources to generate the parent-relative
// resources.
//
parentResType = transDesc->u.DevicePrivate.Data[0]; parentStart.LowPart = transDesc->u.DevicePrivate.Data[1]; parentStart.HighPart = transDesc->u.DevicePrivate.Data[2];
childResType = ioList->List[0].Descriptors[descCount - 1].Type; childStart.QuadPart = (transDesc - 1)->u.Generic.MinimumAddress.QuadPart; if ((parentResType != childResType) || (parentStart.QuadPart != childStart.QuadPart)) {
foundTranslations = TRUE; break; } } } }
if (!foundTranslations) {
//
// Didn't find any translation information for this bus.
//
status = Irp->IoStatus.Status; goto TranslateEjectInterfaceExit; }
//
// Build a translator interface.
//
bridgeTrans = ExAllocatePoolWithTag( PagedPool, sizeof (BRIDGE_TRANSLATOR), ACPI_TRANSLATE_POOLTAG ); if (!bridgeTrans) {
status = STATUS_INSUFFICIENT_RESOURCES; goto TranslateEjectInterfaceExit;
}
bridgeTrans->AcpiObject = devExtension->AcpiObject; bridgeTrans->IoList = ioList;
//
// Build the array of bridge windows.
//
status = BuildTranslatorRanges( bridgeTrans, &bridgeTrans->RangeCount, &bridgeTrans->Ranges ); if (!NT_SUCCESS(status)) {
goto TranslateEjectInterfaceExit;
} transInterface->Size = sizeof(TRANSLATOR_INTERFACE); transInterface->Version = 1; transInterface->Context = (PVOID)bridgeTrans; transInterface->InterfaceReference = AcpiNullReference; transInterface->InterfaceDereference = AcpiNullReference; transInterface->TranslateResources = TranslateBridgeResources; transInterface->TranslateResourceRequirements = TranslateBridgeRequirements;
status = STATUS_SUCCESS;
TranslateEjectInterfaceExit: if (!NT_SUCCESS(status) && bridgeTrans){
ExFreePool(bridgeTrans); }
if(crsBuf){
ExFreePool(crsBuf); }
if(ioList){
ExFreePool(ioList); } return status;}
NTSTATUSFindTranslationRange( IN PHYSICAL_ADDRESS Start, IN LONGLONG Length, IN PBRIDGE_TRANSLATOR Translator, IN RESOURCE_TRANSLATION_DIRECTION Direction, IN UCHAR ResType, OUT PBRIDGE_WINDOW *Window ){ LONGLONG beginning, end; ULONG i; UCHAR rangeType;
PAGED_CODE();
for (i = 0; i < Translator->RangeCount; i++) {
if (Direction == TranslateParentToChild) {
beginning = Translator->Ranges[i].ParentAddress.QuadPart; rangeType = Translator->Ranges[i].ParentType;
} else {
beginning = Translator->Ranges[i].ChildAddress.QuadPart; rangeType = Translator->Ranges[i].ChildType; }
end = beginning + Translator->Ranges[i].Length;
if ((rangeType == ResType) && (!((Start.QuadPart < beginning) || (Start.QuadPart + Length > end)))) {
//
// The range lies within this bridge window
// and the resource types match.
//
*Window = &Translator->Ranges[i];
return STATUS_SUCCESS; } }
return STATUS_NOT_FOUND;} NTSTATUSTranslateBridgeResources( IN PVOID Context, IN PCM_PARTIAL_RESOURCE_DESCRIPTOR Source, IN RESOURCE_TRANSLATION_DIRECTION Direction, IN ULONG AlternativesCount, OPTIONAL IN IO_RESOURCE_DESCRIPTOR Alternatives[], OPTIONAL IN PDEVICE_OBJECT PhysicalDeviceObject, OUT PCM_PARTIAL_RESOURCE_DESCRIPTOR Target )/*++
Routine Description:
This function takes a set of resources that are passed through a bridge and does any translation that is necessary when changing from a parent- relative viewpoint to a child-relative one or back again.
In this function, we have the notion of a "window," which is an aperature within the bridge. Bridges often have multiple windows, each with distinct translations.
This function should never fail, as any resource range that will fail translation should have already been stripped out by TranslateBridgeRequirements.
Arguments:
Context - pointer to the translation data
Source - resource list to be translated
Direction - TranslateChildToParent or TranslateParentToChild
AlternativesCount - not used
Alternatives - not used
PhysicalDeviceObject - not used
Target - translated resource list
Return Value:
Status
--*/{ PBRIDGE_TRANSLATOR translator; PBRIDGE_WINDOW window; NTSTATUS status;
PAGED_CODE(); ASSERT(Context); ASSERT((Source->Type == CmResourceTypePort) || (Source->Type == CmResourceTypeMemory));
translator = (PBRIDGE_TRANSLATOR)Context;
ASSERT(translator->RangeCount > 0);
//
// Find the window that this translation occurs
// within.
//
status = FindTranslationRange(Source->u.Generic.Start, Source->u.Generic.Length, translator, Direction, Source->Type, &window);
if (!NT_SUCCESS(status)) {
//
// We should never get here. This fucntion
// should only be called for ranges that
// are valid. TranslateBridgeRequirements should
// weed out all the invalid ranges.
return status; }
//
// Copy everything
//
*Target = *Source;
switch (Direction) { case TranslateChildToParent:
//
// Target inherits the parent's resource type.
//
Target->Type = window->ParentType;
//
// Calculate the target's parent-relative start
// address.
//
Target->u.Generic.Start.QuadPart = Source->u.Generic.Start.QuadPart + window->ParentAddress.QuadPart - window->ChildAddress.QuadPart;
//
// Make sure the length is still in bounds.
//
ASSERT(Target->u.Generic.Length <= (ULONG)(window->Length - (Target->u.Generic.Start.QuadPart - window->ParentAddress.QuadPart)));
status = STATUS_TRANSLATION_COMPLETE;
break;
case TranslateParentToChild:
//
// Target inherits the child's resource type.
//
Target->Type = window->ChildType;
//
// Calculate the target's child-relative start
// address.
//
Target->u.Generic.Start.QuadPart = Source->u.Generic.Start.QuadPart + window->ChildAddress.QuadPart - window->ParentAddress.QuadPart;
//
// Make sure the length is still in bounds.
//
ASSERT(Target->u.Generic.Length <= (ULONG)(window->Length - (Target->u.Generic.Start.QuadPart - window->ChildAddress.QuadPart)));
status = STATUS_SUCCESS; break;
default: status = STATUS_INVALID_PARAMETER; }
#if 0
if (Target->Type == CmResourceTypePort) { DbgPrint("XXX: %s[%d]=0x%I64x -> %s[%d]=0x%I64x\n", (Direction == TranslateChildToParent) ? "child" : "parent", Source->Type, Source->u.Generic.Start.QuadPart, (Direction == TranslateChildToParent) ? "parent" : "child", Target->Type, Target->u.Generic.Start.QuadPart); }#endif
return status;} NTSTATUSTranslateBridgeRequirements( IN PVOID Context, IN PIO_RESOURCE_DESCRIPTOR Source, IN PDEVICE_OBJECT PhysicalDeviceObject, OUT PULONG TargetCount, OUT PIO_RESOURCE_DESCRIPTOR *Target )/*++
Routine Description:
This function takes a resource requirements list for resources on the child side of the bridge and translates them into resource requirements on the parent side of the bridge. This may involve clipping and there may be multiple target ranges.
Arguments:
Context - pointer to the translation data
Source - resource list to be translated
PhysicalDeviceObject - not used
TargetCount - number of resources in the target list
Target - translated resource requirements list
Return Value:
Status
--*/{ PBRIDGE_TRANSLATOR translator; PBRIDGE_WINDOW window; NTSTATUS status; LONGLONG rangeStart, rangeEnd, windowStart, windowEnd; ULONG i;
PAGED_CODE(); ASSERT(Context); ASSERT((Source->Type == CmResourceTypePort) || (Source->Type == CmResourceTypeMemory));
translator = (PBRIDGE_TRANSLATOR)Context;
//
// Allocate memory for the target range.
//
*Target = ExAllocatePoolWithTag(PagedPool, sizeof(IO_RESOURCE_DESCRIPTOR), ACPI_RESOURCE_POOLTAG);
if (!*Target) { status = STATUS_INSUFFICIENT_RESOURCES; goto cleanup; }
//
// Look at all the aperatures in the bridge to see which
// ones of them could possibly provide translations for
// this resource.
//
rangeStart = Source->u.Generic.MinimumAddress.QuadPart; rangeEnd = Source->u.Generic.MaximumAddress.QuadPart;
for (i = 0; i < translator->RangeCount; i++) {
window = &translator->Ranges[i];
if (window->ChildType != Source->Type) {
//
// This window describes the wrong
// type of resource.
//
continue; }
if (Source->u.Generic.Length > window->Length) {
//
// This resource won't fit in this aperature.
//
continue; }
windowStart = window->ChildAddress.QuadPart; windowEnd = window->ChildAddress.QuadPart + (LONGLONG)window->Length;
if (!(((rangeStart < windowStart) && (rangeEnd < windowStart)) || ((rangeStart > windowEnd) && (rangeEnd > windowEnd)))) {
//
// The range and the window do intersect. So create
// a resource that clips the range to the window.
//
**Target = *Source; *TargetCount = 1;
(*Target)->Type = window->ParentType;
(*Target)->u.Generic.MinimumAddress.QuadPart = rangeStart + (window->ParentAddress.QuadPart - windowStart);
(*Target)->u.Generic.MaximumAddress.QuadPart = rangeEnd + (window->ParentAddress.QuadPart - windowStart);
break; } }
if (i < translator->RangeCount) {
return STATUS_TRANSLATION_COMPLETE;
} else {
*TargetCount = 0; status = STATUS_PNP_TRANSLATION_FAILED; }
cleanup:
if (*Target) { ExFreePool(*Target); }
return status;} NTSTATUSBuildTranslatorRanges( IN PBRIDGE_TRANSLATOR Translator, OUT ULONG *BridgeWindowCount, OUT PBRIDGE_WINDOW *Window ){ PIO_RESOURCE_REQUIREMENTS_LIST ioList; PIO_RESOURCE_DESCRIPTOR transDesc, resDesc; ULONG descCount, windowCount, maxWindows;
PAGED_CODE();
ioList = Translator->IoList;
//
// Make an array of windows for holding the translation information.
//
maxWindows = ioList->List[0].Count / 2;
*Window = ExAllocatePoolWithTag(PagedPool, maxWindows * sizeof(BRIDGE_WINDOW), ACPI_TRANSLATE_POOLTAG);
if (!*Window) { return STATUS_INSUFFICIENT_RESOURCES; }
//
// Fill in the array with translations.
//
windowCount = 0;
for (descCount = 0; descCount < ioList->List[0].Count; descCount++) {
transDesc = &ioList->List[0].Descriptors[descCount];
if (transDesc->Type == CmResourceTypeDevicePrivate) {
//
// Translation information is contained in
// a device private resource that has
// TRANSLATION_DATA_PARENT_ADDRESS in the
// flags field.
//
if (transDesc->Flags & TRANSLATION_DATA_PARENT_ADDRESS) {
ASSERT(windowCount <= maxWindows);
//
// The translation descriptor is supposed to follow
// the resource that it is providing information about.
//
resDesc = &ioList->List[0].Descriptors[descCount - 1];
(*Window)[windowCount].ParentType = (UCHAR)transDesc->u.DevicePrivate.Data[0];
(*Window)[windowCount].ChildType = resDesc->Type;
(*Window)[windowCount].ParentAddress.LowPart = transDesc->u.DevicePrivate.Data[1];
(*Window)[windowCount].ParentAddress.HighPart = transDesc->u.DevicePrivate.Data[2];
(*Window)[windowCount].ChildAddress.QuadPart = resDesc->u.Generic.MinimumAddress.QuadPart;
(*Window)[windowCount].Length = resDesc->u.Generic.Length;
//
// If the HAL has provided underlying sparse port translation
// services, allow for that.
//
if ((HalPortRangeInterface.QueryAllocateRange != NULL) && (resDesc->Type == CmResourceTypePort)) { USHORT rangeId; UCHAR parentType = (UCHAR)transDesc->u.DevicePrivate.Data[0]; BOOLEAN isSparse = transDesc->Flags & TRANSLATION_RANGE_SPARSE; ULONG parentLength = resDesc->u.Generic.Length; PHYSICAL_ADDRESS parentAddress; NTSTATUS status;
PHYSICAL_ADDRESS rangeZeroBase;
parentAddress.LowPart = transDesc->u.DevicePrivate.Data[1]; parentAddress.HighPart = transDesc->u.DevicePrivate.Data[2];
rangeZeroBase.QuadPart = parentAddress.QuadPart - resDesc->u.Generic.MinimumAddress.QuadPart;
if (isSparse) { parentLength = (parentLength + resDesc->u.Generic.MinimumAddress.LowPart) << 10; }
status = HalPortRangeInterface.QueryAllocateRange( isSparse, parentType == CmResourceTypeMemory, NULL, rangeZeroBase, parentLength, &rangeId );
if (NT_SUCCESS(status)) { (*Window)[windowCount].ParentType = CmResourceTypePort; (*Window)[windowCount].ParentAddress.QuadPart = ((ULONGLONG)rangeId << 16) | ((*Window)[windowCount].ChildAddress.QuadPart & 0xffff); } }
windowCount++; } } }
*BridgeWindowCount = windowCount;
return STATUS_SUCCESS;}
|
