FxCmResList Class Reference

#include <fxresource.hpp>

Inheritance diagram for FxCmResList:

Collaboration diagram for FxCmResList:

Public Member Functions
WDFCMRESLIST	GetHandle (VOID)
_Must_inspect_result_ NTSTATUS	BuildFromWdmList (__in PCM_RESOURCE_LIST ResourceList, __in UCHAR AccessFlags)
_Must_inspect_result_ PCM_RESOURCE_LIST	CreateWdmList (__in __drv_strictTypeMatch(__drv_typeExpr) POOL_TYPE PoolType=PagedPool)
ULONG	GetCount (VOID)
PCM_PARTIAL_RESOURCE_DESCRIPTOR	GetDescriptor (__in ULONG Index)
__inline void	LockResourceTable ()
__inline void	UnlockResourceTable ()
NTSTATUS	BuildRegisterResourceTable (VOID)
NTSTATUS	BuildPortResourceTable (VOID)
VOID	UpdateRegisterResourceEntryLocked (__in FxRegisterResourceInfo *Entry, __in PVOID SystemMappedAddress, __in SIZE_T NumberOfBytes, __in PVOID UsermodeMappedAddress)
VOID	ClearRegisterResourceEntryLocked (__in FxRegisterResourceInfo *Entry)
HRESULT	ValidateRegisterPhysicalAddressRange (__in PHYSICAL_ADDRESS PhysicalAddress, __in SIZE_T Size, __out FxRegisterResourceInfo **TableEntry)
HRESULT	ValidateRegisterSystemBaseAddress (__in PVOID Address, __out PVOID *UsermodeBaseAddress)
HRESULT	ValidateRegisterSystemAddressRange (__in PVOID SystemAddress, __in SIZE_T Length, __out_opt PVOID *UsermodeAddress)
HRESULT	ValidateAndClearMapping (__in PVOID Address, __in SIZE_T Length)
HRESULT	ValidatePortAddressRange (__in PVOID Address, __in SIZE_T Length)
SIZE_T	GetResourceLength (__in PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor, __out_opt PHYSICAL_ADDRESS *Start)
HRESULT	MapIoSpaceWorker (__in PHYSICAL_ADDRESS PhysicalAddress, __in SIZE_T NumberOfBytes, __in MEMORY_CACHING_TYPE CacheType, __deref_out VOID **PseudoBaseAddress)
VOID	ValidateResourceUnmap (VOID)
VOID	DeleteRegisterResourceTable (VOID)
VOID	DeletePortResourceTable (VOID)
_Must_inspect_result_ NTSTATUS	CheckForConnectionResources (VOID)
BOOLEAN	HasConnectionResources (VOID)
Public Member Functions inherited from FxResourceCollection
BOOLEAN	RemoveAndDelete (__in ULONG Index)
_Must_inspect_result_ NTSTATUS	AddAt (__in ULONG Index, __in FxObject *Object)
BOOLEAN	IsRemoveAllowed (VOID)
BOOLEAN	IsAddAllowed (VOID)
VOID	MarkChanged (VOID)
BOOLEAN	IsChanged (VOID)
Public Member Functions inherited from FxCollection
	FxCollection (__in PFX_DRIVER_GLOBALS FxDriverGlobals)
	~FxCollection (VOID)
BOOLEAN	Add (__in FxObject *Item)
VOID	StealCollection (__in FxCollection *Collection)
Public Member Functions inherited from FxNonPagedObject
	FxNonPagedObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)
	FxNonPagedObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType ObjectType)
virtual	~FxNonPagedObject (VOID)
	_Acquires_lock_ (this->m_NPLock.m_Lock) __drv_maxIRQL(DISPATCH_LEVEL) __drv_setsIRQL(DISPATCH_LEVEL) VOID Lock(__out __drv_deref(__drv_savesIRQL) PKIRQL PreviousIrql)
	_Releases_lock_ (this->m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) __inline VOID Unlock(__in __drv_restoresIRQL KIRQL PreviousIrql)
	_Acquires_lock_ (this->m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) VOID LockAtDispatch(VOID)
	_Requires_lock_held_ (this->m_NPLock.m_Lock) _Releases_lock_(this -> m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) __inline VOID UnlockFromDispatch(VOID)
Public Member Functions inherited from FxObject
PVOID	GetCOMWrapper ()
void	SetCOMWrapper (__drv_aliasesMem PVOID Wrapper)
	FxObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)
