bushndlr.c File Reference

#include <hal.h>
#include <debug.h>

Include dependency graph for bushndlr.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
PARRAY NTAPI	HalpAllocateArray (IN ULONG ArraySize)
VOID NTAPI	HalpGrowArray (IN PARRAY *CurrentArray, IN PARRAY *NewArray)
PBUS_HANDLER FASTCALL	HalpLookupHandler (IN PARRAY Array, IN ULONG Type, IN ULONG Number, IN BOOLEAN AddReference)
ULONG NTAPI	HalpNoBusData (IN PBUS_HANDLER BusHandler, IN PBUS_HANDLER RootHandler, IN ULONG SlotNumber, IN PVOID Buffer, IN ULONG Offset, IN ULONG Length)
NTSTATUS NTAPI	HalpNoAdjustResourceList (IN PBUS_HANDLER BusHandler, IN PBUS_HANDLER RootHandler, IN OUT PIO_RESOURCE_REQUIREMENTS_LIST *pResourceList)
NTSTATUS NTAPI	HalpNoAssignSlotResources (IN PBUS_HANDLER BusHandler, IN PBUS_HANDLER RootHandler, IN PUNICODE_STRING RegistryPath, IN PUNICODE_STRING DriverClassName OPTIONAL, IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT DeviceObject OPTIONAL, IN ULONG SlotNumber, IN OUT PCM_RESOURCE_LIST *AllocatedResources)
VOID FASTCALL	HaliReferenceBusHandler (IN PBUS_HANDLER Handler)
VOID FASTCALL	HaliDereferenceBusHandler (IN PBUS_HANDLER Handler)
PBUS_HANDLER FASTCALL	HaliHandlerForBus (IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber)
PBUS_HANDLER FASTCALL	HaliHandlerForConfigSpace (IN BUS_DATA_TYPE ConfigType, IN ULONG BusNumber)
PBUS_HANDLER FASTCALL	HaliReferenceHandlerForBus (IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber)
PBUS_HANDLER FASTCALL	HaliReferenceHandlerForConfigSpace (IN BUS_DATA_TYPE ConfigType, IN ULONG BusNumber)
PBUS_HANDLER NTAPI	HalpContextToBusHandler (IN ULONG_PTR ContextValue)
NTSTATUS NTAPI	HaliRegisterBusHandler (IN INTERFACE_TYPE InterfaceType, IN BUS_DATA_TYPE ConfigType, IN ULONG BusNumber, IN INTERFACE_TYPE ParentBusType, IN ULONG ParentBusNumber, IN ULONG ExtraData, IN PINSTALL_BUS_HANDLER InstallCallback, OUT PBUS_HANDLER *ReturnedBusHandler)
VOID NTAPI	HalpInitBusHandler (VOID)

Variables
KSPIN_LOCK	HalpBusDatabaseSpinLock
KEVENT	HalpBusDatabaseEvent
LIST_ENTRY	HalpAllBusHandlers
PARRAY	HalpBusTable
PARRAY	HalpConfigTable

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 12 of file bushndlr.c.

Function Documentation

HaliDereferenceBusHandler()

VOID FASTCALL HaliDereferenceBusHandler

(

IN PBUS_HANDLER

Handler

)

Definition at line 158 of file bushndlr.c.

{
    PHAL_BUS_HANDLER Bus;

    /* Find and dereference the bus handler */
    Bus = CONTAINING_RECORD(Handler, HAL_BUS_HANDLER, Handler);
    Bus->ReferenceCount--;
    ASSERT(Bus->ReferenceCount != 0);
}

Referenced by HalpInitBusHandler().

HaliHandlerForBus()

PBUS_HANDLER FASTCALL HaliHandlerForBus	(	IN INTERFACE_TYPE	InterfaceType,
		IN ULONG	BusNumber
	)

Definition at line 170 of file bushndlr.c.

{
    /* Lookup the interface in the bus table */
    return HalpLookupHandler(HalpBusTable, InterfaceType, BusNumber, FALSE);
}

Referenced by HaliRegisterBusHandler(), and HalpInitBusHandler().

HaliHandlerForConfigSpace()

PBUS_HANDLER FASTCALL HaliHandlerForConfigSpace	(	IN BUS_DATA_TYPE	ConfigType,
		IN ULONG	BusNumber
	)

Definition at line 179 of file bushndlr.c.

{
    /* Lookup the configuration in the configuration table */
    return HalpLookupHandler(HalpConfigTable, ConfigType, BusNumber, FALSE);
}

Referenced by HalpInitBusHandler().

HaliReferenceBusHandler()

