MdeModulePkg/PciBus: Add IOMMU support.
[mirror_edk2.git] / 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