virtual	~FxObject (VOID)
PVOID __inline	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType Type)
PVOID __inline	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __in USHORT ExtraSize=0)
VOID	operator delete (__in PVOID Memory)
VOID	SetNoContextHeader (VOID)
PVOID __inline	GetObjectHandle (VOID)
__inline FxContextHeader *	GetContextHeader (VOID)
__inline PFX_DRIVER_GLOBALS	GetDriverGlobals (VOID)
WDFTYPE	GetType (VOID)
USHORT	GetObjectSize (VOID)
LONG	GetRefCnt (VOID)
FxTagTracker *	GetTagTracker (VOID)
CfxDevice *	GetDevice (VOID)
CfxDeviceBase *	GetDeviceBase (VOID)
VOID	SetDeviceBase (__in CfxDeviceBase *DeviceBase)
__inline VOID	CallCleanup (VOID)
ULONG __inline	AddRef (__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
virtual ULONG	Release (__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
virtual ULONG	AddRefOverride (__in WDFOBJECT_OFFSET Offset, __in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
virtual ULONG	ReleaseOverride (__in WDFOBJECT_OFFSET Offset, __in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
virtual _Must_inspect_result_ NTSTATUS	QueryInterface (__in FxQueryInterfaceParams *Params)
VOID	MarkTraceState (VOID)
BOOLEAN __inline	IsTraceState (VOID)
VOID __inline	TraceDroppedEvent (__in FxObjectDroppedEvent Event)
VOID	MarkPassiveDispose (__in FxObjectLockState State=ObjectLock)
VOID	MarkPassiveCallbacks (__in FxObjectLockState State=ObjectLock)
VOID	MarkForceDisposeThread (__in FxObjectLockState State=ObjectLock)
BOOLEAN	IsPassiveCallbacks (__in BOOLEAN AcquireLock=TRUE)
BOOLEAN	IsPassiveDispose (__in BOOLEAN AcquireLock=TRUE)
BOOLEAN	IsForceDisposeThread (__in BOOLEAN AcquireLock=TRUE)
VOID	MarkCommitted (VOID)
BOOLEAN	IsCommitted (VOID)
VOID	MarkDisposeOverride (__in FxObjectLockState State=ObjectLock)
VOID	MarkNoDeleteDDI (__in FxObjectLockState State=ObjectLock)
BOOLEAN	IsNoDeleteDDI (VOID)
_Must_inspect_result_ NTSTATUS	Commit (__in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __out_opt WDFOBJECT *ObjectHandle, __in_opt FxObject *Parent=NULL, __in BOOLEAN AssignDriverAsDefaultParent=TRUE)
VOID	DeleteFromFailedCreate (VOID)
VOID	ClearEvtCallbacks (VOID)
BOOLEAN	EarlyDispose (VOID)
virtual VOID	DeleteObject (VOID)
virtual BOOLEAN	Dispose (VOID)
_Must_inspect_result_ NTSTATUS	AssignParentObject (__in FxObject *ParentObject)
_Must_inspect_result_ NTSTATUS	AddContext (__in FxContextHeader *Header, __in PVOID *Context, __in PWDF_OBJECT_ATTRIBUTES Attributes)
_Must_inspect_result_ NTSTATUS	RemoveParentAssignment (VOID)
_Must_inspect_result_ FxObject *	GetParentObjectReferenced (__in PVOID Tag)
BOOLEAN	IsDisposed (VOID)
Public Member Functions inherited from FxCollectionInternal
	FxCollectionInternal (VOID)
	~FxCollectionInternal (VOID)
_Must_inspect_result_ FxCollectionEntry *	FindEntry (__in ULONG Index)
_Must_inspect_result_ FxCollectionEntry *	FindEntryByObject (__in FxObject *Object)
ULONG	Count (VOID)
BOOLEAN	Add (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObject *Item)
_Must_inspect_result_ FxObject *	GetItem (__in ULONG Index)
_Must_inspect_result_ FxObject *	GetFirstItem (VOID)
_Must_inspect_result_ FxObject *	GetLastItem (VOID)
NTSTATUS	Remove (__in ULONG Index)
VOID	CleanupEntry (__in FxCollectionEntry *Entry)
VOID	CleanupEntryObject (__in FxObject *Object)
NTSTATUS	RemoveEntry (__in FxCollectionEntry *Entry)
_Must_inspect_result_ NTSTATUS	RemoveItem (__in FxObject *Item)
_Must_inspect_result_ FxCollectionEntry *	Start (VOID)
_Must_inspect_result_ FxCollectionEntry *	End (VOID)
VOID	Clear (VOID)

Static Public Member Functions
static _Must_inspect_result_ NTSTATUS	_CreateAndInit (__in FxCmResList **ResourceList, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in CfxDevice *Device, __in_opt PWDF_OBJECT_ATTRIBUTES ListAttributes, __in UCHAR AccessFlags)
Static Public Member Functions inherited from FxObject
static FxObject *	_FromDisposeEntry (__in PSINGLE_LIST_ENTRY Entry)
static FxObject *	_GetObjectFromHandle (__in WDFOBJECT Handle, __inout PWDFOBJECT_OFFSET ObjectOffset)
static PVOID __inline	_ToHandle (__in FxObject *Object)
static VOID __inline	_ReferenceActual (__in WDFOBJECT Object, __in_opt PVOID Tag, __in LONG Line, __in PSTR File)
static VOID __inline	_DereferenceActual (__in WDFOBJECT Object, __in_opt PVOID Tag, __in LONG Line, __in PSTR File)
static PVOID	_GetDebugBase (__in FxObject *Object)
static PFX_POOL_HEADER	_CleanupPointer (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObject *Object)
static _Must_inspect_result_ NTSTATUS	_GetEffectiveLock (__in FxObject *Object, __in_opt IFxHasCallbacks *Callbacks, __in BOOLEAN AutomaticLocking, __in BOOLEAN PassiveCallbacks, __out FxCallbackLock **CallbackLock, __out_opt FxObject **CallbackLockObject)
static _Must_inspect_result_ NTSTATUS	_ObjectQuery (_In_ FxObject *Object, _In_ CONST GUID *Guid, _In_ ULONG QueryBufferLength, _Out_writes_bytes_(QueryBufferLength) PVOID QueryBuffer)

Protected Member Functions
	FxCmResList (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in UCHAR AccessFlags)
	~FxCmResList ()
Protected Member Functions inherited from FxResourceCollection
	FxResourceCollection (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in WDFTYPE Type, __in USHORT Size, __in UCHAR AccessFlags=FxResourceNoAccess)
Protected Member Functions inherited from FxCollection
	FxCollection (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in WDFTYPE Type, __in USHORT Size)
Protected Member Functions inherited from FxObject
	FxObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType ObjectType)
FxObjectDebugExtension *	GetDebugExtension (VOID)
BOOLEAN	IsDebug (VOID)
VOID	AllocateTagTracker (__in WDFTYPE Type)
virtual VOID	SelfDestruct (VOID)
PVOID __inline	GetObjectHandleUnchecked (VOID)
VOID __inline	DestroyChildren (VOID)
VOID	DeleteEarlyDisposedObject (VOID)
Protected Member Functions inherited from FxCollectionInternal
_Must_inspect_result_ FxCollectionEntry *	AllocateEntry (__in PFX_DRIVER_GLOBALS FxDriverGlobals)
VOID	AddEntry (__in FxCollectionEntry *Node, __in FxObject *Item)

Protected Attributes
FxRegisterResourceInfo *	m_RegisterResourceTable
ULONG	m_RegisterResourceTableSizeCe
FxPortResourceInfo *	m_PortResourceTable
ULONG	m_PortResourceTableSizeCe
BOOLEAN	m_HasConnectionResources
MxLock	m_ResourceTableLock
Protected Attributes inherited from FxObject
union {
CfxDeviceBase *   m_DeviceBase
CfxDevice *   m_Device
};
Protected Attributes inherited from FxCollectionInternal
ULONG	m_Count
LIST_ENTRY	m_ListHead

Additional Inherited Members
Public Attributes inherited from FxResourceCollection
UCHAR	m_AccessFlags
BOOLEAN	m_Changed
Static Protected Member Functions inherited from FxObject
static PVOID	_GetBase (__in FxObject *Object)

Detailed Description

Definition at line 348 of file fxresource.hpp.

Constructor & Destructor Documentation

FxCmResList()

FxCmResList::FxCmResList ( __in PFX_DRIVER_GLOBALS  FxDriverGlobals, __in UCHAR  AccessFlags  )

inlineprotected

Definition at line 377 of file fxresource.hpp.

          : FxResourceCollection(FxDriverGlobals,
                                 FX_TYPE_CM_RES_LIST,
                                 sizeof(FxCmResList),
                                 AccessFlags)
    {
#if (FX_CORE_MODE==FX_CORE_USER_MODE)
        m_RegisterResourceTable = NULL;
        m_PortResourceTable = NULL;
        m_RegisterResourceTableSizeCe = 0;
        m_PortResourceTableSizeCe = 0;
        m_HasConnectionResources = FALSE;
#endif // FX_CORE_USER_MODE
    }

~FxCmResList()

FxCmResList::~FxCmResList ( )

protected

Definition at line 35 of file fxresourcecollectionkm.cpp.

{
}

Member Function Documentation

_CreateAndInit()

static _Must_inspect_result_ NTSTATUS FxCmResList::_CreateAndInit ( __in FxCmResList **  ResourceList, __in PFX_DRIVER_GLOBALS  FxDriverGlobals, __in CfxDevice *  Device, __in_opt PWDF_OBJECT_ATTRIBUTES  ListAttributes, __in UCHAR  AccessFlags  )

inlinestatic

Definition at line 400 of file fxresource.hpp.

    {
        NTSTATUS ntStatus;
        FxCmResList *resList = NULL;
 
        UNREFERENCED_PARAMETER(Device);
 
        //
        // Initialize
        //
        *ResourceList = NULL;
 
        //
        // Allocate a new resource list object
        //
        resList = new(FxDriverGlobals, ListAttributes)
            FxCmResList(FxDriverGlobals, AccessFlags);
 
        if (resList == NULL) {
 
            ntStatus = STATUS_INSUFFICIENT_RESOURCES;
 
            DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR,
                                TRACINGDEVICE,
                                "Failed to allocate FxCmResList, "
                                "returning %!STATUS!",
                                ntStatus);
            goto exit;
        }
 
        *ResourceList = resList;
        ntStatus = STATUS_SUCCESS;
 
    exit:
        if (!NT_SUCCESS(ntStatus)) {
            if (NULL != resList) {
                resList->DeleteFromFailedCreate();
            }
        }
        return ntStatus;
    }

Referenced by FxPkgPnp::Initialize(), and FxPkgPdo::PnpQueryResources().

BuildFromWdmList()

_Must_inspect_result_ NTSTATUS FxCmResList::BuildFromWdmList	(	__in PCM_RESOURCE_LIST	ResourceList,
		__in UCHAR	AccessFlags
	)

Definition at line 289 of file fxresourcecollection.cpp.

{
    NTSTATUS status;
 
    //
    // Predispose to success
    //
    status = STATUS_SUCCESS;
 
    Clear();
 
    m_AccessFlags = AccessFlags;
 
    if (WdmResourceList != NULL) {
        PCM_PARTIAL_RESOURCE_DESCRIPTOR pDescriptor;
        ULONG count, i;
 
        //
        // We only expect to see one full resource descriptor.
        //
        ASSERT(WdmResourceList->Count == 1);
 
        count = WdmResourceList->List[0].PartialResourceList.Count;
        pDescriptor = WdmResourceList->List[0].PartialResourceList.PartialDescriptors;
 
        for(i = 0; i < count; i++, pDescriptor++) {
            FxResourceCm *pResource;
 
            pResource = new(GetDriverGlobals())
                FxResourceCm(GetDriverGlobals(), pDescriptor);
 
            if (pResource == NULL) {
                status = STATUS_INSUFFICIENT_RESOURCES;
            }
 
            if (NT_SUCCESS(status)) {
                status = pResource->AssignParentObject(this);
 
                //
                // Since we control our own lifetime here, the assign should
                // always work.
                //
                ASSERT(NT_SUCCESS(status));
 
                status = Add(pResource) ? STATUS_SUCCESS : STATUS_INSUFFICIENT_RESOURCES;
            }
 
            if (!NT_SUCCESS(status)) {
                Clear();
                break;
            }
        }
    }
 
    return status;
}

Referenced by FxPkgPnp::PnpMatchResources(), and FxPkgFdo::PnpSendStartDeviceDownTheStackOverload().

BuildPortResourceTable()

NTSTATUS FxCmResList::BuildPortResourceTable

(

VOID

)

Definition at line 146 of file fxresourcecollectionum.cpp.

{
    ULONG count;
    ULONG i, index;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR desc;
    ULONG numPortDesc;
    BOOLEAN locked = FALSE;
    NTSTATUS status;
 
    count = GetCount();
    numPortDesc = 0;
 
    //
    // count number of register descriptors
    //
    for (i = 0; i < count; i++) {
        desc = GetDescriptor(i);
        if (desc == NULL) {
            status = STATUS_INVALID_DEVICE_STATE;
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                        "Resource Descriptor not found %!STATUS!", status);
            goto exit;
        }
 
        if (desc->Type == CmResourceTypePort) {
            numPortDesc++;
        }
    }
 
    if (numPortDesc == 0) {
        return STATUS_SUCCESS;
    }
 
    //
    // allocate table
    //
    LockResourceTable();
    locked = TRUE;
 
    status =  FxPortResourceInfo::_CreateAndInit(
                                                GetDriverGlobals(),
                                                numPortDesc,
                                                &m_PortResourceTable
                                                );
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                    "Failed to allocate memory for resource table"
                    " %!STATUS!", status);
        goto exit;
    }
    m_PortResourceTableSizeCe = numPortDesc;
 
    //
    // Populate table
    //
    index = 0;
    for (i = 0; i < count; i++) {
        desc = GetDescriptor(i);
        if (desc == NULL) {
            status = STATUS_INVALID_DEVICE_STATE;
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                        "Resource Descriptor not found %!STATUS!", status);
            goto exit;
        }
 
        if (desc->Type == CmResourceTypePort) {
            SIZE_T len;
            PHYSICAL_ADDRESS pa;
 
            //
            // This will populate Length, StartPa and EndPa
            //
            len = GetResourceLength(desc, &pa);
            if (len) {
                m_PortResourceTable[index].SetPhysicalAddress(pa, len);
            }
 
            index++;
        }
    }
 