VOID FASTCALL HaliReferenceBusHandler

(

IN PBUS_HANDLER

Handler

)

Definition at line 147 of file bushndlr.c.

{
    PHAL_BUS_HANDLER Bus;

    /* Find and reference the bus handler */
    Bus = CONTAINING_RECORD(Handler, HAL_BUS_HANDLER, Handler);
    Bus->ReferenceCount++;
}

Referenced by HalpInitBusHandler().

HaliReferenceHandlerForBus()

PBUS_HANDLER FASTCALL HaliReferenceHandlerForBus	(	IN INTERFACE_TYPE	InterfaceType,
		IN ULONG	BusNumber
	)

Definition at line 188 of file bushndlr.c.

{
    /* Lookup the interface in the bus table, and reference the handler */
    return HalpLookupHandler(HalpBusTable, InterfaceType, BusNumber, TRUE);
}

Referenced by HaliRegisterBusHandler(), and HalpInitBusHandler().

HaliReferenceHandlerForConfigSpace()

PBUS_HANDLER FASTCALL HaliReferenceHandlerForConfigSpace	(	IN BUS_DATA_TYPE	ConfigType,
		IN ULONG	BusNumber
	)

Definition at line 197 of file bushndlr.c.

{
    /* Lookup the configuration in the configuration table and add a reference */
    return HalpLookupHandler(HalpConfigTable, ConfigType, BusNumber, TRUE);
}

Referenced by HalGetBusDataByOffset(), and HalSetBusDataByOffset().

HaliRegisterBusHandler()

NTSTATUS NTAPI HaliRegisterBusHandler	(	IN INTERFACE_TYPE	InterfaceType,
		IN BUS_DATA_TYPE	ConfigType,
		IN ULONG	BusNumber,
		IN INTERFACE_TYPE	ParentBusType,
		IN ULONG	ParentBusNumber,
		IN ULONG	ExtraData,
		IN PINSTALL_BUS_HANDLER	InstallCallback,
		OUT PBUS_HANDLER *	ReturnedBusHandler
	)

Definition at line 242 of file bushndlr.c.

