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 - 2016, Intel Corporation. All rights reserved.<BR>
  12 This program and the accompanying materials
  13 are licensed and made available under the terms and conditions of the BSD License
  14 which accompanies this distribution.  The full text of the license may be found at
  15 http://opensource.org/licenses/bsd-license.php
  16
  17 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  18 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  19
  20 **/
  21
  22 #include "PciBus.h"
  23
  24 //
  25 // PCI Bus Driver Global Variables
  26 //
  27 EFI_DRIVER_BINDING_PROTOCOL                   gPciBusDriverBinding = {
  28   PciBusDriverBindingSupported,
  29   PciBusDriverBindingStart,
  30   PciBusDriverBindingStop,
  31   0xa,
  32   NULL,
  33   NULL
  34 };
  35
  36 EFI_HANDLE                                    gPciHostBrigeHandles[PCI_MAX_HOST_BRIDGE_NUM];
  37 EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_PROTOCOL  *gIncompatiblePciDeviceSupport = NULL;
  38 UINTN                                         gPciHostBridgeNumber = 0;
  39 BOOLEAN                                       gFullEnumeration     = TRUE;
  40 UINT64                                        gAllOne              = 0xFFFFFFFFFFFFFFFFULL;
  41 UINT64                                        gAllZero             = 0;
  42
  43 EFI_PCI_PLATFORM_PROTOCOL                     *gPciPlatformProtocol;
  44 EFI_PCI_OVERRIDE_PROTOCOL                     *gPciOverrideProtocol;
  45 EDKII_IOMMU_PROTOCOL                          *mIoMmuProtocol;
  46
  47
  48 GLOBAL_REMOVE_IF_UNREFERENCED EFI_PCI_HOTPLUG_REQUEST_PROTOCOL mPciHotPlugRequest = {
  49   PciHotPlugRequestNotify
  50 };
  51
  52 /**
  53   The Entry Point for PCI Bus module. The user code starts with this function.
  54
  55   Installs driver module protocols and. Creates virtual device handles for ConIn,
  56   ConOut, and StdErr. Installs Simple Text In protocol, Simple Text In Ex protocol,
  57   Simple Pointer protocol, Absolute Pointer protocol on those virtual handlers.
  58   Installs Graphics Output protocol and/or UGA Draw protocol if needed.
  59
  60   @param[in] ImageHandle    The firmware allocated handle for the EFI image.
  61   @param[in] SystemTable    A pointer to the EFI System Table.
  62
  63   @retval EFI_SUCCESS       The entry point is executed successfully.
  64   @retval other             Some error occurred when executing this entry point.
  65
  66 **/
  67 EFI_STATUS
  68 EFIAPI
  69 PciBusEntryPoint (
  70   IN EFI_HANDLE         ImageHandle,
  71   IN EFI_SYSTEM_TABLE   *SystemTable
  72   )
  73 {
  74   EFI_STATUS  Status;
  75   EFI_HANDLE  Handle;
  76
  77   //
  78   // Initializes PCI devices pool
  79   //
  80   InitializePciDevicePool ();
  81
  82   //
  83   // Install driver model protocol(s).
  84   //
  85   Status = EfiLibInstallDriverBindingComponentName2 (
  86              ImageHandle,
  87              SystemTable,
  88              &gPciBusDriverBinding,
  89              ImageHandle,
  90              &gPciBusComponentName,
  91              &gPciBusComponentName2
  92              );
  93   ASSERT_EFI_ERROR (Status);
  94
  95   if (FeaturePcdGet (PcdPciBusHotplugDeviceSupport)) {
  96     //
  97     // If Hot Plug is supported, install EFI PCI Hot Plug Request protocol.
  98     //
  99     Handle = NULL;
 100     Status = gBS->InstallProtocolInterface (
 101                     &Handle,
 102                     &gEfiPciHotPlugRequestProtocolGuid,
 103                     EFI_NATIVE_INTERFACE,
 104                     &mPciHotPlugRequest
 105                     );
 106   }
 107
 108   return Status;
 109 }
 110
 111 /**
 112   Test to see if this driver supports ControllerHandle. Any ControllerHandle
 113   than contains a gEfiPciRootBridgeIoProtocolGuid protocol can be supported.
 114
 115   @param  This                Protocol instance pointer.
 116   @param  Controller          Handle of device to test.
 117   @param  RemainingDevicePath Optional parameter use to pick a specific child
 118                               device to start.
 119
 120   @retval EFI_SUCCESS         This driver supports this device.
 121   @retval EFI_ALREADY_STARTED This driver is already running on this device.
 122   @retval other               This driver does not support this device.
 123
 124 **/
 125 EFI_STATUS
 126 EFIAPI
 127 PciBusDriverBindingSupported (
 128   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
 129   IN EFI_HANDLE                     Controller,
 130   IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
 131   )
 132 {
 133   EFI_STATUS                      Status;
 134   EFI_DEVICE_PATH_PROTOCOL        *ParentDevicePath;
 135   EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *PciRootBridgeIo;
 136   EFI_DEV_PATH_PTR                Node;
 137
 138   //
 139   // Check RemainingDevicePath validation
 140   //
 141   if (RemainingDevicePath != NULL) {
 142     //
 143     // Check if RemainingDevicePath is the End of Device Path Node,
 144     // if yes, go on checking other conditions
 145     //
 146     if (!IsDevicePathEnd (RemainingDevicePath)) {
 147       //
 148       // If RemainingDevicePath isn't the End of Device Path Node,
 149       // check its validation
 150       //
 151       Node.DevPath = RemainingDevicePath;
 152       if (Node.DevPath->Type != HARDWARE_DEVICE_PATH ||
 153           Node.DevPath->SubType != HW_PCI_DP         ||
 154           DevicePathNodeLength(Node.DevPath) != sizeof(PCI_DEVICE_PATH)) {
 155         return EFI_UNSUPPORTED;
 156       }
 157     }
 158   }
 159
 160   //
 161   // Check if Pci Root Bridge IO protocol is installed by platform
 162   //
 163   Status = gBS->OpenProtocol (
 164                   Controller,
 165                   &gEfiPciRootBridgeIoProtocolGuid,
 166                   (VOID **) &PciRootBridgeIo,
 167                   This->DriverBindingHandle,
 168                   Controller,
 169                   EFI_OPEN_PROTOCOL_BY_DRIVER
 170                   );
 171   if (Status == EFI_ALREADY_STARTED) {
 172     return EFI_SUCCESS;
 173   }
 174
 175   if (EFI_ERROR (Status)) {
 176     return Status;
 177   }
 178
 179   //
 180   // Close the I/O Abstraction(s) used to perform the supported test
 181   //
 182   gBS->CloseProtocol (
 183         Controller,
 184         &gEfiPciRootBridgeIoProtocolGuid,
 185         This->DriverBindingHandle,
 186         Controller
 187         );
 188
 189   //
 190   // Open the EFI Device Path protocol needed to perform the supported test
 191   //
 192   Status = gBS->OpenProtocol (
 193                   Controller,
 194                   &gEfiDevicePathProtocolGuid,
 195                   (VOID **) &ParentDevicePath,
 196                   This->DriverBindingHandle,
 197                   Controller,
 198                   EFI_OPEN_PROTOCOL_BY_DRIVER
 199                   );
 200   if (Status == EFI_ALREADY_STARTED) {
 201     return EFI_SUCCESS;
 202   }
 203
 204   if (EFI_ERROR (Status)) {
 205     return Status;
 206   }
 207
 208   //
 209   // Close protocol, don't use device path protocol in the Support() function
 210   //
 211   gBS->CloseProtocol (
 212         Controller,
 213         &gEfiDevicePathProtocolGuid,
 214         This->DriverBindingHandle,
 215         Controller
 216         );
 217
 218   return EFI_SUCCESS;
 219 }
 220
 221 /**
 222   Start this driver on ControllerHandle and enumerate Pci bus and start
 223   all device under PCI bus.
 224
 225   @param  This                 Protocol instance pointer.
 226   @param  Controller           Handle of device to bind driver to.
 227   @param  RemainingDevicePath  Optional parameter use to pick a specific child
 228                                device to start.
 229
 230   @retval EFI_SUCCESS          This driver is added to ControllerHandle.
 231   @retval EFI_ALREADY_STARTED  This driver is already running on ControllerHandle.
 232   @retval other                This driver does not support this device.
 233
 234 **/
 235 EFI_STATUS
 236 EFIAPI
 237 PciBusDriverBindingStart (
 238   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 239   IN EFI_HANDLE                   Controller,
 240   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
 241   )
 242 {
 243   EFI_STATUS                Status;
 244   EFI_DEVICE_PATH_PROTOCOL  *ParentDevicePath;
 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   //
 325   // Enumerate the entire host bridge
 326   // After enumeration, a database that records all the device information will be created
 327   //
 328   //
 329   Status = PciEnumerator (Controller);
 330
 331   if (EFI_ERROR (Status)) {
 332     return Status;
 333   }
 334
 335   //
 336   // Start all the devices under the entire host bridge.
 337   //
 338   StartPciDevices (Controller);
 339
 340   return EFI_SUCCESS;
 341 }
 342
 343 /**
 344   Stop this driver on ControllerHandle. Support stopping any child handles
 345   created by this driver.
 346
 347   @param  This              Protocol instance pointer.
 348   @param  Controller        Handle of device to stop driver on.
 349   @param  NumberOfChildren  Number of Handles in ChildHandleBuffer. If number of
 350                             children is zero stop the entire bus driver.
 351   @param  ChildHandleBuffer List of Child Handles to Stop.
 352
 353   @retval EFI_SUCCESS       This driver is removed ControllerHandle.
 354   @retval other             This driver was not removed from this device.
 355
 356 **/
 357 EFI_STATUS
 358 EFIAPI
 359 PciBusDriverBindingStop (
 360   IN  EFI_DRIVER_BINDING_PROTOCOL   *This,
 361   IN  EFI_HANDLE                    Controller,
 362   IN  UINTN                         NumberOfChildren,
 363   IN  EFI_HANDLE                    *ChildHandleBuffer
 364   )
 365 {
 366   EFI_STATUS  Status;
 367   UINTN       Index;
 368   BOOLEAN     AllChildrenStopped;
 369
 370   if (NumberOfChildren == 0) {
 371     //
 372     // Close the bus driver
 373     //
 374     gBS->CloseProtocol (
 375           Controller,
 376           &gEfiDevicePathProtocolGuid,
 377           This->DriverBindingHandle,
 378           Controller
 379           );
 380     gBS->CloseProtocol (
 381           Controller,
 382           &gEfiPciRootBridgeIoProtocolGuid,
 383           This->DriverBindingHandle,
 384           Controller
 385           );
 386
 387     DestroyRootBridgeByHandle (
 388       Controller
 389       );
 390
 391     return EFI_SUCCESS;
 392   }
 393
 394   //
 395   // Stop all the children
 396   //
 397
 398   AllChildrenStopped = TRUE;
 399
 400   for (Index = 0; Index < NumberOfChildren; Index++) {
 401
 402     //
 403     // De register all the pci device
 404     //
 405     Status = DeRegisterPciDevice (Controller, ChildHandleBuffer[Index]);
 406
 407     if (EFI_ERROR (Status)) {
 408       AllChildrenStopped = FALSE;
 409     }
 410   }
 411
 412   if (!AllChildrenStopped) {
 413     return EFI_DEVICE_ERROR;
 414   }
 415
 416   return EFI_SUCCESS;
 417 }
 418