exit:
 
    if (!NT_SUCCESS(status)) {
        if (m_PortResourceTable != NULL) {
            delete [] m_PortResourceTable;
            m_PortResourceTable = NULL;
            m_PortResourceTableSizeCe = 0;
        }
    }
 
    if (locked) {
        UnlockResourceTable();
    }
 
    return status;
}

Referenced by __drv_when().

BuildRegisterResourceTable()

NTSTATUS FxCmResList::BuildRegisterResourceTable

(

VOID

)

Definition at line 43 of file fxresourcecollectionum.cpp.

{
    ULONG count;
    ULONG i, index;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR desc;
    ULONG numRegisterDesc;
    BOOLEAN locked = FALSE;
    NTSTATUS status;
 
    count = GetCount();
    numRegisterDesc = 0;
 
    //
    // count number of register descriptors
    //
    for (i = 0; i < count; i++) {
        desc = GetDescriptor(i);
        if (desc == NULL) {
            status = STATUS_INVALID_DEVICE_STATE;
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                        "Resource Descriptor not found %!STATUS!", status);
            goto exit;
        }
 
        if (desc->Type == CmResourceTypeMemory ||
            desc->Type == CmResourceTypeMemoryLarge) {
            numRegisterDesc++;
        }
    }
 
    if (numRegisterDesc == 0) {
        return STATUS_SUCCESS;
    }
 
    //
    // allocate table
    //
    LockResourceTable();
    locked = TRUE;
 
    status =  FxRegisterResourceInfo::_CreateAndInit(
                                                    GetDriverGlobals(),
                                                    numRegisterDesc,
                                                    &m_RegisterResourceTable
                                                    );
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                    "Failed to allocate memory for resource table"
                    " %!STATUS!", status);
        goto exit;
    }
    m_RegisterResourceTableSizeCe = numRegisterDesc;
 
    //
    // Populate table
    //
    index = 0;
    for (i = 0; i < count; i++) {
        desc = GetDescriptor(i);
        if (desc == NULL) {
            status = STATUS_INVALID_DEVICE_STATE;
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                        "Resource Descriptor not found %!STATUS!", status);
            goto exit;
        }
 
        if (desc->Type == CmResourceTypeMemory ||
            desc->Type == CmResourceTypeMemoryLarge) {
            SIZE_T len;
            PHYSICAL_ADDRESS pa;
 
            //
            // This will populate Length and StartPa
            //
            len = GetResourceLength(desc, &pa);
            if (len) {
                m_RegisterResourceTable[index].SetPhysicalAddress(pa, len);
            }
 
            index++;
        }
    }
 