{
    PHAL_BUS_HANDLER Bus, OldHandler = NULL;
    PHAL_BUS_HANDLER* BusEntry;
    //PVOID CodeHandle;
    PARRAY InterfaceArray, InterfaceBusNumberArray, ConfigArray, ConfigBusNumberArray;
    PBUS_HANDLER ParentHandler;
    KIRQL OldIrql;
    NTSTATUS Status;

    /* Make sure we have a valid handler */
    ASSERT((InterfaceType != InterfaceTypeUndefined) ||
           (ConfigType != ConfigurationSpaceUndefined));

    /* Allocate the bus handler */
    Bus = ExAllocatePoolWithTag(NonPagedPool,
                                sizeof(HAL_BUS_HANDLER) + ExtraData,
                                TAG_BUS_HANDLER);
    if (!Bus) return STATUS_INSUFFICIENT_RESOURCES;

    /* Return the handler */
    *ReturnedBusHandler = &Bus->Handler;

    /* FIXME: Fix the kernel first. Don't page us out */
    //CodeHandle = MmLockPagableDataSection(&HaliRegisterBusHandler);

    /* Synchronize with anyone else */
    KeWaitForSingleObject(&HalpBusDatabaseEvent,
                          WrExecutive,
                          KernelMode,
                          FALSE,
                          NULL);

    /* Check for unknown/root bus */
    if (BusNumber == -1)
    {
        /* We must have an interface */
        ASSERT(InterfaceType != InterfaceTypeUndefined);

        /* Find the right bus */
        BusNumber = 0;
        while (HaliHandlerForBus(InterfaceType, BusNumber)) BusNumber++;
    }

    /* Allocate arrays for the handler */
    InterfaceArray = HalpAllocateArray(InterfaceType);
    InterfaceBusNumberArray = HalpAllocateArray(BusNumber);
    ConfigArray = HalpAllocateArray(ConfigType);
    ConfigBusNumberArray = HalpAllocateArray(BusNumber);

    /* Only proceed if all allocations succeeded */
    if ((InterfaceArray) && (InterfaceBusNumberArray) && (ConfigArray) && (ConfigBusNumberArray))
    {
        /* Find the parent handler if any */
        ParentHandler = HaliReferenceHandlerForBus(ParentBusType, ParentBusNumber);

        /* Initialize the handler */
        RtlZeroMemory(Bus, sizeof(HAL_BUS_HANDLER) + ExtraData);
        Bus->ReferenceCount = 1;

        /* Fill out bus data */
        Bus->Handler.BusNumber = BusNumber;
        Bus->Handler.InterfaceType = InterfaceType;
        Bus->Handler.ConfigurationType = ConfigType;
        Bus->Handler.ParentHandler = ParentHandler;

        /* Fill out dummy handlers */
        Bus->Handler.GetBusData = HalpNoBusData;
        Bus->Handler.SetBusData = HalpNoBusData;
        Bus->Handler.AdjustResourceList = HalpNoAdjustResourceList;
        Bus->Handler.AssignSlotResources = HalpNoAssignSlotResources;

        /* Make space for extra data */
        if (ExtraData) Bus->Handler.BusData = Bus + 1;

        /* Check for a parent handler */
        if (ParentHandler)
        {
            /* Inherit the parent routines */
            Bus->Handler.GetBusData = ParentHandler->GetBusData;
            Bus->Handler.SetBusData = ParentHandler->SetBusData;
            Bus->Handler.AdjustResourceList = ParentHandler->AdjustResourceList;
            Bus->Handler.AssignSlotResources = ParentHandler->AssignSlotResources;
            Bus->Handler.TranslateBusAddress = ParentHandler->TranslateBusAddress;
            Bus->Handler.GetInterruptVector = ParentHandler->GetInterruptVector;
        }

        /* We don't support this yet */
        ASSERT(!InstallCallback);

        /* Lock the buses */
        KeAcquireSpinLock(&HalpBusDatabaseSpinLock, &OldIrql);

        /* Make space for the interface */
        HalpGrowArray(&HalpBusTable, &InterfaceArray);

        /* Check if we really have an interface */
        if (InterfaceType != InterfaceTypeUndefined)
        {
            /* Make space for the association */
            HalpGrowArray((PARRAY*)&HalpBusTable->Element[InterfaceType],
                          &InterfaceBusNumberArray);

            /* Get the bus handler pointer */
            BusEntry = (PHAL_BUS_HANDLER*)&((PARRAY)HalpBusTable->Element[InterfaceType])->Element[BusNumber];

            /* Check if there was already a handler there, and set the new one */
            if (*BusEntry) OldHandler = *BusEntry;
            *BusEntry = Bus;
        }

        /* Now add a space for the configuration space */
        HalpGrowArray(&HalpConfigTable, &ConfigArray);

        /* Check if we really have one */
        if (ConfigType != ConfigurationSpaceUndefined)
        {
            /* Make space for this association */
            HalpGrowArray((PARRAY*)&HalpConfigTable->Element[ConfigType],
                          &ConfigBusNumberArray);

            /* Get the bus handler pointer */
            BusEntry = (PHAL_BUS_HANDLER*)&((PARRAY)HalpConfigTable->Element[ConfigType])->Element[BusNumber];
            if (*BusEntry)
            {
                /* Get the old entry, but make sure it's the same we had before */
                ASSERT((OldHandler == NULL) || (OldHandler == *BusEntry));
                OldHandler = *BusEntry;
            }

            /* Set the new entry */
            *BusEntry = Bus;
        }

        /* Link the adapter */
        InsertTailList(&HalpAllBusHandlers, &Bus->AllHandlers);

        /* Remove the old linkage */
        Bus = OldHandler;
        if (Bus) RemoveEntryList(&Bus->AllHandlers);

        /* Release the lock */
        KeReleaseSpinLock(&HalpBusDatabaseSpinLock, OldIrql);
        Status = STATUS_SUCCESS;
    }
    else
    {
        /* Fail */
        Status = STATUS_INSUFFICIENT_RESOURCES;
    }

    /* Signal the event */
    KeSetEvent(&HalpBusDatabaseEvent, 0, FALSE);

    /* FIXME: Fix the kernel first. Re-page the function */
    //MmUnlockPagableImageSection(CodeHandle);

    /* Free all allocations */
    if (Bus) ExFreePoolWithTag(Bus, TAG_BUS_HANDLER);
    if (InterfaceArray) ExFreePoolWithTag(InterfaceArray, TAG_BUS_HANDLER);
    if (InterfaceBusNumberArray) ExFreePoolWithTag(InterfaceBusNumberArray, TAG_BUS_HANDLER);
    if (ConfigArray) ExFreePoolWithTag(ConfigArray, TAG_BUS_HANDLER);
    if (ConfigBusNumberArray) ExFreePoolWithTag(ConfigBusNumberArray, TAG_BUS_HANDLER);

    /* And we're done */
    return Status;
}

Referenced by HalpInitBusHandler().

HalpAllocateArray()

PARRAY NTAPI HalpAllocateArray

