pnpmemio.c File Reference

#include "iop.h"

Go to the source code of this file.

Classes
struct	_PORT_ARBITER_EXTENSION
Defines
#define	BUGFEST_HACKS
#define	MAX_ULONGLONG   ((ULONGLONG) -1)
#define	MAX_ALIAS_PORT   0x0000FFFF
#define	ADDRESS_SPACE_MEMORY   0x0
#define	ADDRESS_SPACE_PORT   0x1
#define	ADDRESS_SPACE_USER_MEMORY   0x2
#define	ADDRESS_SPACE_USER_PORT   0x3
#define	ADDRESS_SPACE_DENSE_MEMORY   0x4
#define	ADDRESS_SPACE_USER_DENSE_MEMORY   0x6
#define	MAX_SCORE   MAXLONG
Typedefs
typedef _PORT_ARBITER_EXTENSION	PORT_ARBITER_EXTENSION
typedef _PORT_ARBITER_EXTENSION *	PPORT_ARBITER_EXTENSION
Functions
VOID	IopPortBacktrackAllocation (IN PARBITER_INSTANCE Arbiter, IN PARBITER_ALLOCATION_STATE State)
BOOLEAN	IopPortGetNextAlias (ULONG IoDescriptorFlags, ULONGLONG LastAlias, PULONGLONG NextAlias)
BOOLEAN	IopPortFindSuitableRange (PARBITER_INSTANCE Arbiter, PARBITER_ALLOCATION_STATE State)
BOOLEAN	IopMemFindSuitableRange (PARBITER_INSTANCE Arbiter, PARBITER_ALLOCATION_STATE State)
NTSTATUS	IopGenericUnpackRequirement (IN PIO_RESOURCE_DESCRIPTOR Descriptor, OUT PULONGLONG Minimum, OUT PULONGLONG Maximum, OUT PULONG Length, OUT PULONG Alignment)
NTSTATUS	IopGenericPackResource (IN PIO_RESOURCE_DESCRIPTOR Requirement, IN ULONGLONG Start, OUT PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor)
LONG	IopGenericScoreRequirement (IN PIO_RESOURCE_DESCRIPTOR Descriptor)
NTSTATUS	IopGenericUnpackResource (IN PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor, OUT PULONGLONG Start, OUT PULONG Length)
BOOLEAN	IopPortIsAliasedRangeAvailable (IN PARBITER_INSTANCE Arbiter, IN PARBITER_ALLOCATION_STATE State)
NTSTATUS	IopMemInitialize (VOID)
VOID	IopPortAddAllocation (IN PARBITER_INSTANCE Arbiter, IN PARBITER_ALLOCATION_STATE State)
NTSTATUS	IopTranslateBusAddress (IN PHYSICAL_ADDRESS SourceAddress, IN UCHAR SourceResourceType, OUT PPHYSICAL_ADDRESS TargetAddress, OUT PUCHAR TargetResourceType)
NTSTATUS	IopGenericTranslateOrdering (OUT PIO_RESOURCE_DESCRIPTOR Target, IN PIO_RESOURCE_DESCRIPTOR Source)
NTSTATUS	IopPortInitialize (VOID)
BOOLEAN	IopPortIsAliasedRangeAvailable (PARBITER_INSTANCE Arbiter, PARBITER_ALLOCATION_STATE State)

---

Define Documentation

#define ADDRESS_SPACE_DENSE_MEMORY   0x4

Definition at line 151 of file pnpmemio.c. Referenced by IopTranslateBusAddress().

#define ADDRESS_SPACE_MEMORY   0x0

Definition at line 147 of file pnpmemio.c. Referenced by IopTranslateBusAddress().

#define ADDRESS_SPACE_PORT   0x1

Definition at line 148 of file pnpmemio.c. Referenced by IopTranslateBusAddress().

#define ADDRESS_SPACE_USER_DENSE_MEMORY   0x6

Definition at line 152 of file pnpmemio.c. Referenced by IopTranslateBusAddress().

#define ADDRESS_SPACE_USER_MEMORY   0x2

Definition at line 149 of file pnpmemio.c. Referenced by IopTranslateBusAddress().