exit:
 
    if (!NT_SUCCESS(status)) {
        if (m_RegisterResourceTable != NULL) {
            delete [] m_RegisterResourceTable;
            m_RegisterResourceTable = NULL;
            m_RegisterResourceTableSizeCe = 0;
        }
    }
 
    if (locked) {
        UnlockResourceTable();
    }
 
    return status;
}

Referenced by __drv_when().

CheckForConnectionResources()

_Must_inspect_result_ NTSTATUS FxCmResList::CheckForConnectionResources

(

VOID

)

Definition at line 758 of file fxresourcecollectionum.cpp.

{
    NTSTATUS status;
    ULONG i;
    ULONG count;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR pDescriptor;
 
    status = STATUS_SUCCESS;
    count = GetCount();
 
    for (i = 0; i < count; i++) {
        pDescriptor = GetDescriptor(i);
        if (pDescriptor == NULL) {
            status = STATUS_INVALID_DEVICE_STATE;
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                        "Resource Descriptor not found %!STATUS!", status);
            goto exit;
        }
 
        if (pDescriptor->Type == CmResourceTypeConnection) {
            m_HasConnectionResources = TRUE;
            break;
        }
    }
 
exit:
    return status;
}

Referenced by __drv_when().

ClearRegisterResourceEntryLocked()

