]> git.proxmox.com Git - mirror_edk2.git/blob - NetworkPkg/HttpBootDxe/HttpBootDxe.h
MdeModulePkg NvmExpressDxe: return error code in error path
[mirror_edk2.git] / NetworkPkg / HttpBootDxe / HttpBootDxe.h
1 /** @file
2 UEFI HTTP boot driver's private data structure and interfaces declaration.
3
4 Copyright (c) 2015 - 2017, Intel Corporation. All rights reserved.<BR>
5 (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>
6 This program and the accompanying materials are licensed and made available under
7 the terms and conditions of the BSD License that accompanies this distribution.
8 The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php.
10
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13
14 **/
15
16 #ifndef __EFI_HTTP_BOOT_DXE_H__
17 #define __EFI_HTTP_BOOT_DXE_H__
18
19 #include <Uefi.h>
20
21 #include <IndustryStandard/Http11.h>
22 #include <IndustryStandard/Dhcp.h>
23
24 //
25 // Libraries
26 //
27 #include <Library/UefiBootServicesTableLib.h>
28 #include <Library/UefiHiiServicesLib.h>
29 #include <Library/UefiRuntimeServicesTableLib.h>
30 #include <Library/MemoryAllocationLib.h>
31 #include <Library/BaseLib.h>
32 #include <Library/UefiLib.h>
33 #include <Library/DevicePathLib.h>
34 #include <Library/DebugLib.h>
35 #include <Library/NetLib.h>
36 #include <Library/HttpLib.h>
37 #include <Library/HiiLib.h>
38 #include <Library/PrintLib.h>
39 #include <Library/DpcLib.h>
40
41 //
42 // UEFI Driver Model Protocols
43 //
44 #include <Protocol/DriverBinding.h>
45 #include <Protocol/ComponentName2.h>
46 #include <Protocol/ComponentName.h>
47
48 //
49 // Consumed Protocols
50 //
51 #include <Protocol/ServiceBinding.h>
52 #include <Protocol/HiiConfigAccess.h>
53 #include <Protocol/NetworkInterfaceIdentifier.h>
54 #include <Protocol/Dhcp4.h>
55 #include <Protocol/Dhcp6.h>
56 #include <Protocol/Dns6.h>
57 #include <Protocol/Http.h>
58 #include <Protocol/Ip4Config2.h>
59 #include <Protocol/Ip6Config.h>
60 #include <Protocol/RamDisk.h>
61 #include <Protocol/AdapterInformation.h>
62
63 //
64 // Produced Protocols
65 //
66 #include <Protocol/LoadFile.h>
67 #include <Protocol/HttpBootCallback.h>
68
69 //
70 // Consumed Guids
71 //
72 #include <Guid/HttpBootConfigHii.h>
73
74 //
75 // Driver Version
76 //
77 #define HTTP_BOOT_DXE_VERSION 0xa
78
79 //
80 // Standard Media Types defined in
81 // http://www.iana.org/assignments/media-types
82 //
83 #define HTTP_CONTENT_TYPE_APP_EFI "application/efi"
84 #define HTTP_CONTENT_TYPE_APP_IMG "application/vnd.efi-img"
85 #define HTTP_CONTENT_TYPE_APP_ISO "application/vnd.efi-iso"
86
87 //
88 // Protocol instances
89 //
90 extern EFI_DRIVER_BINDING_PROTOCOL gHttpBootDxeDriverBinding;
91 extern EFI_COMPONENT_NAME2_PROTOCOL gHttpBootDxeComponentName2;
92 extern EFI_COMPONENT_NAME_PROTOCOL gHttpBootDxeComponentName;
93
94 //
95 // Private data structure
96 //
97 typedef struct _HTTP_BOOT_PRIVATE_DATA HTTP_BOOT_PRIVATE_DATA;
98 typedef struct _HTTP_BOOT_VIRTUAL_NIC HTTP_BOOT_VIRTUAL_NIC;
99
100 typedef enum {
101 ImageTypeEfi,
102 ImageTypeVirtualCd,
103 ImageTypeVirtualDisk,
104 ImageTypeMax
105 } HTTP_BOOT_IMAGE_TYPE;
106
107 //
108 // Include files with internal function prototypes
109 //
110 #include "HttpBootComponentName.h"
111 #include "HttpBootDhcp4.h"
112 #include "HttpBootDhcp6.h"
113 #include "HttpBootImpl.h"
114 #include "HttpBootSupport.h"
115 #include "HttpBootClient.h"
116 #include "HttpBootConfig.h"
117
118 typedef union {
119 HTTP_BOOT_DHCP4_PACKET_CACHE Dhcp4;
120 HTTP_BOOT_DHCP6_PACKET_CACHE Dhcp6;
121 } HTTP_BOOT_DHCP_PACKET_CACHE;
122
123 struct _HTTP_BOOT_VIRTUAL_NIC {
124 UINT32 Signature;
125 EFI_HANDLE Controller;
126 EFI_HANDLE ImageHandle;
127 EFI_LOAD_FILE_PROTOCOL LoadFile;
128 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
129 HTTP_BOOT_PRIVATE_DATA *Private;
130 };
131
132 #define HTTP_BOOT_PRIVATE_DATA_FROM_CALLBACK_INFO(Callback) \
133 CR ( \
134 Callback, \
135 HTTP_BOOT_PRIVATE_DATA, \
136 CallbackInfo, \
137 HTTP_BOOT_PRIVATE_DATA_SIGNATURE \
138 )
139
140 #define HTTP_BOOT_PRIVATE_DATA_FROM_CALLBACK_PROTOCOL(CallbackProtocol) \
141 CR ( \
142 CallbackProtocol, \
143 HTTP_BOOT_PRIVATE_DATA, \
144 LoadFileCallback, \
145 HTTP_BOOT_PRIVATE_DATA_SIGNATURE \
146 )
147
148 struct _HTTP_BOOT_PRIVATE_DATA {
149 UINT32 Signature;
150 EFI_HANDLE Controller;
151
152 HTTP_BOOT_VIRTUAL_NIC *Ip4Nic;
153 HTTP_BOOT_VIRTUAL_NIC *Ip6Nic;
154
155 //
156 // Cousumed children
157 //
158 EFI_HANDLE Ip6Child;
159 EFI_HANDLE Dhcp4Child;
160 EFI_HANDLE Dhcp6Child;
161 HTTP_IO HttpIo;
162 BOOLEAN HttpCreated;
163
164 //
165 // Consumed protocol
166 //
167 EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL *Nii;
168 EFI_IP6_PROTOCOL *Ip6;
169 EFI_IP4_CONFIG2_PROTOCOL *Ip4Config2;
170 EFI_IP6_CONFIG_PROTOCOL *Ip6Config;
171 EFI_DHCP4_PROTOCOL *Dhcp4;
172 EFI_DHCP6_PROTOCOL *Dhcp6;
173 EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath;
174
175
176 //
177 // Produced protocol
178 //
179 EFI_LOAD_FILE_PROTOCOL LoadFile;
180 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
181 UINT32 Id;
182 EFI_HTTP_BOOT_CALLBACK_PROTOCOL *HttpBootCallback;
183 EFI_HTTP_BOOT_CALLBACK_PROTOCOL LoadFileCallback;
184
185 //
186 // Data for the default HTTP Boot callback protocol
187 //
188 UINT64 FileSize;
189 UINT64 ReceivedSize;
190 UINT32 Percentage;
191
192 //
193 // HII callback info block
194 //
195 HTTP_BOOT_FORM_CALLBACK_INFO CallbackInfo;
196
197 //
198 // Mode data
199 //
200 BOOLEAN UsingIpv6;
201 BOOLEAN Started;
202 EFI_IP_ADDRESS StationIp;
203 EFI_IP_ADDRESS SubnetMask;
204 EFI_IP_ADDRESS GatewayIp;
205 EFI_IP_ADDRESS ServerIp;
206 UINT16 Port;
207 UINT32 DnsServerCount;
208 EFI_IP_ADDRESS *DnsServerIp;
209
210 //
211 // The URI string attempt to download through HTTP, may point to
212 // the memory in cached DHCP offer, or to the memory in FilePathUri.
213 //
214 CHAR8 *BootFileUri;
215 VOID *BootFileUriParser;
216 UINTN BootFileSize;
217 BOOLEAN NoGateway;
218 HTTP_BOOT_IMAGE_TYPE ImageType;
219
220 //
221 // URI string extracted from the input FilePath parameter.
222 //
223 CHAR8 *FilePathUri;
224 VOID *FilePathUriParser;
225
226 //
227 // Cached HTTP data
228 //
229 LIST_ENTRY CacheList;
230
231 //
232 // Cached DHCP offer
233 //
234 // OfferIndex records the index of DhcpOffer[] buffer, and OfferCount records the num of each type of offer.
235 //
236 // It supposed that
237 //
238 // OfferNum: 8
239 // OfferBuffer: [ProxyNameUri, DhcpNameUri, DhcpIpUri, ProxyNameUri, ProxyIpUri, DhcpOnly, DhcpIpUri, DhcpNameUriDns]
240 // (OfferBuffer is 0-based.)
241 //
242 // And assume that (DhcpIpUri is the first priority actually.)
243 //
244 // SelectIndex: 5
245 // SelectProxyType: HttpOfferTypeProxyIpUri
246 // (SelectIndex is 1-based, and 0 means no one is selected.)
247 //
248 // So it should be
249 //
250 // DhcpIpUri DhcpNameUriDns DhcpDns DhcpOnly ProxyNameUri ProxyIpUri DhcpNameUri
251 // OfferCount: [ 2, 1, 0, 1, 2, 1, 1]
252 //
253 // OfferIndex: {[ 2, 7, 0, 5, 0, *4, 1]
254 // [ 6, 0, 0, 0, 3, 0, 0]
255 // [ 0, 0, 0, 0, 0, 0, 0]
256 // ... ]}
257 // (OfferIndex is 0-based.)
258 //
259 //
260 UINT32 SelectIndex;
261 UINT32 SelectProxyType;
262 HTTP_BOOT_DHCP_PACKET_CACHE OfferBuffer[HTTP_BOOT_OFFER_MAX_NUM];
263 UINT32 OfferNum;
264 UINT32 OfferCount[HttpOfferTypeMax];
265 UINT32 OfferIndex[HttpOfferTypeMax][HTTP_BOOT_OFFER_MAX_NUM];
266 };
267
268 #define HTTP_BOOT_PRIVATE_DATA_SIGNATURE SIGNATURE_32 ('H', 'B', 'P', 'D')
269 #define HTTP_BOOT_VIRTUAL_NIC_SIGNATURE SIGNATURE_32 ('H', 'B', 'V', 'N')
270 #define HTTP_BOOT_PRIVATE_DATA_FROM_LOADFILE(a) CR (a, HTTP_BOOT_PRIVATE_DATA, LoadFile, HTTP_BOOT_PRIVATE_DATA_SIGNATURE)
271 #define HTTP_BOOT_PRIVATE_DATA_FROM_ID(a) CR (a, HTTP_BOOT_PRIVATE_DATA, Id, HTTP_BOOT_PRIVATE_DATA_SIGNATURE)
272 #define HTTP_BOOT_VIRTUAL_NIC_FROM_LOADFILE(a) CR (a, HTTP_BOOT_VIRTUAL_NIC, LoadFile, HTTP_BOOT_VIRTUAL_NIC_SIGNATURE)
273 extern EFI_LOAD_FILE_PROTOCOL gHttpBootDxeLoadFile;
274
275 /**
276 Tests to see if this driver supports a given controller. If a child device is provided,
277 it further tests to see if this driver supports creating a handle for the specified child device.
278
279 This function checks to see if the driver specified by This supports the device specified by
280 ControllerHandle. Drivers will typically use the device path attached to
281 ControllerHandle and/or the services from the bus I/O abstraction attached to
282 ControllerHandle to determine if the driver supports ControllerHandle. This function
283 may be called many times during platform initialization. In order to reduce boot times, the tests
284 performed by this function must be very small, and take as little time as possible to execute. This
285 function must not change the state of any hardware devices, and this function must be aware that the
286 device specified by ControllerHandle may already be managed by the same driver or a
287 different driver. This function must match its calls to AllocatePages() with FreePages(),
288 AllocatePool() with FreePool(), and OpenProtocol() with CloseProtocol().
289 Because ControllerHandle may have been previously started by the same driver, if a protocol is
290 already in the opened state, then it must not be closed with CloseProtocol(). This is required
291 to guarantee the state of ControllerHandle is not modified by this function.
292
293 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
294 @param[in] ControllerHandle The handle of the controller to test. This handle
295 must support a protocol interface that supplies
296 an I/O abstraction to the driver.
297 @param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This
298 parameter is ignored by device drivers, and is optional for bus
299 drivers. For bus drivers, if this parameter is not NULL, then
300 the bus driver must determine if the bus controller specified
301 by ControllerHandle and the child controller specified
302 by RemainingDevicePath are both supported by this
303 bus driver.
304
305 @retval EFI_SUCCESS The device specified by ControllerHandle and
306 RemainingDevicePath is supported by the driver specified by This.
307 @retval EFI_ALREADY_STARTED The device specified by ControllerHandle and
308 RemainingDevicePath is already being managed by the driver
309 specified by This.
310 @retval EFI_ACCESS_DENIED The device specified by ControllerHandle and
311 RemainingDevicePath is already being managed by a different
312 driver or an application that requires exclusive access.
313 Currently not implemented.
314 @retval EFI_UNSUPPORTED The device specified by ControllerHandle and
315 RemainingDevicePath is not supported by the driver specified by This.
316 **/
317 EFI_STATUS
318 EFIAPI
319 HttpBootIp4DxeDriverBindingSupported (
320 IN EFI_DRIVER_BINDING_PROTOCOL *This,
321 IN EFI_HANDLE ControllerHandle,
322 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
323 );
324
325 /**
326 Starts a device controller or a bus controller.
327
328 The Start() function is designed to be invoked from the EFI boot service ConnectController().
329 As a result, much of the error checking on the parameters to Start() has been moved into this
330 common boot service. It is legal to call Start() from other locations,
331 but the following calling restrictions must be followed, or the system behavior will not be deterministic.
332 1. ControllerHandle must be a valid EFI_HANDLE.
333 2. If RemainingDevicePath is not NULL, then it must be a pointer to a naturally aligned
334 EFI_DEVICE_PATH_PROTOCOL.
335 3. Prior to calling Start(), the Supported() function for the driver specified by This must
336 have been called with the same calling parameters, and Supported() must have returned EFI_SUCCESS.
337
338 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
339 @param[in] ControllerHandle The handle of the controller to start. This handle
340 must support a protocol interface that supplies
341 an I/O abstraction to the driver.
342 @param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This
343 parameter is ignored by device drivers, and is optional for bus
344 drivers. For a bus driver, if this parameter is NULL, then handles
345 for all the children of Controller are created by this driver.
346 If this parameter is not NULL and the first Device Path Node is
347 not the End of Device Path Node, then only the handle for the
348 child device specified by the first Device Path Node of
349 RemainingDevicePath is created by this driver.
350 If the first Device Path Node of RemainingDevicePath is
351 the End of Device Path Node, no child handle is created by this
352 driver.
353
354 @retval EFI_SUCCESS The device was started.
355 @retval EFI_DEVICE_ERROR The device could not be started due to a device error.Currently not implemented.
356 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources.
357 @retval Others The driver failded to start the device.
358
359 **/
360 EFI_STATUS
361 EFIAPI
362 HttpBootIp4DxeDriverBindingStart (
363 IN EFI_DRIVER_BINDING_PROTOCOL *This,
364 IN EFI_HANDLE ControllerHandle,
365 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
366 );
367
368 /**
369 Stops a device controller or a bus controller.
370
371 The Stop() function is designed to be invoked from the EFI boot service DisconnectController().
372 As a result, much of the error checking on the parameters to Stop() has been moved
373 into this common boot service. It is legal to call Stop() from other locations,
374 but the following calling restrictions must be followed, or the system behavior will not be deterministic.
375 1. ControllerHandle must be a valid EFI_HANDLE that was used on a previous call to this
376 same driver's Start() function.
377 2. The first NumberOfChildren handles of ChildHandleBuffer must all be a valid
378 EFI_HANDLE. In addition, all of these handles must have been created in this driver's
379 Start() function, and the Start() function must have called OpenProtocol() on
380 ControllerHandle with an Attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
381
382 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
383 @param[in] ControllerHandle A handle to the device being stopped. The handle must
384 support a bus specific I/O protocol for the driver
385 to use to stop the device.
386 @param[in] NumberOfChildren The number of child device handles in ChildHandleBuffer.
387 @param[in] ChildHandleBuffer An array of child handles to be freed. May be NULL
388 if NumberOfChildren is 0.
389
390 @retval EFI_SUCCESS The device was stopped.
391 @retval EFI_DEVICE_ERROR The device could not be stopped due to a device error.
392
393 **/
394 EFI_STATUS
395 EFIAPI
396 HttpBootIp4DxeDriverBindingStop (
397 IN EFI_DRIVER_BINDING_PROTOCOL *This,
398 IN EFI_HANDLE ControllerHandle,
399 IN UINTN NumberOfChildren,
400 IN EFI_HANDLE *ChildHandleBuffer OPTIONAL
401 );
402
403 /**
404 Tests to see if this driver supports a given controller. If a child device is provided,
405 it further tests to see if this driver supports creating a handle for the specified child device.
406
407 This function checks to see if the driver specified by This supports the device specified by
408 ControllerHandle. Drivers will typically use the device path attached to
409 ControllerHandle and/or the services from the bus I/O abstraction attached to
410 ControllerHandle to determine if the driver supports ControllerHandle. This function
411 may be called many times during platform initialization. In order to reduce boot times, the tests
412 performed by this function must be very small, and take as little time as possible to execute. This
413 function must not change the state of any hardware devices, and this function must be aware that the
414 device specified by ControllerHandle may already be managed by the same driver or a
415 different driver. This function must match its calls to AllocatePages() with FreePages(),
416 AllocatePool() with FreePool(), and OpenProtocol() with CloseProtocol().
417 Because ControllerHandle may have been previously started by the same driver, if a protocol is
418 already in the opened state, then it must not be closed with CloseProtocol(). This is required
419 to guarantee the state of ControllerHandle is not modified by this function.
420
421 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
422 @param[in] ControllerHandle The handle of the controller to test. This handle
423 must support a protocol interface that supplies
424 an I/O abstraction to the driver.
425 @param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This
426 parameter is ignored by device drivers, and is optional for bus
427 drivers. For bus drivers, if this parameter is not NULL, then
428 the bus driver must determine if the bus controller specified
429 by ControllerHandle and the child controller specified
430 by RemainingDevicePath are both supported by this
431 bus driver.
432
433 @retval EFI_SUCCESS The device specified by ControllerHandle and
434 RemainingDevicePath is supported by the driver specified by This.
435 @retval EFI_ALREADY_STARTED The device specified by ControllerHandle and
436 RemainingDevicePath is already being managed by the driver
437 specified by This.
438 @retval EFI_ACCESS_DENIED The device specified by ControllerHandle and
439 RemainingDevicePath is already being managed by a different
440 driver or an application that requires exclusive access.
441 Currently not implemented.
442 @retval EFI_UNSUPPORTED The device specified by ControllerHandle and
443 RemainingDevicePath is not supported by the driver specified by This.
444 **/
445 EFI_STATUS
446 EFIAPI
447 HttpBootIp6DxeDriverBindingSupported (
448 IN EFI_DRIVER_BINDING_PROTOCOL *This,
449 IN EFI_HANDLE ControllerHandle,
450 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
451 );
452
453 /**
454 Starts a device controller or a bus controller.
455
456 The Start() function is designed to be invoked from the EFI boot service ConnectController().
457 As a result, much of the error checking on the parameters to Start() has been moved into this
458 common boot service. It is legal to call Start() from other locations,
459 but the following calling restrictions must be followed, or the system behavior will not be deterministic.
460 1. ControllerHandle must be a valid EFI_HANDLE.
461 2. If RemainingDevicePath is not NULL, then it must be a pointer to a naturally aligned
462 EFI_DEVICE_PATH_PROTOCOL.
463 3. Prior to calling Start(), the Supported() function for the driver specified by This must
464 have been called with the same calling parameters, and Supported() must have returned EFI_SUCCESS.
465
466 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
467 @param[in] ControllerHandle The handle of the controller to start. This handle
468 must support a protocol interface that supplies
469 an I/O abstraction to the driver.
470 @param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This
471 parameter is ignored by device drivers, and is optional for bus
472 drivers. For a bus driver, if this parameter is NULL, then handles
473 for all the children of Controller are created by this driver.
474 If this parameter is not NULL and the first Device Path Node is
475 not the End of Device Path Node, then only the handle for the
476 child device specified by the first Device Path Node of
477 RemainingDevicePath is created by this driver.
478 If the first Device Path Node of RemainingDevicePath is
479 the End of Device Path Node, no child handle is created by this
480 driver.
481
482 @retval EFI_SUCCESS The device was started.
483 @retval EFI_DEVICE_ERROR The device could not be started due to a device error.Currently not implemented.
484 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources.
485 @retval Others The driver failded to start the device.
486
487 **/
488 EFI_STATUS
489 EFIAPI
490 HttpBootIp6DxeDriverBindingStart (
491 IN EFI_DRIVER_BINDING_PROTOCOL *This,
492 IN EFI_HANDLE ControllerHandle,
493 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
494 );
495
496 /**
497 Stops a device controller or a bus controller.
498
499 The Stop() function is designed to be invoked from the EFI boot service DisconnectController().
500 As a result, much of the error checking on the parameters to Stop() has been moved
501 into this common boot service. It is legal to call Stop() from other locations,
502 but the following calling restrictions must be followed, or the system behavior will not be deterministic.
503 1. ControllerHandle must be a valid EFI_HANDLE that was used on a previous call to this
504 same driver's Start() function.
505 2. The first NumberOfChildren handles of ChildHandleBuffer must all be a valid
506 EFI_HANDLE. In addition, all of these handles must have been created in this driver's
507 Start() function, and the Start() function must have called OpenProtocol() on
508 ControllerHandle with an Attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
509
510 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
511 @param[in] ControllerHandle A handle to the device being stopped. The handle must
512 support a bus specific I/O protocol for the driver
513 to use to stop the device.
514 @param[in] NumberOfChildren The number of child device handles in ChildHandleBuffer.
515 @param[in] ChildHandleBuffer An array of child handles to be freed. May be NULL
516 if NumberOfChildren is 0.
517
518 @retval EFI_SUCCESS The device was stopped.
519 @retval EFI_DEVICE_ERROR The device could not be stopped due to a device error.
520
521 **/
522 EFI_STATUS
523 EFIAPI
524 HttpBootIp6DxeDriverBindingStop (
525 IN EFI_DRIVER_BINDING_PROTOCOL *This,
526 IN EFI_HANDLE ControllerHandle,
527 IN UINTN NumberOfChildren,
528 IN EFI_HANDLE *ChildHandleBuffer OPTIONAL
529 );
530 #endif