#define ADDRESS_SPACE_USER_PORT   0x3

Definition at line 150 of file pnpmemio.c. Referenced by IopTranslateBusAddress().

#define BUGFEST_HACKS

Definition at line 24 of file pnpmemio.c.

#define MAX_ALIAS_PORT   0x0000FFFF

Definition at line 31 of file pnpmemio.c. Referenced by IopPortGetNextAlias().

#define MAX_SCORE   MAXLONG

Referenced by IopGenericScoreRequirement().

#define MAX_ULONGLONG   ((ULONGLONG) -1)

Definition at line 30 of file pnpmemio.c.

---

Typedef Documentation

typedef struct _PORT_ARBITER_EXTENSION PORT_ARBITER_EXTENSION

typedef struct _PORT_ARBITER_EXTENSION * PPORT_ARBITER_EXTENSION

---

Function Documentation

NTSTATUS IopGenericPackResource (  IN PIO_RESOURCE_DESCRIPTOR  Requirement, IN ULONGLONG  Start, OUT PCM_PARTIAL_RESOURCE_DESCRIPTOR  Descriptor )

Definition at line 630 of file pnpmemio.c. References ARB_PRINT, ASSERT, PAGED_CODE, and Start. Referenced by IopMemInitialize(), and IopPortInitialize(). : This routine packs an resource descriptor. Arguments: Requirement - The requirement from which this resource was chosen. Start - The start value of the resource. Descriptor - Pointer to the descriptor to pack into. Return Value: Returns the status of this operation. --*/ { PAGED_CODE(); ASSERT(Descriptor); ASSERT(Requirement); ASSERT(Requirement->Type == CmResourceTypePort || Requirement->Type == CmResourceTypeMemory); Descriptor->Type = Requirement->Type; Descriptor->Flags = Requirement->Flags; Descriptor->ShareDisposition = Requirement->ShareDisposition; Descriptor->u.Generic.Start.QuadPart = Start; Descriptor->u.Generic.Length = Requirement->u.Generic.Length; ARB_PRINT(2, ("Packing %s resource %p => 0x%I64x length 0x%x\n", Descriptor->Type == CmResourceTypePort ? "port" : "memory", Descriptor, Descriptor->u.Port.Start.QuadPart, Descriptor->u.Port.Length )); return STATUS_SUCCESS; }

LONG IopGenericScoreRequirement (  IN PIO_RESOURCE_DESCRIPTOR  Descriptor  )