VOID FxCmResList::ClearRegisterResourceEntryLocked

(

__in FxRegisterResourceInfo *

Entry

)

Definition at line 259 of file fxresourcecollectionum.cpp.

{
    Entry->ClearMappedAddress();
}

Referenced by ValidateAndClearMapping().

CreateWdmList()

_Must_inspect_result_ PCM_RESOURCE_LIST FxCmResList::CreateWdmList

(

__in __drv_strictTypeMatch(__drv_typeExpr) POOL_TYPE

PoolType = PagedPool

)

Definition at line 366 of file fxresourcecollection.cpp.

{
    PCM_RESOURCE_LIST pWdmResourceList;
    ULONG size;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
 
    pWdmResourceList = NULL;
    pFxDriverGlobals = GetDriverGlobals();
 
    if (Count()) {
        //
        // NOTE: This function assumes all resources are on the same bus
        // and therefore there is only one FULL_RESOURCE_DESCRIPTOR.
        //
        size = sizeof(CM_RESOURCE_LIST) +
               (sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR) * (Count() - 1));
 
        pWdmResourceList = (PCM_RESOURCE_LIST)
            MxMemory::MxAllocatePoolWithTag(PoolType, size, pFxDriverGlobals->Tag);
 
        if (pWdmResourceList != NULL) {
            PCM_PARTIAL_RESOURCE_DESCRIPTOR pDescriptor;
            FxCollectionEntry *cur, *end;
 
            RtlZeroMemory(pWdmResourceList, size);
 
            pWdmResourceList->Count = 1;  // We only return one full descriptor
 
            pWdmResourceList->List[0].PartialResourceList.Version  = 1;
            pWdmResourceList->List[0].PartialResourceList.Revision = 1;
            pWdmResourceList->List[0].PartialResourceList.Count = Count();
 
            pDescriptor =
                pWdmResourceList->List[0].PartialResourceList.PartialDescriptors;
 
            end = End();
            for (cur = Start(); cur != end; cur = cur->Next()) {
                FxResourceCm *pResource;
 
                pResource = (FxResourceCm*) cur->m_Object;
 
                RtlCopyMemory(pDescriptor,
                              &pResource->m_Descriptor,
                              sizeof(pResource->m_Descriptor));
                pDescriptor++;
            }
        }
    }
 
    return pWdmResourceList;
}

Referenced by FxPkgFdo::PnpSendStartDeviceDownTheStackOverload().

DeletePortResourceTable()

VOID FxCmResList::DeletePortResourceTable ( VOID  )

inline

Definition at line 595 of file fxresource.hpp.

    {
        LockResourceTable();
        if (m_PortResourceTable != NULL) {
            delete [] m_PortResourceTable;
            m_PortResourceTable = NULL;
            m_PortResourceTableSizeCe = 0;
        }
        UnlockResourceTable();
    }

Referenced by FxPkgPnp::PnpReleaseHardware().

DeleteRegisterResourceTable()

VOID FxCmResList::DeleteRegisterResourceTable ( VOID  )

inline

Definition at line 581 of file fxresource.hpp.

    {
        LockResourceTable();
        if (m_RegisterResourceTable != NULL) {
            delete [] m_RegisterResourceTable;
            m_RegisterResourceTable = NULL;
            m_RegisterResourceTableSizeCe = 0;
        }
        UnlockResourceTable();
    }

Referenced by FxPkgPnp::PnpReleaseHardware().

GetCount()

ULONG FxCmResList::GetCount

(

VOID

)

Definition at line 434 of file fxresourcecollection.cpp.

{
    ULONG count;
    KIRQL irql;
 
    Lock(&irql);
    count = Count();
    Unlock(irql);
 
    return count;
}

GetDescriptor()

PCM_PARTIAL_RESOURCE_DESCRIPTOR FxCmResList::GetDescriptor

(

__in ULONG

Index

)

Definition at line 449 of file fxresourcecollection.cpp.

{
    FxResourceCm* pObject;
    KIRQL irql;
 
    Lock(&irql);
    pObject = (FxResourceCm*) GetItem(Index);
    Unlock(irql);
 
    if (pObject == NULL) {
        return NULL;
    }
    else {
        //
        // Copy the current descriptor to the clone and return it
        //
        RtlCopyMemory(&pObject->m_DescriptorClone,
                      &pObject->m_Descriptor,
                      sizeof(pObject->m_Descriptor));
 
        return &pObject->m_DescriptorClone;
    }
}

Referenced by BuildPortResourceTable(), BuildRegisterResourceTable(), and CheckForConnectionResources().

GetHandle()

WDFCMRESLIST FxCmResList::GetHandle ( VOID  )

inline

Definition at line 449 of file fxresource.hpp.

    {
        return (WDFCMRESLIST) GetObjectHandle();
    }

Referenced by __drv_when(), FxPkgPnp::PnpReleaseHardware(), and FxPkgFdo::PnpSendStartDeviceDownTheStackOverload().

GetResourceLength()

SIZE_T FxCmResList::GetResourceLength	(	__in PCM_PARTIAL_RESOURCE_DESCRIPTOR	Descriptor,
		__out_opt PHYSICAL_ADDRESS *	Start
	)

Definition at line 551 of file fxresourcecollectionum.cpp.

