ReactOS  0.4.14-dev-604-gcfdd483
bushndlr.c
Go to the documentation of this file.
1 /*
2  * PROJECT: ReactOS HAL
3  * LICENSE: GPL - See COPYING in the top level directory
4  * FILE: hal/halx86/legacy/bus/bushndlr.c
5  * PURPOSE: Generic HAL Bus Handler Support
6  * PROGRAMMERS: Stefan Ginsberg (stefan.ginsberg@reactos.org)
7  */
8 
9 /* INCLUDES *******************************************************************/
10 
11 #include <hal.h>
12 #define NDEBUG
13 #include <debug.h>
14 
15 /* GLOBALS ********************************************************************/
16 
22 
23 /* PRIVATE FUNCTIONS **********************************************************/
24 
25 PARRAY
26 NTAPI
28 {
29  PARRAY Array;
30  ULONG Size;
31 
32  /* Compute array size */
33  if (ArraySize == MAXULONG) ArraySize = 0;
34  Size = ArraySize * sizeof(PARRAY) + sizeof(ARRAY);
35 
36  /* Allocate the array */
38  Size,
40  if (!Array) KeBugCheckEx(HAL_MEMORY_ALLOCATION, Size, 0, (ULONG_PTR)__FILE__, __LINE__);
41 
42  /* Initialize it */
43  Array->ArraySize = ArraySize;
44  RtlZeroMemory(Array->Element, sizeof(PVOID) * (ArraySize + 1));
45  return Array;
46 }
47 
48 VOID
49 NTAPI
50 HalpGrowArray(IN PARRAY *CurrentArray,
51  IN PARRAY *NewArray)
52 {
53  PVOID Tmp;
54 
55  /* Check if the current array doesn't exist yet, or if it's smaller than the new one */
56  if (!(*CurrentArray) || ((*NewArray)->ArraySize > (*CurrentArray)->ArraySize))
57  {
58  /* Does it exist (and can it fit?) */
59  if (*CurrentArray)
60  {
61  /* Copy the current array into the new one */
62  RtlCopyMemory(&(*NewArray)->Element,
63  &(*CurrentArray)->Element,
64  sizeof(PVOID) * ((*CurrentArray)->ArraySize + 1));
65  }
66 
67  /* Swap the pointers (XOR swap would be more l33t) */
68  Tmp = *CurrentArray;
69  *CurrentArray = *NewArray;
70  *NewArray = Tmp;
71  }
72 }
73 
77  IN ULONG Type,
78  IN ULONG Number,
79  IN BOOLEAN AddReference)
80 {
81  PHAL_BUS_HANDLER Bus;
83 
84  /* Make sure the entry exists */
85  if (Array->ArraySize >= Type)
86  {
87  /* Retrieve it */
88  Array = Array->Element[Type];
89 
90  /* Make sure the entry array exists */
91  if ((Array) && (Array->ArraySize >= Number))
92  {
93  /* Retrieve the bus and its handler */
94  Bus = Array->Element[Number];
95  Handler = &Bus->Handler;
96 
97  /* Reference the handler if needed */
98  if (AddReference) Bus->ReferenceCount++;
99  }
100  }
101 
102  /* Return the handler */
103  return Handler;
104 }
105 
106 ULONG
107 NTAPI
109  IN PBUS_HANDLER RootHandler,
111  IN PVOID Buffer,
112  IN ULONG Offset,
113  IN ULONG Length)
114 {
115  /* Not implemented */
116  DPRINT1("STUB GetSetBusData\n");
117  return 0;
118 }
119 
120 NTSTATUS
121 NTAPI
123  IN PBUS_HANDLER RootHandler,
124  IN OUT PIO_RESOURCE_REQUIREMENTS_LIST *pResourceList)
125 {
126  DPRINT1("STUB Adjustment\n");
127  return STATUS_UNSUCCESSFUL;
128 }
129 
130 NTSTATUS
131 NTAPI
133  IN PBUS_HANDLER RootHandler,
140 {
141  DPRINT1("STUB Assignment\n");
142  return STATUS_NOT_SUPPORTED;
143 }
144 
145 VOID
146 FASTCALL
148 {
149  PHAL_BUS_HANDLER Bus;
150 
151  /* Find and reference the bus handler */
153  Bus->ReferenceCount++;
154 }
155 
156 VOID
157 FASTCALL
159 {
160  PHAL_BUS_HANDLER Bus;
161 
162  /* Find and dereference the bus handler */
164  Bus->ReferenceCount--;
165  ASSERT(Bus->ReferenceCount != 0);
166 }
167 
169 FASTCALL
172 {
173  /* Lookup the interface in the bus table */
174  return HalpLookupHandler(HalpBusTable, InterfaceType, BusNumber, FALSE);
175 }
176 
178 FASTCALL
181 {
182  /* Lookup the configuration in the configuration table */
183  return HalpLookupHandler(HalpConfigTable, ConfigType, BusNumber, FALSE);
184 }
185 
187 FASTCALL
190 {
191  /* Lookup the interface in the bus table, and reference the handler */
192  return HalpLookupHandler(HalpBusTable, InterfaceType, BusNumber, TRUE);
193 }
194 
196 FASTCALL
199 {
200  /* Lookup the configuration in the configuration table and add a reference */
201  return HalpLookupHandler(HalpConfigTable, ConfigType, BusNumber, TRUE);
202 }
203 
205 NTAPI
207 {
208  PLIST_ENTRY NextEntry;
209  PHAL_BUS_HANDLER BusHandler, ThisHandler;
210 
211  /* Start lookup */
212  NextEntry = HalpAllBusHandlers.Flink;
213  ThisHandler = CONTAINING_RECORD(NextEntry, HAL_BUS_HANDLER, AllHandlers);
214  if (ContextValue)
215  {
216  /* If the list is empty, quit */
217  if (IsListEmpty(&HalpAllBusHandlers)) return NULL;
218 
219  /* Otherwise, scan the list */
220  BusHandler = CONTAINING_RECORD(ContextValue, HAL_BUS_HANDLER, Handler);
221  do
222  {
223  /* Check if we've reached the right one */
224  ThisHandler = CONTAINING_RECORD(NextEntry, HAL_BUS_HANDLER, AllHandlers);
225  if (ThisHandler == BusHandler) break;
226 
227  /* Try the next one */
228  NextEntry = NextEntry->Flink;
229  } while (NextEntry != &HalpAllBusHandlers);
230  }
231 
232  /* If we looped back to the end, we didn't find anything */
233  if (NextEntry == &HalpAllBusHandlers) return NULL;
234 
235  /* Otherwise return the handler */
236  return &ThisHandler->Handler;
237 }
238 
239 #ifndef _MINIHAL_
240 NTSTATUS
241 NTAPI
243  IN BUS_DATA_TYPE ConfigType,
245  IN INTERFACE_TYPE ParentBusType,
246  IN ULONG ParentBusNumber,
247  IN ULONG ExtraData,
249  OUT PBUS_HANDLER *ReturnedBusHandler)
250 {
251  PHAL_BUS_HANDLER Bus, OldHandler = NULL;
252  PHAL_BUS_HANDLER* BusEntry;
253  //PVOID CodeHandle;
254  PARRAY InterfaceArray, InterfaceBusNumberArray, ConfigArray, ConfigBusNumberArray;
255  PBUS_HANDLER ParentHandler;
256  KIRQL OldIrql;
258 
259  /* Make sure we have a valid handler */
260  ASSERT((InterfaceType != InterfaceTypeUndefined) ||
261  (ConfigType != ConfigurationSpaceUndefined));
262 
263  /* Allocate the bus handler */
265  sizeof(HAL_BUS_HANDLER) + ExtraData,
267  if (!Bus) return STATUS_INSUFFICIENT_RESOURCES;
268 
269  /* Return the handler */
270  *ReturnedBusHandler = &Bus->Handler;
271 
272  /* FIXME: Fix the kernel first. Don't page us out */
273  //CodeHandle = MmLockPagableDataSection(&HaliRegisterBusHandler);
274 
275  /* Synchronize with anyone else */
277  WrExecutive,
278  KernelMode,
279  FALSE,
280  NULL);
281 
282  /* Check for unknown/root bus */
283  if (BusNumber == -1)
284  {
285  /* We must have an interface */
286  ASSERT(InterfaceType != InterfaceTypeUndefined);
287 
288  /* Find the right bus */
289  BusNumber = 0;
290  while (HaliHandlerForBus(InterfaceType, BusNumber)) BusNumber++;
291  }
292 
293  /* Allocate arrays for the handler */
294  InterfaceArray = HalpAllocateArray(InterfaceType);
295  InterfaceBusNumberArray = HalpAllocateArray(BusNumber);
296  ConfigArray = HalpAllocateArray(ConfigType);
297  ConfigBusNumberArray = HalpAllocateArray(BusNumber);
298 
299  /* Only proceed if all allocations succeeded */
300  if ((InterfaceArray) && (InterfaceBusNumberArray) && (ConfigArray) && (ConfigBusNumberArray))
301  {
302  /* Find the parent handler if any */
303  ParentHandler = HaliReferenceHandlerForBus(ParentBusType, ParentBusNumber);
304 
305  /* Initialize the handler */
306  RtlZeroMemory(Bus, sizeof(HAL_BUS_HANDLER) + ExtraData);
307  Bus->ReferenceCount = 1;
308 
309  /* Fill out bus data */
310  Bus->Handler.BusNumber = BusNumber;
311  Bus->Handler.InterfaceType = InterfaceType;
312  Bus->Handler.ConfigurationType = ConfigType;
313  Bus->Handler.ParentHandler = ParentHandler;
314 
315  /* Fill out dummy handlers */
320 
321  /* Make space for extra data */
322  if (ExtraData) Bus->Handler.BusData = Bus + 1;
323 
324  /* Check for a parent handler */
325  if (ParentHandler)
326  {
327  /* Inherit the parent routines */
328  Bus->Handler.GetBusData = ParentHandler->GetBusData;
329  Bus->Handler.SetBusData = ParentHandler->SetBusData;
330  Bus->Handler.AdjustResourceList = ParentHandler->AdjustResourceList;
331  Bus->Handler.AssignSlotResources = ParentHandler->AssignSlotResources;
332  Bus->Handler.TranslateBusAddress = ParentHandler->TranslateBusAddress;
333  Bus->Handler.GetInterruptVector = ParentHandler->GetInterruptVector;
334  }
335 
336  /* We don't support this yet */
338 
339  /* Lock the buses */
341 
342  /* Make space for the interface */
343  HalpGrowArray(&HalpBusTable, &InterfaceArray);
344 
345  /* Check if we really have an interface */
346  if (InterfaceType != InterfaceTypeUndefined)
347  {
348  /* Make space for the association */
349  HalpGrowArray((PARRAY*)&HalpBusTable->Element[InterfaceType],
350  &InterfaceBusNumberArray);
351 
352  /* Get the bus handler pointer */
353  BusEntry = (PHAL_BUS_HANDLER*)&((PARRAY)HalpBusTable->Element[InterfaceType])->Element[BusNumber];
354 
355  /* Check if there was already a handler there, and set the new one */
356  if (*BusEntry) OldHandler = *BusEntry;
357  *BusEntry = Bus;
358  }
359 
360  /* Now add a space for the configuration space */
361  HalpGrowArray(&HalpConfigTable, &ConfigArray);
362 
363  /* Check if we really have one */
364  if (ConfigType != ConfigurationSpaceUndefined)
365  {
366  /* Make space for this association */
368  &ConfigBusNumberArray);
369 
370  /* Get the bus handler pointer */
371  BusEntry = (PHAL_BUS_HANDLER*)&((PARRAY)HalpConfigTable->Element[ConfigType])->Element[BusNumber];
372  if (*BusEntry)
373  {
374  /* Get the old entry, but make sure it's the same we had before */
375  ASSERT((OldHandler == NULL) || (OldHandler == *BusEntry));
376  OldHandler = *BusEntry;
377  }
378 
379  /* Set the new entry */
380  *BusEntry = Bus;
381  }
382 
383  /* Link the adapter */
385 
386  /* Remove the old linkage */
387  Bus = OldHandler;
388  if (Bus) RemoveEntryList(&Bus->AllHandlers);
389 
390  /* Release the lock */
393  }
394  else
395  {
396  /* Fail */
398  }
399 
400  /* Signal the event */
402 
403  /* FIXME: Fix the kernel first. Re-page the function */
404  //MmUnlockPagableImageSection(CodeHandle);
405 
406  /* Free all allocations */
407  if (Bus) ExFreePoolWithTag(Bus, TAG_BUS_HANDLER);
408  if (InterfaceArray) ExFreePoolWithTag(InterfaceArray, TAG_BUS_HANDLER);
409  if (InterfaceBusNumberArray) ExFreePoolWithTag(InterfaceBusNumberArray, TAG_BUS_HANDLER);
410  if (ConfigArray) ExFreePoolWithTag(ConfigArray, TAG_BUS_HANDLER);
411  if (ConfigBusNumberArray) ExFreePoolWithTag(ConfigBusNumberArray, TAG_BUS_HANDLER);
412 
413  /* And we're done */
414  return Status;
415 }
416 #endif
417 
418 VOID
419 NTAPI
421 {
422  /* Setup the bus lock */
424 
425  /* Setup the bus event */
427 
428  /* Setup the bus configuration and bus table */
431 
432  /* Setup the bus list */
434 
435  /* Setup the HAL Dispatch routines */
436 #ifndef _MINIHAL_
443 #endif
445  HalPciTranslateBusAddress = HaliTranslateBusAddress; /* PCI Driver can override */
447 }
448 
449 /* EOF */
#define HalReferenceHandlerForBus
Definition: haltypes.h:286
#define HalRegisterBusHandler
Definition: halfuncs.h:38
PBUS_HANDLER FASTCALL HaliReferenceHandlerForConfigSpace(IN BUS_DATA_TYPE ConfigType, IN ULONG BusNumber)
Definition: bushndlr.c:197
#define IN
Definition: typedefs.h:38
BOOLEAN NTAPI HaliFindBusAddressTranslation(IN PHYSICAL_ADDRESS BusAddress, IN OUT PULONG AddressSpace, OUT PPHYSICAL_ADDRESS TranslatedAddress, IN OUT PULONG_PTR Context, IN BOOLEAN NextBus)
Definition: bussupp.c:1297
#define HalPciTranslateBusAddress
Definition: halfuncs.h:41
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
enum _INTERFACE_TYPE INTERFACE_TYPE
Type
Definition: Type.h:6
BUS_DATA_TYPE ConfigurationType
Definition: haltypes.h:225
_Inout_opt_ PDEVICE_OBJECT _Inout_opt_ PDEVICE_OBJECT _Inout_opt_ PDEVICE_OBJECT _Inout_opt_ PCM_RESOURCE_LIST * AllocatedResources
Definition: ndis.h:4640
VOID NTAPI HalpInitBusHandler(VOID)
Definition: bushndlr.c:420
enum _BUS_DATA_TYPE BUS_DATA_TYPE
PARRAY NTAPI HalpAllocateArray(IN ULONG ArraySize)
Definition: bushndlr.c:27
LONG NTSTATUS
Definition: precomp.h:26
NTSTATUS NTAPI HalpAssignSlotResources(IN PUNICODE_STRING RegistryPath, IN PUNICODE_STRING DriverClassName, IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT DeviceObject, IN INTERFACE_TYPE BusType, IN ULONG BusNumber, IN ULONG SlotNumber, IN OUT PCM_RESOURCE_LIST *AllocatedResources)
Definition: bus.c:39
#define InsertTailList(ListHead, Entry)
PARRAY HalpConfigTable
Definition: bushndlr.c:21
#define HalDereferenceBusHandler
Definition: haltypes.h:288
LONG NTAPI KeSetEvent(IN PKEVENT Event, IN KPRIORITY Increment, IN BOOLEAN Wait)
Definition: eventobj.c:159
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
#define FASTCALL
Definition: nt_native.h:50
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
_In_opt_ PUNICODE_STRING DriverClassName
Definition: halfuncs.h:156
PBUS_HANDLER FASTCALL HaliHandlerForBus(IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber)
Definition: bushndlr.c:170
uint32_t ULONG_PTR
Definition: typedefs.h:63
FORCEINLINE BOOLEAN RemoveEntryList(_In_ PLIST_ENTRY Entry)
Definition: rtlfuncs.h:105
struct _ARRAY * PARRAY
UCHAR KIRQL
Definition: env_spec_w32.h:591
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
PBUS_HANDLER FASTCALL HaliHandlerForConfigSpace(IN BUS_DATA_TYPE ConfigType, IN ULONG BusNumber)
Definition: bushndlr.c:179
ULONG NTAPI HalpNoBusData(IN PBUS_HANDLER BusHandler, IN PBUS_HANDLER RootHandler, IN ULONG SlotNumber, IN PVOID Buffer, IN ULONG Offset, IN ULONG Length)
Definition: bushndlr.c:108
VOID FASTCALL HaliDereferenceBusHandler(IN PBUS_HANDLER Handler)
Definition: bushndlr.c:158
#define TAG_BUS_HANDLER
Definition: hal.h:56
FORCEINLINE VOID KeInitializeSpinLock(_Out_ PKSPIN_LOCK SpinLock)
Definition: kefuncs.h:251
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
static PDRIVER_OBJECT DriverObject
Definition: template.c:42
PARRAY HalpBusTable
Definition: bushndlr.c:20
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: bushndlr.c:242
Definition: bufpool.h:45
#define HalHandlerForConfigSpace
Definition: halfuncs.h:36
struct _BUS_HANDLER * ParentHandler
Definition: haltypes.h:228
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
_In_opt_ PUNICODE_STRING _In_ PDRIVER_OBJECT _In_ PDEVICE_OBJECT _In_ INTERFACE_TYPE _In_ ULONG BusNumber
Definition: halfuncs.h:156
BOOLEAN NTAPI HaliTranslateBusAddress(IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber, IN PHYSICAL_ADDRESS BusAddress, IN OUT PULONG AddressSpace, OUT PPHYSICAL_ADDRESS TranslatedAddress)
Definition: bussupp.c:1371
struct _LIST_ENTRY * Flink
Definition: typedefs.h:119
PBUS_HANDLER NTAPI HalpContextToBusHandler(IN ULONG_PTR ContextValue)
Definition: bushndlr.c:206
ULONG BusNumber
Definition: haltypes.h:226
#define KeAcquireSpinLock(sl, irql)
Definition: env_spec_w32.h:609
PTRANSLATEBUSADDRESS TranslateBusAddress
Definition: haltypes.h:238
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
_In_opt_ PUNICODE_STRING _In_ PDRIVER_OBJECT _In_ PDEVICE_OBJECT _In_ INTERFACE_TYPE _In_ ULONG _In_ ULONG SlotNumber
Definition: halfuncs.h:156
PASSIGNSLOTRESOURCES AssignSlotResources
Definition: haltypes.h:236
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:803
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: bushndlr.c:132
PBUS_HANDLER FASTCALL HalpLookupHandler(IN PARRAY Array, IN ULONG Type, IN ULONG Number, IN BOOLEAN AddReference)
Definition: bushndlr.c:76
NTSTATUS NTAPI HalpNoAdjustResourceList(IN PBUS_HANDLER BusHandler, IN PBUS_HANDLER RootHandler, IN OUT PIO_RESOURCE_REQUIREMENTS_LIST *pResourceList)
Definition: bushndlr.c:122
Definition: typedefs.h:117
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
_In_opt_ PENTER_STATE_SYSTEM_HANDLER _In_opt_ PVOID _In_ LONG _In_opt_ LONG volatile * Number
Definition: ntpoapi.h:204
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn BOOLEAN Physical UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER Handler
Definition: acpixf.h:668
KSPIN_LOCK HalpBusDatabaseSpinLock
Definition: bushndlr.c:17
Status
Definition: gdiplustypes.h:24
#define MAXULONG
Definition: typedefs.h:250
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
ULONG ArraySize
Definition: bus.h:266
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
BUS_HANDLER Handler
Definition: bus.h:274
PVOID Element[ANYSIZE_ARRAY]
Definition: bus.h:267
#define HalFindBusAddressTranslation
Definition: halfuncs.h:44
LIST_ENTRY HalpAllBusHandlers
Definition: bushndlr.c:19
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
ULONG KSPIN_LOCK
Definition: env_spec_w32.h:72
PGETSETBUSDATA SetBusData
Definition: haltypes.h:234
PGETINTERRUPTVECTOR GetInterruptVector
Definition: haltypes.h:237
KEVENT HalpBusDatabaseEvent
Definition: bushndlr.c:18
#define KeReleaseSpinLock(sl, irql)
Definition: env_spec_w32.h:627
#define DPRINT1
Definition: precomp.h:8
Definition: shimeng.h:15
#define OUT
Definition: typedefs.h:39
VOID FASTCALL HaliReferenceBusHandler(IN PBUS_HANDLER Handler)
Definition: bushndlr.c:147
NTSTATUS(NTAPI * PINSTALL_BUS_HANDLER)(_In_ PBUS_HANDLER Bus)
Definition: haltypes.h:54
INTERFACE_TYPE InterfaceType
Definition: haltypes.h:224
PBUS_HANDLER FASTCALL HaliReferenceHandlerForBus(IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber)
Definition: bushndlr.c:188
#define STATUS_NOT_SUPPORTED
Definition: ntstatus.h:409
unsigned int ULONG
Definition: retypes.h:1
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
#define HalPciAssignSlotResources
Definition: halfuncs.h:42
_In_ PUNICODE_STRING RegistryPath
Definition: wmip.h:27
PGETSETBUSDATA GetBusData
Definition: haltypes.h:233
PADJUSTRESOURCELIST AdjustResourceList
Definition: haltypes.h:235
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
VOID NTAPI HalpGrowArray(IN PARRAY *CurrentArray, IN PARRAY *NewArray)
Definition: bushndlr.c:50
LIST_ENTRY AllHandlers
Definition: bus.h:272
return STATUS_SUCCESS
Definition: btrfs.c:2938
#define HalHandlerForBus
Definition: halfuncs.h:35
#define HalReferenceBusHandler
Definition: haltypes.h:287
ULONG ReferenceCount
Definition: bus.h:273
PVOID BusData
Definition: haltypes.h:229
VOID NTAPI KeBugCheckEx(_In_ ULONG BugCheckCode, _In_ ULONG_PTR BugCheckParameter1, _In_ ULONG_PTR BugCheckParameter2, _In_ ULONG_PTR BugCheckParameter3, _In_ ULONG_PTR BugCheckParameter4)
Definition: rtlcompat.c:107
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68