(

IN ULONG

ArraySize

)

Definition at line 27 of file bushndlr.c.

{
    PARRAY Array;
    ULONG Size;

    /* Compute array size */
    if (ArraySize == MAXULONG) ArraySize = 0;
    Size = ArraySize * sizeof(PARRAY) + sizeof(ARRAY);

    /* Allocate the array */
    Array = ExAllocatePoolWithTag(NonPagedPool,
                                  Size,
                                  TAG_BUS_HANDLER);
    if (!Array) KeBugCheckEx(HAL_MEMORY_ALLOCATION, Size, 0, (ULONG_PTR)__FILE__, __LINE__);

    /* Initialize it */
    Array->ArraySize = ArraySize;
    RtlZeroMemory(Array->Element, sizeof(PVOID) * (ArraySize + 1));
    return Array;
}

Referenced by HaliRegisterBusHandler(), and HalpInitBusHandler().

HalpContextToBusHandler()

PBUS_HANDLER NTAPI HalpContextToBusHandler

(

IN ULONG_PTR

ContextValue

)

Definition at line 206 of file bushndlr.c.

{
    PLIST_ENTRY NextEntry;
    PHAL_BUS_HANDLER BusHandler, ThisHandler;

    /* Start lookup */
    NextEntry = HalpAllBusHandlers.Flink;
    ThisHandler = CONTAINING_RECORD(NextEntry, HAL_BUS_HANDLER, AllHandlers);
    if (ContextValue)
    {
        /* If the list is empty, quit */
        if (IsListEmpty(&HalpAllBusHandlers)) return NULL;

        /* Otherwise, scan the list */
        BusHandler = CONTAINING_RECORD(ContextValue, HAL_BUS_HANDLER, Handler);
        do
        {
            /* Check if we've reached the right one */
            ThisHandler = CONTAINING_RECORD(NextEntry, HAL_BUS_HANDLER, AllHandlers);
            if (ThisHandler == BusHandler) break;

            /* Try the next one */
            NextEntry = NextEntry->Flink;
        } while (NextEntry != &HalpAllBusHandlers);
    }

    /* If we looped back to the end, we didn't find anything */
    if (NextEntry == &HalpAllBusHandlers) return NULL;

    /* Otherwise return the handler */
    return &ThisHandler->Handler;
}

Referenced by HaliFindBusAddressTranslation().

HalpGrowArray()

VOID NTAPI HalpGrowArray	(	IN PARRAY *	CurrentArray,
		IN PARRAY *	NewArray
	)

Definition at line 50 of file bushndlr.c.

{
    PVOID Tmp;

    /* Check if the current array doesn't exist yet, or if it's smaller than the new one */
    if (!(*CurrentArray) || ((*NewArray)->ArraySize > (*CurrentArray)->ArraySize))
    {
        /* Does it exist (and can it fit?) */
        if (*CurrentArray)
        {
            /* Copy the current array into the new one */
            RtlCopyMemory(&(*NewArray)->Element,
                          &(*CurrentArray)->Element,
                          sizeof(PVOID) * ((*CurrentArray)->ArraySize + 1));
        }

        /* Swap the pointers (XOR swap would be more l33t) */
        Tmp = *CurrentArray;
        *CurrentArray = *NewArray;
        *NewArray = Tmp;
    }
}

Referenced by HaliRegisterBusHandler().

HalpInitBusHandler()

VOID NTAPI HalpInitBusHandler

(

VOID

)

Definition at line 420 of file bushndlr.c.

{
    /* Setup the bus lock */
    KeInitializeSpinLock(&HalpBusDatabaseSpinLock);

    /* Setup the bus event */
    KeInitializeEvent(&HalpBusDatabaseEvent, SynchronizationEvent, TRUE);

    /* Setup the bus configuration and bus table */
    HalpBusTable = HalpAllocateArray(0);
    HalpConfigTable = HalpAllocateArray(0);

    /* Setup the bus list */
    InitializeListHead(&HalpAllBusHandlers);

    /* Setup the HAL Dispatch routines */
#ifndef _MINIHAL_
    HalRegisterBusHandler = HaliRegisterBusHandler;
    HalHandlerForBus = HaliHandlerForBus;
    HalHandlerForConfigSpace = HaliHandlerForConfigSpace;
    HalReferenceHandlerForBus = HaliReferenceHandlerForBus;
    HalReferenceBusHandler = HaliReferenceBusHandler;
    HalDereferenceBusHandler = HaliDereferenceBusHandler;
#endif
    HalPciAssignSlotResources = HalpAssignSlotResources;
    HalPciTranslateBusAddress = HaliTranslateBusAddress; /* PCI Driver can override */
    if (!HalFindBusAddressTranslation) HalFindBusAddressTranslation = HaliFindBusAddressTranslation;
}