{
    ULONGLONG length;
 
    length = 0;
 
    ASSERT((Descriptor->Type == CmResourceTypeMemory) ||
          (Descriptor->Type == CmResourceTypeMemoryLarge) ||
          (Descriptor->Type == CmResourceTypePort));
 
    //
    // If it is not large memory resource than length is in u.Memory.Length.
    // For large memory resource, the length is given by different fields in
    // CM_PARTIAL_RESOURCE_DESCRIPTOR structure.
    //
    if ((Descriptor->Type == CmResourceTypeMemory) ||
        (Descriptor->Type == CmResourceTypePort)) {
        length = Descriptor->u.Memory.Length;
 
    } else if (Descriptor->Flags & CM_RESOURCE_MEMORY_LARGE_40) {
        length = (((ULONGLONG)Descriptor->u.Memory40.Length40) << 8);
 
    } else if (Descriptor->Flags & CM_RESOURCE_MEMORY_LARGE_48) {
        length = (((ULONGLONG)Descriptor->u.Memory48.Length48) << 16);
 
    } else if (Descriptor->Flags & CM_RESOURCE_MEMORY_LARGE_64) {
        length = (((ULONGLONG)Descriptor->u.Memory64.Length64) << 32);
 
    } else {
        //
        // It should not be possible to get here.
        //
        ASSERT(FALSE);
    }
 
    if (Start != NULL) {
        *Start = Descriptor->u.Generic.Start;
    }
 
    //
    // large memory descriptor is only supported on 64-bit so the casting
    // below is ok.
    //
    return (SIZE_T) length;
}

Referenced by BuildPortResourceTable(), and BuildRegisterResourceTable().

HasConnectionResources()

BOOLEAN FxCmResList::HasConnectionResources ( VOID  )

inline

Definition at line 615 of file fxresource.hpp.

    {
        return m_HasConnectionResources;
    }

Referenced by FxDevice::IsInterruptAccessAllowed().

LockResourceTable()

__inline void FxCmResList::LockResourceTable ( )

inline

Definition at line 487 of file fxresource.hpp.

    {
        KIRQL oldIrql;
 
        m_ResourceTableLock.Acquire(&oldIrql);
 
        UNREFERENCED_PARAMETER(oldIrql);
    }

Referenced by BuildPortResourceTable(), BuildRegisterResourceTable(), DeletePortResourceTable(), DeleteRegisterResourceTable(), if(), MapIoSpaceWorker(), ValidateAndClearMapping(), and ValidateRegisterSystemBaseAddress().

MapIoSpaceWorker()

HRESULT FxCmResList::MapIoSpaceWorker	(	__in PHYSICAL_ADDRESS	PhysicalAddress,
		__in SIZE_T	NumberOfBytes,
		__in MEMORY_CACHING_TYPE	CacheType,
		__deref_out VOID **	PseudoBaseAddress
	)

Definition at line 619 of file fxresourcecollectionum.cpp.

{
    IWudfDeviceStack *deviceStack;
    PVOID systemAddress;
    PVOID usermodeAddress;
    HRESULT hr;
    FxRegisterResourceInfo* resEntry;
 
    //
    // check if this physical resource is among the assigned resources.
    // If it is, retrieve the table entry corresponding to to register res.
    //
    LockResourceTable();
 
    hr = ValidateRegisterPhysicalAddressRange(PhysicalAddress,
                                              NumberOfBytes,
                                              &resEntry);
 
    FX_VERIFY_WITH_NAME(DRIVER(BadArgument, TODO),
        CHECK("Invalid physical address or number of bytes provided",
        (SUCCEEDED(hr))), GetDriverGlobals()->Public.DriverName);
 
    *PseudoBaseAddress = NULL;
 
    //
    // Call host
    //
    deviceStack = GetDevice()->GetDeviceStack();
    systemAddress = NULL;
    usermodeAddress = NULL;
 
    if(GetDevice()->AreRegistersMappedToUsermode()) {
        hr = deviceStack->MapIoSpace(PhysicalAddress,
                                NumberOfBytes,
                                CacheType,
                                &systemAddress,
                                &usermodeAddress);
    }
    else {
        hr = deviceStack->MapIoSpace(PhysicalAddress,
                                NumberOfBytes,
                                CacheType,
                                &systemAddress,
                                NULL);
    }
 
    if (SUCCEEDED(hr)) {
        //
        // update the mapped resource list entry and add it to list
        //
        UpdateRegisterResourceEntryLocked(resEntry,
                                          systemAddress,
                                          NumberOfBytes,
                                          usermodeAddress);
 
        //
        // Convert system address to pseudo (opaque) base address
        //
        *PseudoBaseAddress = GetDevice()->GetPseudoAddressFromSystemAddress(
                                                            systemAddress
                                                            );
    }
 
    UnlockResourceTable();
 
    return hr;
}

UnlockResourceTable()

__inline void FxCmResList::UnlockResourceTable ( )

inline

Definition at line 500 of file fxresource.hpp.

    {
        m_ResourceTableLock.Release(PASSIVE_LEVEL);
    }

Referenced by BuildPortResourceTable(), BuildRegisterResourceTable(), DeletePortResourceTable(), DeleteRegisterResourceTable(), if(), MapIoSpaceWorker(), ValidateAndClearMapping(), and ValidateRegisterSystemBaseAddress().

UpdateRegisterResourceEntryLocked()

VOID FxCmResList::UpdateRegisterResourceEntryLocked	(	__in FxRegisterResourceInfo *	Entry,
		__in PVOID	SystemMappedAddress,
		__in SIZE_T	NumberOfBytes,
		__in PVOID	UsermodeMappedAddress
	)

Definition at line 248 of file fxresourcecollectionum.cpp.

{
    Entry->SetMappedAddress(SystemMappedAddress, NumberOfBytes, UsermodeMappedAddress);
}

Referenced by MapIoSpaceWorker().

ValidateAndClearMapping()

HRESULT FxCmResList::ValidateAndClearMapping	(	__in PVOID	Address,
		__in SIZE_T	Length
	)

Definition at line 363 of file fxresourcecollectionum.cpp.

