MdeModulePkg/Bus/Pci/PciBusDxe/PciBus.c

   1 /** @file
   2   Driver Binding functions for PCI Bus module.
   3
   4   Single PCI bus driver instance will manager all PCI Root Bridges in one EFI based firmware,
   5   since all PCI Root Bridges' resources need to be managed together.
   6   Supported() function will try to get PCI Root Bridge IO Protocol.
   7   Start() function will get PCI Host Bridge Resource Allocation Protocol to manage all
   8   PCI Root Bridges. So it means platform needs install PCI Root Bridge IO protocol for each
   9   PCI Root Bus and install PCI Host Bridge Resource Allocation Protocol.
  10
  11 Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
  12 SPDX-License-Identifier: BSD-2-Clause-Patent
  13
  14 **/
  15
  16 #include "PciBus.h"
  17
  18 //
  19 // PCI Bus Driver Global Variables
  20 //
  21 EFI_DRIVER_BINDING_PROTOCOL                   gPciBusDriverBinding = {
  22   PciBusDriverBindingSupported,
  23   PciBusDriverBindingStart,
  24   PciBusDriverBindingStop,
  25   0xa,
  26   NULL,
  27   NULL
  28 };
  29
  30 EFI_HANDLE                                    gPciHostBrigeHandles[PCI_MAX_HOST_BRIDGE_NUM];
  31 EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_PROTOCOL  *gIncompatiblePciDeviceSupport = NULL;
  32 UINTN                                         gPciHostBridgeNumber = 0;
  33 BOOLEAN                                       gFullEnumeration     = TRUE;
  34 UINT64                                        gAllOne              = 0xFFFFFFFFFFFFFFFFULL;
  35 UINT64                                        gAllZero             = 0;
  36
  37 EFI_PCI_PLATFORM_PROTOCOL                     *gPciPlatformProtocol;
  38 EFI_PCI_OVERRIDE_PROTOCOL                     *gPciOverrideProtocol;
  39 EDKII_IOMMU_PROTOCOL                          *mIoMmuProtocol;
  40
  41
  42 GLOBAL_REMOVE_IF_UNREFERENCED EFI_PCI_HOTPLUG_REQUEST_PROTOCOL mPciHotPlugRequest = {
  43   PciHotPlugRequestNotify
  44 };
  45
  46 /**
  47   The Entry Point for PCI Bus module. The user code starts with this function.
  48
  49   Installs driver module protocols and. Creates virtual device handles for ConIn,
  50   ConOut, and StdErr. Installs Simple Text In protocol, Simple Text In Ex protocol,
  51   Simple Pointer protocol, Absolute Pointer protocol on those virtual handlers.
  52   Installs Graphics Output protocol and/or UGA Draw protocol if needed.
  53
  54   @param[in] ImageHandle    The firmware allocated handle for the EFI image.
  55   @param[in] SystemTable    A pointer to the EFI System Table.
  56
  57   @retval EFI_SUCCESS       The entry point is executed successfully.
  58   @retval other             Some error occurred when executing this entry point.
  59
  60 **/
  61 EFI_STATUS
  62 EFIAPI
  63 PciBusEntryPoint (
  64   IN EFI_HANDLE         ImageHandle,
  65   IN EFI_SYSTEM_TABLE   *SystemTable
  66   )
  67 {
  68   EFI_STATUS  Status;
  69   EFI_HANDLE  Handle;
  70
  71   //
  72   // Initializes PCI devices pool
  73   //
  74   InitializePciDevicePool ();
  75
  76   //
  77   // Install driver model protocol(s).
  78   //
  79   Status = EfiLibInstallDriverBindingComponentName2 (
  80              ImageHandle,
  81              SystemTable,
  82              &gPciBusDriverBinding,
  83              ImageHandle,
  84              &gPciBusComponentName,
  85              &gPciBusComponentName2
  86              );
  87   ASSERT_EFI_ERROR (Status);
  88
  89   if (FeaturePcdGet (PcdPciBusHotplugDeviceSupport)) {
  90     //
  91     // If Hot Plug is supported, install EFI PCI Hot Plug Request protocol.
  92     //
  93     Handle = NULL;
  94     Status = gBS->InstallProtocolInterface (
  95                     &Handle,
  96                     &gEfiPciHotPlugRequestProtocolGuid,
  97                     EFI_NATIVE_INTERFACE,
  98                     &mPciHotPlugRequest
  99                     );
 100   }
 101
 102   return Status;
 103 }
 104
 105 /**
 106   Test to see if this driver supports ControllerHandle. Any ControllerHandle
 107   than contains a gEfiPciRootBridgeIoProtocolGuid protocol can be supported.
 108
 109   @param  This                Protocol instance pointer.
 110   @param  Controller          Handle of device to test.
 111   @param  RemainingDevicePath Optional parameter use to pick a specific child
 112                               device to start.
 113
 114   @retval EFI_SUCCESS         This driver supports this device.
 115   @retval EFI_ALREADY_STARTED This driver is already running on this device.
 116   @retval other               This driver does not support this device.
 117
 118 **/
 119 EFI_STATUS
 120 EFIAPI
 121 PciBusDriverBindingSupported (
 122   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
 123   IN EFI_HANDLE                     Controller,
 124   IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
 125   )
 126 {
 127   EFI_STATUS                      Status;
 128   EFI_DEVICE_PATH_PROTOCOL        *ParentDevicePath;
 129   EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *PciRootBridgeIo;
 130   EFI_DEV_PATH_PTR                Node;
 131
 132   //
 133   // Check RemainingDevicePath validation
 134   //
 135   if (RemainingDevicePath != NULL) {
 136     //
 137     // Check if RemainingDevicePath is the End of Device Path Node,
 138     // if yes, go on checking other conditions
 139     //
 140     if (!IsDevicePathEnd (RemainingDevicePath)) {
 141       //
 142       // If RemainingDevicePath isn't the End of Device Path Node,
 143       // check its validation
 144       //
 145       Node.DevPath = RemainingDevicePath;
 146       if (Node.DevPath->Type != HARDWARE_DEVICE_PATH ||
 147           Node.DevPath->SubType != HW_PCI_DP         ||
 148           DevicePathNodeLength(Node.DevPath) != sizeof(PCI_DEVICE_PATH)) {
 149         return EFI_UNSUPPORTED;
 150       }
 151     }
 152   }
 153
 154   //
 155   // Check if Pci Root Bridge IO protocol is installed by platform
 156   //
 157   Status = gBS->OpenProtocol (
 158                   Controller,
 159                   &gEfiPciRootBridgeIoProtocolGuid,
 160                   (VOID **) &PciRootBridgeIo,
 161                   This->DriverBindingHandle,
 162                   Controller,
 163                   EFI_OPEN_PROTOCOL_BY_DRIVER
 164                   );
 165   if (Status == EFI_ALREADY_STARTED) {
 166     return EFI_SUCCESS;
 167   }
 168
 169   if (EFI_ERROR (Status)) {
 170     return Status;
 171   }
 172
 173   //
 174   // Close the I/O Abstraction(s) used to perform the supported test
 175   //
 176   gBS->CloseProtocol (
 177         Controller,
 178         &gEfiPciRootBridgeIoProtocolGuid,
 179         This->DriverBindingHandle,
 180         Controller
 181         );
 182
 183   //
 184   // Open the EFI Device Path protocol needed to perform the supported test
 185   //
 186   Status = gBS->OpenProtocol (
 187                   Controller,
 188                   &gEfiDevicePathProtocolGuid,
 189                   (VOID **) &ParentDevicePath,
 190                   This->DriverBindingHandle,
 191                   Controller,
 192                   EFI_OPEN_PROTOCOL_BY_DRIVER
 193                   );
 194   if (Status == EFI_ALREADY_STARTED) {
 195     return EFI_SUCCESS;
 196   }
 197
 198   if (EFI_ERROR (Status)) {
 199     return Status;
 200   }
 201
 202   //
 203   // Close protocol, don't use device path protocol in the Support() function
 204   //
 205   gBS->CloseProtocol (
 206         Controller,
 207         &gEfiDevicePathProtocolGuid,
 208         This->DriverBindingHandle,
 209         Controller
 210         );
 211
 212   return EFI_SUCCESS;
 213 }
 214
 215 /**
 216   Start this driver on ControllerHandle and enumerate Pci bus and start
 217   all device under PCI bus.
 218
 219   @param  This                 Protocol instance pointer.
 220   @param  Controller           Handle of device to bind driver to.
 221   @param  RemainingDevicePath  Optional parameter use to pick a specific child
 222                                device to start.
 223
 224   @retval EFI_SUCCESS          This driver is added to ControllerHandle.
 225   @retval EFI_ALREADY_STARTED  This driver is already running on ControllerHandle.
 226   @retval other                This driver does not support this device.
 227
 228 **/
 229 EFI_STATUS
 230 EFIAPI
 231 PciBusDriverBindingStart (
 232   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 233   IN EFI_HANDLE                   Controller,
 234   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
 235   )
 236 {
 237   EFI_STATUS                      Status;
 238   EFI_DEVICE_PATH_PROTOCOL        *ParentDevicePath;
 239   EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *PciRootBridgeIo;
 240
 241   //
 242   // Initialize PciRootBridgeIo to suppress incorrect compiler warning.
 243   //
 244   PciRootBridgeIo = NULL;
 245
 246   //
 247   // Check RemainingDevicePath validation
 248   //
 249   if (RemainingDevicePath != NULL) {
 250     //
 251     // Check if RemainingDevicePath is the End of Device Path Node,
 252     // if yes, return EFI_SUCCESS
 253     //
 254     if (IsDevicePathEnd (RemainingDevicePath)) {
 255       return EFI_SUCCESS;
 256     }
 257   }
 258
 259   gBS->LocateProtocol (
 260          &gEfiIncompatiblePciDeviceSupportProtocolGuid,
 261          NULL,
 262          (VOID **) &gIncompatiblePciDeviceSupport
 263          );
 264
 265   //
 266   // If PCI Platform protocol is available, get it now.
 267   // If the platform implements this, it must be installed before BDS phase
 268   //
 269   gPciPlatformProtocol = NULL;
 270   gBS->LocateProtocol (
 271         &gEfiPciPlatformProtocolGuid,
 272         NULL,
 273         (VOID **) &gPciPlatformProtocol
 274         );
 275
 276   //
 277   // If PCI Platform protocol doesn't exist, try to Pci Override Protocol.
 278   //
 279   if (gPciPlatformProtocol == NULL) {
 280     gPciOverrideProtocol = NULL;
 281     gBS->LocateProtocol (
 282           &gEfiPciOverrideProtocolGuid,
 283           NULL,
 284           (VOID **) &gPciOverrideProtocol
 285           );
 286   }
 287
 288   if (mIoMmuProtocol == NULL) {
 289     gBS->LocateProtocol (
 290           &gEdkiiIoMmuProtocolGuid,
 291           NULL,
 292           (VOID **) &mIoMmuProtocol
 293           );
 294   }
 295
 296   if (PcdGetBool (PcdPciDisableBusEnumeration)) {
 297     gFullEnumeration = FALSE;
 298   } else {
 299     gFullEnumeration = (BOOLEAN) ((SearchHostBridgeHandle (Controller) ? FALSE : TRUE));
 300   }
 301
 302   //
 303   // Open Device Path Protocol for PCI root bridge
 304   //
 305   Status = gBS->OpenProtocol (
 306                   Controller,
 307                   &gEfiDevicePathProtocolGuid,
 308                   (VOID **) &ParentDevicePath,
 309                   This->DriverBindingHandle,
 310                   Controller,
 311                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 312                   );
 313   ASSERT_EFI_ERROR (Status);
 314
 315   //
 316   // Report Status Code to indicate PCI bus starts
 317   //
 318   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 319     EFI_PROGRESS_CODE,
 320     (EFI_IO_BUS_PCI | EFI_IOB_PC_INIT),
 321     ParentDevicePath
 322     );
 323
 324   Status = EFI_SUCCESS;
 325   //
 326   // Enumerate the entire host bridge
 327   // After enumeration, a database that records all the device information will be created
 328   //
 329   //
 330   if (gFullEnumeration) {
 331     //
 332     // Get the rootbridge Io protocol to find the host bridge handle
 333     //
 334     Status = gBS->OpenProtocol (
 335                     Controller,
 336                     &gEfiPciRootBridgeIoProtocolGuid,
 337                     (VOID **) &PciRootBridgeIo,
 338                     gPciBusDriverBinding.DriverBindingHandle,
 339                     Controller,
 340                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 341                     );
 342
 343     if (!EFI_ERROR (Status)) {
 344       Status = PciEnumerator (Controller, PciRootBridgeIo->ParentHandle);
 345     }
 346   } else {
 347     //
 348     // If PCI bus has already done the full enumeration, never do it again
 349     //
 350     Status = PciEnumeratorLight (Controller);
 351   }
 352
 353   if (EFI_ERROR (Status)) {
 354     return Status;
 355   }
 356
 357   //
 358   // Start all the devices under the entire host bridge.
 359   //
 360   StartPciDevices (Controller);
 361
 362   if (gFullEnumeration) {
 363     gFullEnumeration = FALSE;
 364
 365     Status = gBS->InstallProtocolInterface (
 366                     &PciRootBridgeIo->ParentHandle,
 367                     &gEfiPciEnumerationCompleteProtocolGuid,
 368                     EFI_NATIVE_INTERFACE,
 369                     NULL
 370                     );
 371     ASSERT_EFI_ERROR (Status);
 372   }
 373
 374   return Status;
 375 }
 376
 377 /**
 378   Stop this driver on ControllerHandle. Support stopping any child handles
 379   created by this driver.
 380
 381   @param  This              Protocol instance pointer.
 382   @param  Controller        Handle of device to stop driver on.
 383   @param  NumberOfChildren  Number of Handles in ChildHandleBuffer. If number of
 384                             children is zero stop the entire bus driver.
 385   @param  ChildHandleBuffer List of Child Handles to Stop.
 386
 387   @retval EFI_SUCCESS       This driver is removed ControllerHandle.
 388   @retval other             This driver was not removed from this device.
 389
 390 **/
 391 EFI_STATUS
 392 EFIAPI
 393 PciBusDriverBindingStop (
 394   IN  EFI_DRIVER_BINDING_PROTOCOL   *This,
 395   IN  EFI_HANDLE                    Controller,
 396   IN  UINTN                         NumberOfChildren,
 397   IN  EFI_HANDLE                    *ChildHandleBuffer
 398   )
 399 {
 400   EFI_STATUS  Status;
 401   UINTN       Index;
 402   BOOLEAN     AllChildrenStopped;
 403
 404   if (NumberOfChildren == 0) {
 405     //
 406     // Close the bus driver
 407     //
 408     gBS->CloseProtocol (
 409           Controller,
 410           &gEfiDevicePathProtocolGuid,
 411           This->DriverBindingHandle,
 412           Controller
 413           );
 414     gBS->CloseProtocol (
 415           Controller,
 416           &gEfiPciRootBridgeIoProtocolGuid,
 417           This->DriverBindingHandle,
 418           Controller
 419           );
 420
 421     DestroyRootBridgeByHandle (
 422       Controller
 423       );
 424
 425     return EFI_SUCCESS;
 426   }
 427
 428   //
 429   // Stop all the children
 430   //
 431
 432   AllChildrenStopped = TRUE;
 433
 434   for (Index = 0; Index < NumberOfChildren; Index++) {
 435
 436     //
 437     // De register all the pci device
 438     //
 439     Status = DeRegisterPciDevice (Controller, ChildHandleBuffer[Index]);
 440
 441     if (EFI_ERROR (Status)) {
 442       AllChildrenStopped = FALSE;
 443     }
 444   }
 445
 446   if (!AllChildrenStopped) {
 447     return EFI_DEVICE_ERROR;
 448   }
 449
 450   return EFI_SUCCESS;
 451 }
 452