Definition at line 542 of file pnpmemio.c. References ALIGN_ADDRESS_UP, ARB_PRINT, ASSERT, MAX_SCORE, and PAGED_CODE. Referenced by IopMemInitialize(), and IopPortInitialize(). : This routine scores a requirement based on how flexible it is. The least flexible devices are scored the least and so when the arbitration list is sorted we try to allocate their resources first. Arguments: Descriptor - The descriptor describing the requirement to score. Return Value: The score. --*/ { LONG score; ULONGLONG start, end; LONGLONG bigscore; ULONG alignment; PAGED_CODE(); #define MAX_SCORE MAXLONG ASSERT(Descriptor); ASSERT((Descriptor->Type == CmResourceTypePort) || (Descriptor->Type == CmResourceTypeMemory)); alignment = Descriptor->u.Generic.Alignment; // // Fix the broken hardware that reports 0 alignment // Since this is not a PCI device, set the alignment to 1. // // if (alignment == 0 && ((Descriptor->Type == CmResourceTypePort) || (Descriptor->Type == CmResourceTypeMemory))) { alignment = 1; } start = ALIGN_ADDRESS_UP( Descriptor->u.Generic.MinimumAddress.QuadPart, alignment ); end = Descriptor->u.Generic.MaximumAddress.QuadPart; // // The score is the number of possible allocations that could be made // given the alignment and length constraints // bigscore = (((end - Descriptor->u.Generic.Length + 1) - start) / alignment) + 1; score = (LONG)bigscore; if (bigscore < 0) { score = -1; } else if (bigscore > MAX_SCORE) { score = MAX_SCORE; } ARB_PRINT(2, ("Scoring port resource %p(0x%I64x-0x%I64x) => %i\n", Descriptor->Type == CmResourceTypePort ? "port" : "memory", Descriptor, Descriptor->u.Generic.MinimumAddress.QuadPart, end, score )); return score; }

NTSTATUS IopGenericTranslateOrdering (  OUT PIO_RESOURCE_DESCRIPTOR  Target, IN PIO_RESOURCE_DESCRIPTOR  Source )

Definition at line 263 of file pnpmemio.c. References ASSERT, IopTranslateBusAddress(), NT_SUCCESS, NTSTATUS(), and PAGED_CODE. Referenced by IopMemInitialize(), and IopPortInitialize(). : This routine is called during arbiter initialization to translate the orderings. Parameters: Target - Place to put the translated descriptor Source - Descriptor to translate Return Value: STATUS_SUCCESS */ { NTSTATUS status; UCHAR initialResourceType, minResourceType, maxResourceType; PAGED_CODE(); *Target = *Source; if (Source->Type != CmResourceTypeMemory && Source->Type != CmResourceTypePort) { return STATUS_SUCCESS; } initialResourceType = Source->Type; // // Translate the minimum // status = IopTranslateBusAddress(Source->u.Generic.MinimumAddress, initialResourceType, &Target->u.Generic.MinimumAddress, &minResourceType ); if (NT_SUCCESS(status)) { // // Translate the maximum iff we could translate the minimum // status = IopTranslateBusAddress(Source->u.Generic.MaximumAddress, initialResourceType, &Target->u.Generic.MaximumAddress, &maxResourceType ); } // // If we couldn't translate both ends of the range then we want to skip this // range - set it's type to CmResourceTypeNull // if (!NT_SUCCESS(status)) { Target->Type = CmResourceTypeNull; } else { ASSERT(minResourceType == maxResourceType); Target->Type = minResourceType; } return STATUS_SUCCESS; }

NTSTATUS IopGenericUnpackRequirement (  IN PIO_RESOURCE_DESCRIPTOR  Descriptor, OUT PULONGLONG  Minimum, OUT PULONGLONG  Maximum, OUT PULONG  Length, OUT PULONG  Alignment )

Definition at line 463 of file pnpmemio.c. References ARB_PRINT, ASSERT, and PAGED_CODE. Referenced by IopMemInitialize(), and IopPortInitialize(). : This routine unpacks an resource requirement descriptor. Arguments: Descriptor - The descriptor describing the requirement to unpack. Minimum - Pointer to where the minimum acceptable start value should be unpacked to. Maximum - Pointer to where the maximum acceptable end value should be unpacked to. Length - Pointer to where the required length should be unpacked to. Minimum - Pointer to where the required alignment should be unpacked to. Return Value: Returns the status of this operation. --*/ { PAGED_CODE(); ASSERT(Descriptor); ASSERT(Descriptor->Type == CmResourceTypePort || Descriptor->Type == CmResourceTypeMemory); *Minimum = (ULONGLONG) Descriptor->u.Generic.MinimumAddress.QuadPart; *Maximum = (ULONGLONG) Descriptor->u.Generic.MaximumAddress.QuadPart; *Length = Descriptor->u.Generic.Length; *Alignment = Descriptor->u.Generic.Alignment; // // Fix the broken hardware that reports 0 alignment // if (*Alignment == 0) { *Alignment = 1; } // // Fix broken INF's that report they support 24bit memory > 0xFFFFFF // if (Descriptor->Type == CmResourceTypeMemory && Descriptor->Flags & CM_RESOURCE_MEMORY_24 && Descriptor->u.Memory.MaximumAddress.QuadPart > 0xFFFFFF) { *Maximum = 0xFFFFFF; } ARB_PRINT(2, ("Unpacking %s requirement %p => 0x%I64x-0x%I64x length 0x%x alignment 0x%x\n", Descriptor->Type == CmResourceTypePort ? "port" : "memory", Descriptor, *Minimum, *Maximum, *Length, *Alignment )); return STATUS_SUCCESS; }

NTSTATUS IopGenericUnpackResource (  IN PCM_PARTIAL_RESOURCE_DESCRIPTOR  Descriptor, OUT PULONGLONG  Start, OUT PULONG  Length )

Definition at line 682 of file pnpmemio.c. References ARB_PRINT, ASSERT, PAGED_CODE, and Start. Referenced by IopMemInitialize(), and IopPortInitialize(). 00690 : 00691 00692 This routine unpacks an resource descriptor. 00693 00694 Arguments: 00695 00696 Descriptor - The descriptor describing the resource to unpack. 00697 00698 Start - Pointer to where the start value should be unpacked to. 00699 00700 Length - Pointer to where the length value should be unpacked to. 00701 00702 Return Value: 00703 00704 Returns the status of this operation. 00705 00706 --*/ 00707 00708 { 00709 00710 PAGED_CODE(); 00711 ASSERT(Descriptor); 00712 ASSERT(Descriptor->Type == CmResourceTypePort 00713 || Descriptor->Type == CmResourceTypeMemory); 00714 00715 *Start = Descriptor->u.Generic.Start.QuadPart; 00716 *Length = Descriptor->u.Generic.Length; 00717 00718 ARB_PRINT(2, 00719 ("Unpacking %s resource %p => 0x%I64x Length 0x%x\n", 00720 Descriptor->Type == CmResourceTypePort ? "port" : "memory", 00721 Descriptor, 00722 *Start, 00723 *Length 00724 )); 00725 00726 return STATUS_SUCCESS; 00727 00728 } #if 0

BOOLEAN IopMemFindSuitableRange (  PARBITER_INSTANCE  Arbiter, PARBITER_ALLOCATION_STATE  State )

Definition at line 1342 of file pnpmemio.c. References ArbFindSuitableRange(), ARBITER_FLAG_BOOT_CONFIG, ARBITER_RANGE_BOOT_ALLOCATED, _ARBITER_ALLOCATION_STATE::Entry, _ARBITER_LIST_ENTRY::Flags, and _ARBITER_ALLOCATION_STATE::RangeAvailableAttributes. Referenced by IopMemInitialize(). : This routine is called from AllocateEntry once we have decided where we want to allocate from. It tries to find a free range that matches the requirements in State while restricting its possible solutions to the range State->Start to State->CurrentMaximum. On success State->Start and State->End represent this range. Conflicts between boot configs are allowed Arguments: Arbiter - The instance data of the arbiter who was called. State - The state of the current arbitration. Return Value: TRUE if we found a range, FALSE otherwise. --*/ { // // If this was a boot config then consider other boot configs to be // available // if (State->Entry->Flags & ARBITER_FLAG_BOOT_CONFIG) { State->RangeAvailableAttributes |= ARBITER_RANGE_BOOT_ALLOCATED; } // // Do the default thing // return ArbFindSuitableRange(Arbiter, State); }

NTSTATUS IopMemInitialize (  VOID   )

Referenced by IopInitializePlugPlayServices().

VOID IopPortAddAllocation (  IN PARBITER_INSTANCE  Arbiter, IN PARBITER_ALLOCATION_STATE  State )

Definition at line 1146 of file pnpmemio.c. References ARB_PRINT, ARBITER_ALTERNATIVE_FLAG_SHARED, ARBITER_RANGE_ALIAS, ASSERT, IopPortGetNextAlias(), NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, and RtlAddRange(). Referenced by IopPortInitialize(). : This routine is called from AllocateEntry once we have found a possible solution (State->Start - State->End). It adds the ranges that will not be available if we commit to this solution to Arbiter->PossibleAllocation. Arguments: Arbiter - The instance data of the arbiter who was called. State - The state of the current arbitration. Return Value: None. --*/ { NTSTATUS status; ULONGLONG alias; BOOLEAN isAlias; PAGED_CODE(); ASSERT(Arbiter); ASSERT(State); status = RtlAddRange(Arbiter->PossibleAllocation, State->Start, State->End, State->RangeAttributes, RTL_RANGE_LIST_ADD_IF_CONFLICT + (State->CurrentAlternative->Flags & ARBITER_ALTERNATIVE_FLAG_SHARED ? RTL_RANGE_LIST_ADD_SHARED : 0), NULL, State->Entry->PhysicalDeviceObject ); ASSERT(NT_SUCCESS(status)); // // Add any aliases // alias = State->Start; ARB_PRINT(2, ("Adding aliases\n")); while (IopPortGetNextAlias(State->CurrentAlternative->Descriptor->Flags, alias, &alias)) { status = RtlAddRange(Arbiter->PossibleAllocation, alias, alias + State->CurrentAlternative->Length - 1, (UCHAR) (State->RangeAttributes | ARBITER_RANGE_ALIAS), RTL_RANGE_LIST_ADD_IF_CONFLICT + (State->CurrentAlternative->Flags & ARBITER_ALTERNATIVE_FLAG_SHARED ? RTL_RANGE_LIST_ADD_SHARED : 0), NULL, State->Entry->PhysicalDeviceObject ); // // We have already checked if these ranges are available // so we should not fail... // ASSERT(NT_SUCCESS(status)); } }

VOID IopPortBacktrackAllocation (  IN PARBITER_INSTANCE  Arbiter, IN PARBITER_ALLOCATION_STATE  State )

Definition at line 890 of file pnpmemio.c. References ARB_PRINT, ArbBacktrackAllocation(), ASSERT, IopPortGetNextAlias(), NT_SUCCESS, NTSTATUS(), PAGED_CODE, and RtlDeleteRange(). Referenced by IopPortInitialize(). : This routine is called from AllocateEntry if the possible solution (State->Start - State->End) does not allow us to allocate resources to the rest of the devices being considered. It deletes the ranges that were added to Arbiter->PossibleAllocation by AddAllocation including those associated with ISA aliases. Arguments: Arbiter - The instance data of the arbiter who was called. State - The state of the current arbitration. Return Value: None. --*/ { NTSTATUS status; ULONGLONG alias = State->Start; PAGED_CODE(); // // Delete the aliases // ARB_PRINT(2, ("\t\tDeleting aliases\n")); while (IopPortGetNextAlias(State->CurrentAlternative->Flags, alias, &alias)) { status = RtlDeleteRange( Arbiter->PossibleAllocation, alias, alias + State->CurrentAlternative->Length - 1, State->Entry->PhysicalDeviceObject ); // // We should not fail... // ASSERT(NT_SUCCESS(status)); } // // Now call the original function to delete the base range // ArbBacktrackAllocation(Arbiter, State); }

BOOLEAN IopPortFindSuitableRange (  PARBITER_INSTANCE  Arbiter, PARBITER_ALLOCATION_STATE  State )

Definition at line 959 of file pnpmemio.c. References _ARBITER_ALTERNATIVE::Alignment, ARBITER_ALTERNATIVE_FLAG_SHARED, ARBITER_FLAG_BOOT_CONFIG, ARBITER_RANGE_BOOT_ALLOCATED, ArbiterRequestLegacyAssigned, ArbiterRequestLegacyReported, _ARBITER_ALLOCATION_STATE::CurrentAlternative, _ARBITER_ALLOCATION_STATE::CurrentMaximum, _ARBITER_ALLOCATION_STATE::CurrentMinimum, _ARBITER_ALLOCATION_STATE::End, _ARBITER_ALLOCATION_STATE::Entry, FALSE, _ARBITER_ALTERNATIVE::Flags, _ARBITER_LIST_ENTRY::Flags, IopPortIsAliasedRangeAvailable(), _ARBITER_ALTERNATIVE::Length, NT_SUCCESS, NTSTATUS(), PAGED_CODE, _ARBITER_LIST_ENTRY::RequestSource, RtlFindRange(), _ARBITER_ALLOCATION_STATE::Start, and TRUE. Referenced by IopPortInitialize(). : This routine is called from AllocateEntry once we have decided where we want to allocate from. It tries to find a free range that matches the requirements in State while restricting its possible solutions to the range State->Start to State->CurrentMaximum. On success State->Start and State->End represent this range. Conflicts with ISA aliases are considered. Arguments: Arbiter - The instance data of the arbiter who was called. State - The state of the current arbitration. Return Value: TRUE if we found a range, FALSE otherwise. --*/ { NTSTATUS status; UCHAR userFlagsMask = 0; PAGED_CODE(); // // If we are asking for zero ports then trivially succeed with the minimum // value // if (State->CurrentAlternative->Length == 0) { State->End = State->Start; return TRUE; } // // For legacy requests from IoAssignResources (directly or by way of // HalAssignSlotResources) or IoReportResourceUsage we consider preallocated // resources to be available for backward compatibility reasons. // // If we are allocating a devices boot config then we consider all other // boot configs to be available. // if (State->Entry->RequestSource == ArbiterRequestLegacyReported || State->Entry->RequestSource == ArbiterRequestLegacyAssigned || State->Entry->Flags & ARBITER_FLAG_BOOT_CONFIG) { userFlagsMask = ARBITER_RANGE_BOOT_ALLOCATED; } // // Try to satisfy the request // while (State->CurrentMinimum <= State->CurrentMaximum) { // // Select the first free alternative from the current alternative // status = RtlFindRange( Arbiter->PossibleAllocation, State->CurrentMinimum, State->CurrentMaximum, State->CurrentAlternative->Length, State->CurrentAlternative->Alignment, State->CurrentAlternative->Flags & ARBITER_ALTERNATIVE_FLAG_SHARED ? RTL_RANGE_LIST_SHARED_OK : 0, userFlagsMask, Arbiter->ConflictCallbackContext, Arbiter->ConflictCallback, &State->Start ); // // Did we find a range and if not can we override any conflict // if (NT_SUCCESS(status) || Arbiter->OverrideConflict(Arbiter, State)) { State->End = State->Start + State->CurrentAlternative->Length - 1; // // Check if the aliases are available // if (IopPortIsAliasedRangeAvailable(Arbiter, State)) { // // We found a suitable range so return // return TRUE; } else { // // This range's aliases arn't available so try the next range // State->Start += State->CurrentAlternative->Length; continue; } } else { // // We couldn't find a base range // break; } } return FALSE; }

BOOLEAN IopPortGetNextAlias (  ULONG  IoDescriptorFlags, ULONGLONG  LastAlias, PULONGLONG  NextAlias )

Definition at line 1087 of file pnpmemio.c. References FALSE, MAX_ALIAS_PORT, PAGED_CODE, and TRUE. Referenced by IopPortAddAllocation(), IopPortBacktrackAllocation(), and IopPortIsAliasedRangeAvailable(). : This routine calculates the next alias of an IO port up to MAX_ALIAS_PORT. Arguments: IoDescriptorFlags - The flags from the requirement descriptor indicating the type of alias if any. LastAlias - The alias previous to this one. NextAlias - Point to where the next alias should be returned Return Value: TRUE if we found an alias, FALSE otherwise. --*/ { ULONGLONG next; PAGED_CODE(); if (IoDescriptorFlags & CM_RESOURCE_PORT_10_BIT_DECODE) { next = LastAlias + (1 << 10); } else if (IoDescriptorFlags & CM_RESOURCE_PORT_12_BIT_DECODE) { next = LastAlias + (1 << 12); } else { // BUGBUG - should CM_RESOURCE_PORT_16_BIT_DECODE be set? // // There are no aliases // return FALSE; } // // Check that we are below the maximum aliased port // if (next > MAX_ALIAS_PORT) { return FALSE; } else { *NextAlias = next; return TRUE; } }

NTSTATUS IopPortInitialize (  VOID   )

Definition at line 349 of file pnpmemio.c. References _ARBITER_INSTANCE::AddAllocation, ArbInitializeArbiterInstance(), _ARBITER_INSTANCE::BacktrackAllocation, _ARBITER_INSTANCE::FindSuitableRange, IopGenericPackResource(), IopGenericScoreRequirement(), IopGenericTranslateOrdering(), IopGenericUnpackRequirement(), IopGenericUnpackResource(), IopPortAddAllocation(), IopPortBacktrackAllocation(), IopPortFindSuitableRange(), IopRootPortArbiter, L, NULL, _ARBITER_INSTANCE::PackResource, PAGED_CODE, _ARBITER_INSTANCE::ScoreRequirement, _ARBITER_INSTANCE::UnpackRequirement, and _ARBITER_INSTANCE::UnpackResource. Referenced by IopInitializePlugPlayServices(). : This routine initializes the arbiter Parameters: None Return Value: None --*/ { PAGED_CODE(); // // Fill in the non-default action handlers // IopRootPortArbiter.FindSuitableRange = IopPortFindSuitableRange; IopRootPortArbiter.AddAllocation = IopPortAddAllocation; IopRootPortArbiter.BacktrackAllocation = IopPortBacktrackAllocation; IopRootPortArbiter.UnpackRequirement = IopGenericUnpackRequirement; IopRootPortArbiter.PackResource = IopGenericPackResource; IopRootPortArbiter.UnpackResource = IopGenericUnpackResource; IopRootPortArbiter.ScoreRequirement = IopGenericScoreRequirement; return ArbInitializeArbiterInstance(&IopRootPortArbiter, NULL, // Indicates ROOT arbiter CmResourceTypePort, L"RootPort", L"Root", IopGenericTranslateOrdering ); }

BOOLEAN IopPortIsAliasedRangeAvailable (  PARBITER_INSTANCE  Arbiter, PARBITER_ALLOCATION_STATE  State )

Definition at line 1227 of file pnpmemio.c. References ARB_PRINT, ARBITER_ALLOCATION_STATE, ARBITER_ALTERNATIVE_FLAG_SHARED, ARBITER_RANGE_BOOT_ALLOCATED, ArbiterRequestLegacyAssigned, ArbiterRequestLegacyReported, ASSERT, _ARBITER_ALLOCATION_STATE::CurrentAlternative, _ARBITER_ALLOCATION_STATE::CurrentMaximum, _ARBITER_ALLOCATION_STATE::CurrentMinimum, _ARBITER_ALTERNATIVE::Descriptor, _ARBITER_ALLOCATION_STATE::Entry, FALSE, _ARBITER_ALTERNATIVE::Flags, IopPortGetNextAlias(), _ARBITER_ALTERNATIVE::Length, NT_SUCCESS, NTSTATUS(), PAGED_CODE, _ARBITER_LIST_ENTRY::RequestSource, RtlIsRangeAvailable(), _ARBITER_ALLOCATION_STATE::Start, and TRUE. Referenced by IopPortFindSuitableRange(). : This routine determines if the range (Start-(Length-1)) is available taking into account any aliases. Arguments: Arbiter - The instance data of the arbiter who was called. State - The state of the current arbitration. Return Value: TRUE if the range is available, FALSE otherwise. --*/ { NTSTATUS status; ULONGLONG alias = State->Start; BOOLEAN aliasAvailable; UCHAR userFlagsMask = 0; PAGED_CODE(); #if defined(BUGFEST_HACKS) // // For the purposes of the Bug^H^H^HPlugFest don't mind is aliases conflict // with any devices but still add them... // return TRUE; #endif // // For legacy requests from IoAssignResources (directly or by way of // HalAssignSlotResources) or IoReportResourceUsage we consider preallocated // resources to be available for backward compatibility reasons. // if (State->Entry->RequestSource == ArbiterRequestLegacyReported || State->Entry->RequestSource == ArbiterRequestLegacyAssigned) { userFlagsMask |= ARBITER_RANGE_BOOT_ALLOCATED; } while (IopPortGetNextAlias(State->CurrentAlternative->Descriptor->Flags, alias, &alias)) { status = RtlIsRangeAvailable( Arbiter->PossibleAllocation, alias, alias + State->CurrentAlternative->Length - 1, State->CurrentAlternative->Flags & ARBITER_ALTERNATIVE_FLAG_SHARED ? RTL_RANGE_LIST_SHARED_OK : 0, userFlagsMask, Arbiter->ConflictCallbackContext, Arbiter->ConflictCallback, &aliasAvailable ); ASSERT(NT_SUCCESS(status)); if (!aliasAvailable) { ARBITER_ALLOCATION_STATE tempState; // // Check if we allow this conflict by calling OverrideConflict - // we will need to falsify ourselves an allocation state first // // BUGBUG - this works but relies on knowing what OverrideConflict // looks at. A better fix invloves storing the aliases in another // list but this it too much of a change for Win2k // RtlCopyMemory(&tempState, State, sizeof(ARBITER_ALLOCATION_STATE)); tempState.CurrentMinimum = alias; tempState.CurrentMaximum = alias + State->CurrentAlternative->Length - 1; if (Arbiter->OverrideConflict(Arbiter, &tempState)) { // // We decided this conflict was ok so contine checking the rest // of the aliases // continue; } // // An alias isn't available - get another possibility // ARB_PRINT(2, ("\t\tAlias 0x%x-0x%x not available\n", alias, alias + State->CurrentAlternative->Length - 1 )); return FALSE; } } return TRUE; }

BOOLEAN IopPortIsAliasedRangeAvailable (  IN PARBITER_INSTANCE  Arbiter, IN PARBITER_ALLOCATION_STATE  State )

NTSTATUS IopTranslateBusAddress (  IN PHYSICAL_ADDRESS  SourceAddress, IN UCHAR  SourceResourceType, OUT PPHYSICAL_ADDRESS  TargetAddress, OUT PUCHAR  TargetResourceType )

Definition at line 155 of file pnpmemio.c. References ADDRESS_SPACE_DENSE_MEMORY, ADDRESS_SPACE_MEMORY, ADDRESS_SPACE_PORT, ADDRESS_SPACE_USER_DENSE_MEMORY, ADDRESS_SPACE_USER_MEMORY, ADDRESS_SPACE_USER_PORT, ARB_PRINT, ASSERT, HalTranslateBusAddress(), NTSTATUS(), and PAGED_CODE. Referenced by IopGenericTranslateOrdering(). : This routine translates addresses. Parameters: SourceAddress - The address to translate ResourceType - The resource type (IO or Memory) we are translaing. If the address space changes from IO->Memory this will be updated. TargetAddress - Pointer to where the target should be translated to. Return Value: STATUS_SUCCESS or an error status --*/ { NTSTATUS status = STATUS_UNSUCCESSFUL; ULONG sourceAddressSpace, targetAddressSpace; BOOLEAN translated; PAGED_CODE(); // // Select the appropriate address space // if (SourceResourceType == CmResourceTypeMemory) { sourceAddressSpace = ADDRESS_SPACE_MEMORY; } else if (SourceResourceType == CmResourceTypePort) { sourceAddressSpace = ADDRESS_SPACE_PORT; } else { return STATUS_INVALID_PARAMETER; } ARB_PRINT( 2, ("Translating %s address 0x%I64x => ", SourceResourceType == CmResourceTypeMemory ? "Memory" : "I/O", SourceAddress.QuadPart )); // // HACKHACK Ask the HAL to translate on ISA bus - if we can't then just // don't translate because this must be a PCI system so the root arbiters // don't do much (Yes it's a steaming hack but it'll work for beta 1) // targetAddressSpace = sourceAddressSpace; translated = HalTranslateBusAddress( Isa, 0, SourceAddress, &targetAddressSpace, TargetAddress ); if (!translated) { ARB_PRINT(2,("Translation failed!\n")); return STATUS_UNSUCCESSFUL; } // // Update the resource type in the target if we have gone from Io to Memory // // // BUBBUG - update the length for IO -> Memory (Dense vs Sparse) // I think the answer is dense -> spares is multiply length by 32 // if (targetAddressSpace == ADDRESS_SPACE_MEMORY || targetAddressSpace == ADDRESS_SPACE_USER_MEMORY || targetAddressSpace == ADDRESS_SPACE_DENSE_MEMORY || targetAddressSpace == ADDRESS_SPACE_USER_DENSE_MEMORY) { *TargetResourceType = CmResourceTypeMemory; } else if (targetAddressSpace == ADDRESS_SPACE_PORT || targetAddressSpace == ADDRESS_SPACE_USER_PORT) { *TargetResourceType = CmResourceTypePort; } else { ASSERT(0 && "Translation has returned an unknown address space"); } ARB_PRINT( 2, ("%s address 0x%I64x\n", *TargetResourceType == CmResourceTypeMemory ? "Memory" : "I/O", TargetAddress->QuadPart )); return STATUS_SUCCESS; }

---