{
    HRESULT hr = E_INVALIDARG;
    ULONG i;
    FxRegisterResourceInfo* entry = NULL;
 
    LockResourceTable();
 
    for (i = 0; i < m_RegisterResourceTableSizeCe; i++) {
        entry = &m_RegisterResourceTable[i];
 
        if (NULL != entry->m_StartSystemVa &&
            Address == entry->m_StartSystemVa &&
            Length == entry->m_MappedLength) {
            //
            // there is a valid mapping. clear it.
            //
            FX_VERIFY_WITH_NAME(INTERNAL, CHECK_NOT_NULL(entry->m_EndSystemVa),
                GetDriverGlobals()->Public.DriverName);
 
            ClearRegisterResourceEntryLocked(entry);
 
            hr = S_OK;
            break;
        }
    }
 
    UnlockResourceTable();
 
    return hr;
}

ValidatePortAddressRange()

HRESULT FxCmResList::ValidatePortAddressRange	(	__in PVOID	Address,
		__in SIZE_T	Length
	)

Definition at line 718 of file fxresourcecollectionum.cpp.

{
    ULONG i;
    HRESULT hr;
    ULONGLONG driverStartPa, driverEndPa, systemStartPa, systemEndPa;
    ULONGLONG tmp;
    FxPortResourceInfo* entry = NULL;
 
    driverStartPa = (ULONGLONG)Address;
 
    //
    //  driverEndPa = driverStartPa + Length - 1;
    //
    hr = ULongLongAdd(driverStartPa, Length, &tmp);
    FX_VERIFY_WITH_NAME(DRIVER(BadArgument, TODO), CHECK("Integer overflow occurred"
        "when computing port address range", SUCCEEDED(hr)),
        GetDriverGlobals()->Public.DriverName);
 
    driverEndPa = tmp - 1;
 
    for (i = 0; i < m_PortResourceTableSizeCe; i++) {
        entry = &m_PortResourceTable[i];
 
        systemStartPa = entry->m_StartPa.QuadPart;
        systemEndPa = entry->m_EndPa.QuadPart;
 
        if (driverStartPa >= systemStartPa  &&
            driverEndPa <= systemEndPa) {
            return S_OK;
        }
    }
 
    return E_INVALIDARG;
}

ValidateRegisterPhysicalAddressRange()

HRESULT FxCmResList::ValidateRegisterPhysicalAddressRange	(	__in PHYSICAL_ADDRESS	PhysicalAddress,
		__in SIZE_T	Size,
		__out FxRegisterResourceInfo **	TableEntry
	)

Definition at line 267 of file fxresourcecollectionum.cpp.

{
    ULONG i;
    HRESULT hr;
    ULONGLONG driverStartPa, driverEndPa, systemStartPa, systemEndPa;
    ULONGLONG tmp;
    FxRegisterResourceInfo* entry = NULL;
 
    *TableEntry = NULL;
 
    //
    // Physical address is of LONGLONG type (signed) we need to cast it to
    // ULONGLONG for comparision because in a LONGLONG comprison, the
    // result is different when highest bit is set vs when it is not set.
    //
    driverStartPa = PhysicalAddress.QuadPart;
 
    //
    //  driverEndPa = driverStartPa + Size - 1;
    //
    hr = ULongLongAdd(driverStartPa, Size, &tmp);
    FX_VERIFY_WITH_NAME(DRIVER(BadArgument, TODO), CHECK("Integer overflow occurred"
        "when computing register address range", SUCCEEDED(hr)),
        GetDriverGlobals()->Public.DriverName);
 
    driverEndPa = tmp - 1;
 
    //
    // We allow one physical address range mapping only. The base address and
    // length can be flexible within the assigned range.
    //
    for (i = 0; i < m_RegisterResourceTableSizeCe; i++) {
        entry = &m_RegisterResourceTable[i];
 
        //
        // No need to do int overflow safe additon here since start address and
        // length are assigned by pnp manager. Note that we don't store endPa in
        // resource table the way we do for SystemVa is because endPa is not
        // needed in hot path so can be computed using length.
        //
        systemStartPa = entry->m_StartPa.QuadPart;
        systemEndPa  = systemStartPa + entry->m_Length - 1;
 
        if (driverStartPa >= systemStartPa &&
            driverEndPa <= systemEndPa) {
 
            FX_VERIFY_WITH_NAME(DRIVER(BadArgument, TODO), CHECK("Attempt to do multiple "
                "mapping of same resource, or multiple mapping in same resource"
                " range",
                (entry->m_StartSystemVa == NULL)), GetDriverGlobals()->Public.DriverName);
            FX_VERIFY_WITH_NAME(INTERNAL, CHECK_NULL(entry->m_EndSystemVa),
                GetDriverGlobals()->Public.DriverName);
            FX_VERIFY_WITH_NAME(INTERNAL, CHECK_NULL(entry->m_StartUsermodeVa),
                GetDriverGlobals()->Public.DriverName);
            FX_VERIFY_WITH_NAME(INTERNAL, CHECK("Mapped length not zero",
                (entry->m_MappedLength == 0)), GetDriverGlobals()->Public.DriverName);
 
            *TableEntry = entry;
 
            return S_OK;
        }
    }
 
    return E_INVALIDARG;
}

Referenced by MapIoSpaceWorker().

ValidateRegisterSystemAddressRange()

HRESULT FxCmResList::ValidateRegisterSystemAddressRange	(	__in PVOID	SystemAddress,
		__in SIZE_T	Length,
		__out_opt PVOID *	UsermodeAddress
	)

Definition at line 471 of file fxresourcecollectionum.cpp.

