reactos/hal/halx86/generic/legacy/bus/bushndlr.c

   1 /*
   2  * PROJECT:         ReactOS HAL
   3  * LICENSE:         GPL - See COPYING in the top level directory
   4  * FILE:            hal/halx86/generic/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
  17 KSPIN_LOCK HalpBusDatabaseSpinLock;
  18 KEVENT HalpBusDatabaseEvent;
  19 LIST_ENTRY HalpAllBusHandlers;
  20 PARRAY HalpBusTable;
  21 PARRAY HalpConfigTable;
  22
  23 /* PRIVATE FUNCTIONS **********************************************************/
  24
  25 PARRAY
  26 NTAPI
  27 HalpAllocateArray(IN ULONG ArraySize)
  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 */
  37     Array = ExAllocatePoolWithTag(NonPagedPool,
  38                                   Size,
  39                                   'BusH');
  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
  74 PBUS_HANDLER
  75 FASTCALL
  76 HalpLookupHandler(IN PARRAY Array,
  77                   IN ULONG Type,
  78                   IN ULONG Number,
  79                   IN BOOLEAN AddReference)
  80 {
  81     PHAL_BUS_HANDLER Bus;
  82     PBUS_HANDLER Handler = NULL;
  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
 108 HalpNoBusData(IN PBUS_HANDLER BusHandler,
 109               IN PBUS_HANDLER RootHandler,
 110               IN ULONG SlotNumber,
 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
 122 HalpNoAdjustResourceList(IN PBUS_HANDLER BusHandler,
 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
 132 HalpNoAssignSlotResources(IN PBUS_HANDLER BusHandler,
 133                           IN PBUS_HANDLER RootHandler,
 134                           IN PUNICODE_STRING RegistryPath,
 135                           IN PUNICODE_STRING DriverClassName OPTIONAL,
 136                           IN PDRIVER_OBJECT DriverObject,
 137                           IN PDEVICE_OBJECT DeviceObject OPTIONAL,
 138                           IN ULONG SlotNumber,
 139                           IN OUT PCM_RESOURCE_LIST *AllocatedResources)
 140 {
 141     DPRINT1("STUB Assignment\n");
 142     return STATUS_NOT_SUPPORTED;
 143 }
 144
 145 VOID
 146 FASTCALL
 147 HaliReferenceBusHandler(IN PBUS_HANDLER Handler)
 148 {
 149     PHAL_BUS_HANDLER Bus;
 150
 151     /* Find and reference the bus handler */
 152     Bus = CONTAINING_RECORD(Handler, HAL_BUS_HANDLER, Handler);
 153     Bus->ReferenceCount++;
 154 }
 155
 156 VOID
 157 FASTCALL
 158 HaliDereferenceBusHandler(IN PBUS_HANDLER Handler)
 159 {
 160     PHAL_BUS_HANDLER Bus;
 161
 162     /* Find and dereference the bus handler */
 163     Bus = CONTAINING_RECORD(Handler, HAL_BUS_HANDLER, Handler);
 164     Bus->ReferenceCount--;
 165     ASSERT(Bus->ReferenceCount != 0);
 166 }
 167
 168 PBUS_HANDLER
 169 FASTCALL
 170 HaliHandlerForBus(IN INTERFACE_TYPE InterfaceType,
 171                   IN ULONG BusNumber)
 172 {
 173     /* Lookup the interface in the bus table */
 174     return HalpLookupHandler(HalpBusTable, InterfaceType, BusNumber, FALSE);
 175 }
 176
 177 PBUS_HANDLER
 178 FASTCALL
 179 HaliHandlerForConfigSpace(IN BUS_DATA_TYPE ConfigType,
 180                           IN ULONG BusNumber)
 181 {
 182     /* Lookup the configuration in the configuration table */
 183     return HalpLookupHandler(HalpConfigTable, ConfigType, BusNumber, FALSE);
 184 }
 185
 186 PBUS_HANDLER
 187 FASTCALL
 188 HaliReferenceHandlerForBus(IN INTERFACE_TYPE InterfaceType,
 189                            IN ULONG BusNumber)
 190 {
 191     /* Lookup the interface in the bus table, and reference the handler */
 192     return HalpLookupHandler(HalpBusTable, InterfaceType, BusNumber, TRUE);
 193 }
 194
 195 PBUS_HANDLER
 196 FASTCALL
 197 HaliReferenceHandlerForConfigSpace(IN BUS_DATA_TYPE ConfigType,
 198                                    IN ULONG BusNumber)
 199 {
 200     /* Lookup the configuration in the configuration table and add a reference */
 201     return HalpLookupHandler(HalpConfigTable, ConfigType, BusNumber, TRUE);
 202 }
 203
 204 #ifndef _MINIHAL_
 205 NTSTATUS
 206 NTAPI
 207 HaliRegisterBusHandler(IN INTERFACE_TYPE InterfaceType,
 208                        IN BUS_DATA_TYPE ConfigType,
 209                        IN ULONG BusNumber,
 210                        IN INTERFACE_TYPE ParentBusType,
 211                        IN ULONG ParentBusNumber,
 212                        IN ULONG ExtraData,
 213                        IN PINSTALL_BUS_HANDLER InstallCallback,
 214                        OUT PBUS_HANDLER *ReturnedBusHandler)
 215 {
 216     PHAL_BUS_HANDLER Bus, OldHandler = NULL;
 217     PHAL_BUS_HANDLER* BusEntry;
 218     //PVOID CodeHandle;
 219     PARRAY InterfaceArray, InterfaceBusNumberArray, ConfigArray, ConfigBusNumberArray;
 220     PBUS_HANDLER ParentHandler;
 221     KIRQL OldIrql;
 222     NTSTATUS Status;
 223
 224     /* Make sure we have a valid handler */
 225     ASSERT((InterfaceType != InterfaceTypeUndefined) ||
 226            (ConfigType != ConfigurationSpaceUndefined));
 227
 228     /* Allocate the bus handler */
 229     Bus = ExAllocatePoolWithTag(NonPagedPool,
 230                                 sizeof(HAL_BUS_HANDLER) + ExtraData,
 231                                 'HsuB');
 232     if (!Bus) return STATUS_INSUFFICIENT_RESOURCES;
 233
 234     /* Return the handler */
 235     *ReturnedBusHandler = &Bus->Handler;
 236
 237     /* FIXME: Fix the kernel first. Don't page us out */
 238     //CodeHandle = MmLockPagableDataSection(&HaliRegisterBusHandler);
 239
 240     /* Synchronize with anyone else */
 241     KeWaitForSingleObject(&HalpBusDatabaseEvent,
 242                           WrExecutive,
 243                           KernelMode,
 244                           FALSE,
 245                           NULL);
 246
 247     /* Check for unknown/root bus */
 248     if (BusNumber == -1)
 249     {
 250         /* We must have an interface */
 251         ASSERT(InterfaceType != InterfaceTypeUndefined);
 252
 253         /* Find the right bus */
 254         BusNumber = 0;
 255         while (HaliHandlerForBus(InterfaceType, BusNumber)) BusNumber++;
 256     }
 257
 258     /* Allocate arrays for the handler */
 259     InterfaceArray = HalpAllocateArray(InterfaceType);
 260     InterfaceBusNumberArray = HalpAllocateArray(BusNumber);
 261     ConfigArray = HalpAllocateArray(ConfigType);
 262     ConfigBusNumberArray = HalpAllocateArray(BusNumber);
 263
 264     /* Only proceed if all allocations succeeded */
 265     if ((InterfaceArray) && (InterfaceBusNumberArray) && (ConfigArray) && (ConfigBusNumberArray))
 266     {
 267         /* Find the parent handler if any */
 268         ParentHandler = HaliReferenceHandlerForBus(ParentBusType, ParentBusNumber);
 269
 270         /* Initialize the handler */
 271         RtlZeroMemory(Bus, sizeof(HAL_BUS_HANDLER) + ExtraData);
 272         Bus->ReferenceCount = 1;
 273
 274         /* Fill out bus data */
 275         Bus->Handler.BusNumber = BusNumber;
 276         Bus->Handler.InterfaceType = InterfaceType;
 277         Bus->Handler.ConfigurationType = ConfigType;
 278         Bus->Handler.ParentHandler = ParentHandler;
 279
 280         /* Fill out dummy handlers */
 281         Bus->Handler.GetBusData = HalpNoBusData;
 282         Bus->Handler.SetBusData = HalpNoBusData;
 283         Bus->Handler.AdjustResourceList = HalpNoAdjustResourceList;
 284         Bus->Handler.AssignSlotResources = HalpNoAssignSlotResources;
 285
 286         /* Make space for extra data */
 287         if (ExtraData) Bus->Handler.BusData = Bus + 1;
 288
 289         /* Check for a parent handler */
 290         if (ParentHandler)
 291         {
 292             /* Inherit the parent routines */
 293             Bus->Handler.GetBusData = ParentHandler->GetBusData;
 294             Bus->Handler.SetBusData = ParentHandler->SetBusData;
 295             Bus->Handler.AdjustResourceList = ParentHandler->AdjustResourceList;
 296             Bus->Handler.AssignSlotResources = ParentHandler->AssignSlotResources;
 297             Bus->Handler.TranslateBusAddress = ParentHandler->TranslateBusAddress;
 298             Bus->Handler.GetInterruptVector = ParentHandler->GetInterruptVector;
 299         }
 300
 301         /* We don't support this yet */
 302         ASSERT(!InstallCallback);
 303
 304         /* Lock the buses */
 305         KeAcquireSpinLock(&HalpBusDatabaseSpinLock, &OldIrql);
 306
 307         /* Make space for the interface */
 308         HalpGrowArray(&HalpBusTable, &InterfaceArray);
 309
 310         /* Check if we really have an interface */
 311         if (InterfaceType != InterfaceTypeUndefined)
 312         {
 313             /* Make space for the association */
 314             HalpGrowArray((PARRAY*)&HalpBusTable->Element[InterfaceType],
 315                           &InterfaceBusNumberArray);
 316
 317             /* Get the bus handler pointer */
 318             BusEntry = (PHAL_BUS_HANDLER*)&((PARRAY)HalpBusTable->Element[InterfaceType])->Element[BusNumber];
 319
 320             /* Check if there was already a handler there, and set the new one */
 321             if (*BusEntry) OldHandler = *BusEntry;
 322             *BusEntry = Bus;
 323         }
 324
 325         /* Now add a space for the configuration space */
 326         HalpGrowArray(&HalpConfigTable, &ConfigArray);
 327
 328         /* Check if we really have one */
 329         if (ConfigType != ConfigurationSpaceUndefined)
 330         {
 331             /* Make space for this association */
 332             HalpGrowArray((PARRAY*)&HalpConfigTable->Element[ConfigType],
 333                           &ConfigBusNumberArray);
 334
 335             /* Get the bus handler pointer */
 336             BusEntry = (PHAL_BUS_HANDLER*)&((PARRAY)HalpConfigTable->Element[ConfigType])->Element[BusNumber];
 337             if (*BusEntry)
 338             {
 339                 /* Get the old entry, but make sure it's the same we had before */
 340                 ASSERT((OldHandler == NULL) || (OldHandler == *BusEntry));
 341                 OldHandler = *BusEntry;
 342             }
 343
 344             /* Set the new entry */
 345             *BusEntry = Bus;
 346         }
 347
 348         /* Link the adapter */
 349         InsertTailList(&HalpAllBusHandlers, &Bus->AllHandlers);
 350
 351         /* Remove the old linkage */
 352         Bus = OldHandler;
 353         if (Bus) RemoveEntryList(&Bus->AllHandlers);
 354
 355         /* Release the lock */
 356         KeReleaseSpinLock(&HalpBusDatabaseSpinLock, OldIrql);
 357         Status = STATUS_SUCCESS;
 358     }
 359     else
 360     {
 361         /* Fail */
 362         Status = STATUS_INSUFFICIENT_RESOURCES;
 363     }
 364
 365     /* Signal the event */
 366     KeSetEvent(&HalpBusDatabaseEvent, 0, FALSE);
 367
 368     /* FIXME: Fix the kernel first. Re-page the function */
 369     //MmUnlockPagableImageSection(CodeHandle);
 370
 371     /* Free all allocations */
 372     if (Bus) ExFreePool(Bus);
 373     if (InterfaceArray) ExFreePool(InterfaceArray);
 374     if (InterfaceBusNumberArray) ExFreePool(InterfaceBusNumberArray);
 375     if (ConfigArray) ExFreePool(ConfigArray);
 376     if (ConfigBusNumberArray) ExFreePool(ConfigBusNumberArray);
 377
 378     /* And we're done */
 379     return Status;
 380 }
 381 #endif
 382
 383 VOID
 384 NTAPI
 385 HalpInitBusHandler(VOID)
 386 {
 387     /* Setup the bus lock */
 388     KeInitializeSpinLock(&HalpBusDatabaseSpinLock);
 389
 390     /* Setup the bus event */
 391     KeInitializeEvent(&HalpBusDatabaseEvent, SynchronizationEvent, TRUE);
 392
 393     /* Setup the bus configuration and bus table */
 394     HalpBusTable = HalpAllocateArray(0);
 395     HalpConfigTable = HalpAllocateArray(0);
 396
 397     /* Setup the bus list */
 398     InitializeListHead(&HalpAllBusHandlers);
 399
 400     /* Setup the HAL Dispatch routines */
 401 #ifndef _MINIHAL_
 402     HalRegisterBusHandler = HaliRegisterBusHandler;
 403     HalHandlerForBus = HaliHandlerForBus;
 404     HalHandlerForConfigSpace = HaliHandlerForConfigSpace;
 405     HalReferenceHandlerForBus = HaliReferenceHandlerForBus;
 406     HalReferenceBusHandler = HaliReferenceBusHandler;
 407     HalDereferenceBusHandler = HaliDereferenceBusHandler;
 408 #endif
 409     HalPciAssignSlotResources = HalpAssignSlotResources;
 410     HalPciTranslateBusAddress = HaliTranslateBusAddress; /* PCI Driver can override */
 411     /* FIXME: Fix later */
 412 #if 0
 413     if (!HalFindBusAddressTranslation) HalFindBusAddressTranslation = HaliFindBusAddressTranslation;
 414 #else
 415     /* These should be written by the PCI driver later, but we give defaults */
 416     HalFindBusAddressTranslation = HalpFindBusAddressTranslation;
 417 #endif
 418 }
 419
 420 /* EOF */