Referenced by HalpRegisterInternalBusHandlers(), and LoadBootDeviceDriver().

HalpLookupHandler()

PBUS_HANDLER FASTCALL HalpLookupHandler	(	IN PARRAY	Array,
		IN ULONG	Type,
		IN ULONG	Number,
		IN BOOLEAN	AddReference
	)

Definition at line 76 of file bushndlr.c.

{
    PHAL_BUS_HANDLER Bus;
    PBUS_HANDLER Handler = NULL;

    /* Make sure the entry exists */
    if (Array->ArraySize >= Type)
    {
        /* Retrieve it */
        Array = Array->Element[Type];

        /* Make sure the entry array exists */
        if ((Array) && (Array->ArraySize >= Number))
        {
            /* Retrieve the bus and its handler */
            Bus = Array->Element[Number];
            Handler = &Bus->Handler;

            /* Reference the handler if needed */
            if (AddReference) Bus->ReferenceCount++;
        }
    }

    /* Return the handler */
    return Handler;
}

Referenced by HaliHandlerForBus(), HaliHandlerForConfigSpace(), HaliReferenceHandlerForBus(), and HaliReferenceHandlerForConfigSpace().

HalpNoAdjustResourceList()

NTSTATUS NTAPI HalpNoAdjustResourceList	(	IN PBUS_HANDLER	BusHandler,
		IN PBUS_HANDLER	RootHandler,
		IN OUT PIO_RESOURCE_REQUIREMENTS_LIST *	pResourceList
	)

Definition at line 122 of file bushndlr.c.

{
    DPRINT1("STUB Adjustment\n");
    return STATUS_UNSUCCESSFUL;
}

Referenced by HaliRegisterBusHandler().

HalpNoAssignSlotResources()

NTSTATUS NTAPI HalpNoAssignSlotResources	(	IN PBUS_HANDLER	BusHandler,
		IN PBUS_HANDLER	RootHandler,
		IN PUNICODE_STRING	RegistryPath,
		IN PUNICODE_STRING DriverClassName	OPTIONAL,
		IN PDRIVER_OBJECT	DriverObject,
		IN PDEVICE_OBJECT DeviceObject	OPTIONAL,
		IN ULONG	SlotNumber,
		IN OUT PCM_RESOURCE_LIST *	AllocatedResources
	)

Definition at line 132 of file bushndlr.c.

{
    DPRINT1("STUB Assignment\n");
    return STATUS_NOT_SUPPORTED;
}

Referenced by HaliRegisterBusHandler().

HalpNoBusData()

ULONG NTAPI HalpNoBusData	(	IN PBUS_HANDLER	BusHandler,
		IN PBUS_HANDLER	RootHandler,
		IN ULONG	SlotNumber,
		IN PVOID	Buffer,
		IN ULONG	Offset,
		IN ULONG	Length
	)

Definition at line 108 of file bushndlr.c.

{
    /* Not implemented */
    DPRINT1("STUB GetSetBusData\n");
    return 0;
}

Referenced by HaliRegisterBusHandler(), and HalpRegisterInternalBusHandlers().

Variable Documentation

HalpAllBusHandlers

LIST_ENTRY HalpAllBusHandlers

Definition at line 19 of file bushndlr.c.

Referenced by HaliFindBusAddressTranslation(), HaliRegisterBusHandler(), HalpContextToBusHandler(), and HalpInitBusHandler().

HalpBusDatabaseEvent

KEVENT HalpBusDatabaseEvent

Definition at line 18 of file bushndlr.c.

Referenced by HaliRegisterBusHandler(), and HalpInitBusHandler().

HalpBusDatabaseSpinLock

KSPIN_LOCK HalpBusDatabaseSpinLock

Definition at line 17 of file bushndlr.c.

Referenced by HaliRegisterBusHandler(), and HalpInitBusHandler().

HalpBusTable

PARRAY HalpBusTable

Definition at line 20 of file bushndlr.c.

Referenced by HaliHandlerForBus(), HaliReferenceHandlerForBus(), HaliRegisterBusHandler(), and HalpInitBusHandler().

HalpConfigTable

PARRAY HalpConfigTable

Definition at line 21 of file bushndlr.c.

Referenced by HaliHandlerForConfigSpace(), HaliReferenceHandlerForConfigSpace(), HaliRegisterBusHandler(), and HalpInitBusHandler().