{
    HRESULT hr = E_INVALIDARG;
    FxRegisterResourceInfo* entry = NULL;
    SIZE_T offset = 0;
    ULONG i;
    PVOID start = NULL;
    PVOID end  = NULL;
    ULONG_PTR tmp;
 
    //
    // compute system address range to look for
    //
    start = SystemAddress;
 
    //
    // Use interger overflow safe functions
    // end = ((PUCHAR)SystemAddress) + Length - 1;
    //
    hr = ULongPtrAdd((ULONG_PTR) start, Length, &tmp);
    FX_VERIFY_WITH_NAME(DRIVER(BadArgument, TODO), CHECK("Integer overflow occurred"
        "when computing register address range", SUCCEEDED(hr)),
        GetDriverGlobals()->Public.DriverName);
 
    end = (PVOID)(tmp - 1);
 
    //
    // check if range is in the register resource table
    //
    hr = E_INVALIDARG;
    for (i = 0; i < m_RegisterResourceTableSizeCe; i++) {
        entry = &m_RegisterResourceTable[i];
 
        if (start >= entry->m_StartSystemVa &&
            end <= entry->m_EndSystemVa) {
            hr = S_OK;
            break;
        }
    }
 
    //
    // compute the corresponding usermode address
    //
    if (SUCCEEDED(hr) && UsermodeAddress != NULL) {
        offset = ((PUCHAR)SystemAddress) - ((PUCHAR)entry->m_StartSystemVa);
        *UsermodeAddress = ((PUCHAR)entry->m_StartUsermodeVa) + offset;
    }
 
    return hr;
}

Referenced by if(), and LockResourceTable().

ValidateRegisterSystemBaseAddress()

HRESULT FxCmResList::ValidateRegisterSystemBaseAddress	(	__in PVOID	Address,
		__out PVOID *	UsermodeBaseAddress
	)

Definition at line 421 of file fxresourcecollectionum.cpp.

{
    ULONG i;
    FxRegisterResourceInfo* entry = NULL;
 
    LockResourceTable();
    for (i = 0; i < m_RegisterResourceTableSizeCe; i++) {
        entry = &m_RegisterResourceTable[i];
 
        if (Address == entry->m_StartSystemVa) {
 
            FX_VERIFY_WITH_NAME(INTERNAL, CHECK_NOT_NULL(entry->m_StartUsermodeVa),
                GetDriverGlobals()->Public.DriverName);
 
            *UsermodeBaseAddress = entry->m_StartUsermodeVa;
 
            UnlockResourceTable();
            return S_OK;
        }
    }
 
    UnlockResourceTable();
    return E_INVALIDARG;
}

ValidateResourceUnmap()

VOID FxCmResList::ValidateResourceUnmap

(

VOID

)

Definition at line 693 of file fxresourcecollectionum.cpp.

{
    ULONG i;
    FxRegisterResourceInfo* entry = NULL;
 
    //
    // make sure driver has unmapped its resources. No need to
    // acquire the resource validation table lock as this is called in
    // ReleaseHardware pnp callback and cannot race with another framework
    // pnp callback that updates this table (PrepareHardware) so no invalid
    // access. If a driver thread unmaps after ReleaseHardware return then also
    // it will be a valid access of table entry.
    //
 
    for (i = 0; i < m_RegisterResourceTableSizeCe; i++) {
        entry = &m_RegisterResourceTable[i];
 
        FX_VERIFY_WITH_NAME(DRIVER(BadArgument, TODO), CHECK("Driver did not unmap its "
            "register resources", (entry->m_StartSystemVa == NULL)), GetDriverGlobals()->Public.DriverName);
    }
}

Referenced by FxPkgPnp::PnpReleaseHardware().

Member Data Documentation

m_HasConnectionResources

BOOLEAN FxCmResList::m_HasConnectionResources

protected

Definition at line 367 of file fxresource.hpp.

Referenced by CheckForConnectionResources(), FxCmResList(), and HasConnectionResources().

m_PortResourceTable

FxPortResourceInfo* FxCmResList::m_PortResourceTable

protected

Definition at line 361 of file fxresource.hpp.

Referenced by BuildPortResourceTable(), DeletePortResourceTable(), FxCmResList(), and ValidatePortAddressRange().

m_PortResourceTableSizeCe

ULONG FxCmResList::m_PortResourceTableSizeCe

protected

Definition at line 362 of file fxresource.hpp.

Referenced by BuildPortResourceTable(), DeletePortResourceTable(), FxCmResList(), and ValidatePortAddressRange().

m_RegisterResourceTable

FxRegisterResourceInfo* FxCmResList::m_RegisterResourceTable

protected

Definition at line 355 of file fxresource.hpp.

Referenced by BuildRegisterResourceTable(), DeleteRegisterResourceTable(), FxCmResList(), ValidateAndClearMapping(), ValidateRegisterPhysicalAddressRange(), ValidateRegisterSystemAddressRange(), ValidateRegisterSystemBaseAddress(), and ValidateResourceUnmap().

m_RegisterResourceTableSizeCe

ULONG FxCmResList::m_RegisterResourceTableSizeCe

protected

Definition at line 356 of file fxresource.hpp.

Referenced by BuildRegisterResourceTable(), DeleteRegisterResourceTable(), FxCmResList(), ValidateAndClearMapping(), ValidateRegisterPhysicalAddressRange(), ValidateRegisterSystemAddressRange(), ValidateRegisterSystemBaseAddress(), and ValidateResourceUnmap().

m_ResourceTableLock

MxLock FxCmResList::m_ResourceTableLock

protected

Definition at line 372 of file fxresource.hpp.

Referenced by LockResourceTable(), and UnlockResourceTable().

---

The documentation for this class was generated from the following files:

• sdk/lib/drivers/wdf/shared/inc/private/common/fxresource.hpp
• sdk/lib/drivers/wdf/shared/support/fxresourcecollection.cpp
• sdk/lib/drivers/wdf/shared/support/km/fxresourcecollectionkm.cpp
• sdk/lib/drivers/wdf/shared/support/um/fxresourcecollectionum.cpp