1 /** @file
2
3 This driver produces Virtio Device Protocol instances for Virtio PCI devices.
4
5 Copyright (C) 2012, Red Hat, Inc.
6 Copyright (c) 2012 - 2016, Intel Corporation. All rights reserved.<BR>
7 Copyright (C) 2013, ARM Ltd.
8 Copyright (C) 2017, AMD Inc, All rights reserved.<BR>
9
10 SPDX-License-Identifier: BSD-2-Clause-Patent
11
12 **/
13
14 #include <IndustryStandard/Pci.h>
15 #include <Library/BaseMemoryLib.h>
16 #include <Library/DebugLib.h>
17 #include <Library/MemoryAllocationLib.h>
18 #include <Library/UefiBootServicesTableLib.h>
19 #include <Library/UefiLib.h>
20
21 #include "VirtioPciDevice.h"
22
23 STATIC VIRTIO_DEVICE_PROTOCOL mDeviceProtocolTemplate = {
24 0, // Revision
25 0, // SubSystemDeviceId
26 VirtioPciGetDeviceFeatures, // GetDeviceFeatures
27 VirtioPciSetGuestFeatures, // SetGuestFeatures
28 VirtioPciSetQueueAddress, // SetQueueAddress
29 VirtioPciSetQueueSel, // SetQueueSel
30 VirtioPciSetQueueNotify, // SetQueueNotify
31 VirtioPciSetQueueAlignment, // SetQueueAlignment
32 VirtioPciSetPageSize, // SetPageSize
33 VirtioPciGetQueueSize, // GetQueueNumMax
34 VirtioPciSetQueueSize, // SetQueueNum
35 VirtioPciGetDeviceStatus, // GetDeviceStatus
36 VirtioPciSetDeviceStatus, // SetDeviceStatus
37 VirtioPciDeviceWrite, // WriteDevice
38 VirtioPciDeviceRead, // ReadDevice
39 VirtioPciAllocateSharedPages, // AllocateSharedPages
40 VirtioPciFreeSharedPages, // FreeSharedPages
41 VirtioPciMapSharedBuffer, // MapSharedBuffer
42 VirtioPciUnmapSharedBuffer, // UnmapSharedBuffer
43 };
44
45 /**
46
47 Read a word from Region 0 of the device specified by PciIo.
48
49 Region 0 must be an iomem region. This is an internal function for the PCI
50 implementation of the protocol.
51
52 @param[in] Dev Virtio PCI device.
53
54 @param[in] FieldOffset Source offset.
55
56 @param[in] FieldSize Source field size, must be in { 1, 2, 4, 8 }.
57
58 @param[in] BufferSize Number of bytes available in the target buffer. Must
59 equal FieldSize.
60
61 @param[out] Buffer Target buffer.
62
63
64 @return Status code returned by PciIo->Io.Read().
65
66 **/
67 EFI_STATUS
68 EFIAPI
VirtioPciIoRead(IN VIRTIO_PCI_DEVICE * Dev,IN UINTN FieldOffset,IN UINTN FieldSize,IN UINTN BufferSize,OUT VOID * Buffer)69 VirtioPciIoRead (
70 IN VIRTIO_PCI_DEVICE *Dev,
71 IN UINTN FieldOffset,
72 IN UINTN FieldSize,
73 IN UINTN BufferSize,
74 OUT VOID *Buffer
75 )
76 {
77 UINTN Count;
78 EFI_PCI_IO_PROTOCOL_WIDTH Width;
79 EFI_PCI_IO_PROTOCOL *PciIo;
80
81 ASSERT (FieldSize == BufferSize);
82
83 PciIo = Dev->PciIo;
84 Count = 1;
85
86 switch (FieldSize) {
87 case 1:
88 Width = EfiPciIoWidthUint8;
89 break;
90
91 case 2:
92 Width = EfiPciIoWidthUint16;
93 break;
94
95 case 8:
96 //
97 // The 64bit PCI I/O is broken down into two 32bit reads to prevent
98 // any alignment or width issues.
99 // The UEFI spec says under EFI_PCI_IO_PROTOCOL.Io.Write():
100 //
101 // The I/O operations are carried out exactly as requested. The caller
102 // is responsible for any alignment and I/O width issues which the
103 // bus, device, platform, or type of I/O might require. For example on
104 // some platforms, width requests of EfiPciIoWidthUint64 do not work.
105 //
106 Count = 2;
107
108 //
109 // fall through
110 //
111 case 4:
112 Width = EfiPciIoWidthUint32;
113 break;
114
115 default:
116 ASSERT (FALSE);
117 return EFI_INVALID_PARAMETER;
118 }
119
120 return PciIo->Io.Read (
121 PciIo,
122 Width,
123 PCI_BAR_IDX0,
124 FieldOffset,
125 Count,
126 Buffer
127 );
128 }
129
130 /**
131
132 Write a word into Region 0 of the device specified by PciIo.
133
134 Region 0 must be an iomem region. This is an internal function for the PCI
135 implementation of the protocol.
136
137 @param[in] Dev Virtio PCI device.
138
139 @param[in] FieldOffset Destination offset.
140
141 @param[in] FieldSize Destination field size, must be in { 1, 2, 4, 8 }.
142
143 @param[in] Value Little endian value to write, converted to UINT64.
144 The least significant FieldSize bytes will be used.
145
146
147 @return Status code returned by PciIo->Io.Write().
148
149 **/
150 EFI_STATUS
151 EFIAPI
VirtioPciIoWrite(IN VIRTIO_PCI_DEVICE * Dev,IN UINTN FieldOffset,IN UINTN FieldSize,IN UINT64 Value)152 VirtioPciIoWrite (
153 IN VIRTIO_PCI_DEVICE *Dev,
154 IN UINTN FieldOffset,
155 IN UINTN FieldSize,
156 IN UINT64 Value
157 )
158 {
159 UINTN Count;
160 EFI_PCI_IO_PROTOCOL_WIDTH Width;
161 EFI_PCI_IO_PROTOCOL *PciIo;
162
163 PciIo = Dev->PciIo;
164 Count = 1;
165
166 switch (FieldSize) {
167 case 1:
168 Width = EfiPciIoWidthUint8;
169 break;
170
171 case 2:
172 Width = EfiPciIoWidthUint16;
173 break;
174
175 case 8:
176 //
177 // The 64bit PCI I/O is broken down into two 32bit writes to prevent
178 // any alignment or width issues.
179 // The UEFI spec says under EFI_PCI_IO_PROTOCOL.Io.Write():
180 //
181 // The I/O operations are carried out exactly as requested. The caller
182 // is responsible for any alignment and I/O width issues which the
183 // bus, device, platform, or type of I/O might require. For example on
184 // some platforms, width requests of EfiPciIoWidthUint64 do not work
185 //
186 Count = Count * 2;
187
188 //
189 // fall through
190 //
191 case 4:
192 Width = EfiPciIoWidthUint32;
193 break;
194
195 default:
196 ASSERT (FALSE);
197 return EFI_INVALID_PARAMETER;
198 }
199
200 return PciIo->Io.Write (
201 PciIo,
202 Width,
203 PCI_BAR_IDX0,
204 FieldOffset,
205 Count,
206 &Value
207 );
208 }
209
210 /**
211
212 Device probe function for this driver.
213
214 The DXE core calls this function for any given device in order to see if the
215 driver can drive the device.
216
217 @param[in] This The EFI_DRIVER_BINDING_PROTOCOL object
218 incorporating this driver (independently of
219 any device).
220
221 @param[in] DeviceHandle The device to probe.
222
223 @param[in] RemainingDevicePath Relevant only for bus drivers, ignored.
224
225
226 @retval EFI_SUCCESS The driver supports the device being probed.
227
228 @retval EFI_UNSUPPORTED Based on virtio-pci discovery, we do not support
229 the device.
230
231 @return Error codes from the OpenProtocol() boot service or
232 the PciIo protocol.
233
234 **/
235 STATIC
236 EFI_STATUS
237 EFIAPI
VirtioPciDeviceBindingSupported(IN EFI_DRIVER_BINDING_PROTOCOL * This,IN EFI_HANDLE DeviceHandle,IN EFI_DEVICE_PATH_PROTOCOL * RemainingDevicePath)238 VirtioPciDeviceBindingSupported (
239 IN EFI_DRIVER_BINDING_PROTOCOL *This,
240 IN EFI_HANDLE DeviceHandle,
241 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
242 )
243 {
244 EFI_STATUS Status;
245 EFI_PCI_IO_PROTOCOL *PciIo;
246 PCI_TYPE00 Pci;
247
248 //
249 // Attempt to open the device with the PciIo set of interfaces. On success,
250 // the protocol is "instantiated" for the PCI device. Covers duplicate open
251 // attempts (EFI_ALREADY_STARTED).
252 //
253 Status = gBS->OpenProtocol (
254 DeviceHandle, // candidate device
255 &gEfiPciIoProtocolGuid, // for generic PCI access
256 (VOID **)&PciIo, // handle to instantiate
257 This->DriverBindingHandle, // requestor driver identity
258 DeviceHandle, // ControllerHandle, according to
259 // the UEFI Driver Model
260 EFI_OPEN_PROTOCOL_BY_DRIVER // get exclusive PciIo access to
261 // the device; to be released
262 );
263 if (EFI_ERROR (Status)) {
264 return Status;
265 }
266
267 //
268 // Read entire PCI configuration header for more extensive check ahead.
269 //
270 Status = PciIo->Pci.Read (
271 PciIo, // (protocol, device)
272 // handle
273 EfiPciIoWidthUint32, // access width & copy
274 // mode
275 0, // Offset
276 sizeof Pci / sizeof (UINT32), // Count
277 &Pci // target buffer
278 );
279
280 if (Status == EFI_SUCCESS) {
281 //
282 // virtio-0.9.5, 2.1 PCI Discovery
283 //
284 if ((Pci.Hdr.VendorId == VIRTIO_VENDOR_ID) &&
285 (Pci.Hdr.DeviceId >= 0x1000) &&
286 (Pci.Hdr.DeviceId <= 0x103F) &&
287 (Pci.Hdr.RevisionID == 0x00)) {
288 Status = EFI_SUCCESS;
289 } else {
290 Status = EFI_UNSUPPORTED;
291 }
292 }
293
294 //
295 // We needed PCI IO access only transitorily, to see whether we support the
296 // device or not.
297 //
298 gBS->CloseProtocol (DeviceHandle, &gEfiPciIoProtocolGuid,
299 This->DriverBindingHandle, DeviceHandle);
300
301 return Status;
302 }
303
304 /**
305
306 Initialize the VirtIo PCI Device
307
308 @param[in, out] Dev The driver instance to configure. The caller is
309 responsible for Device->PciIo's validity (ie. working IO
310 access to the underlying virtio-pci device).
311
312 @retval EFI_SUCCESS Setup complete.
313
314 @retval EFI_UNSUPPORTED The underlying IO device doesn't support the
315 provided address offset and read size.
316
317 @return Error codes from PciIo->Pci.Read().
318
319 **/
320 STATIC
321 EFI_STATUS
322 EFIAPI
VirtioPciInit(IN OUT VIRTIO_PCI_DEVICE * Device)323 VirtioPciInit (
324 IN OUT VIRTIO_PCI_DEVICE *Device
325 )
326 {
327 EFI_STATUS Status;
328 EFI_PCI_IO_PROTOCOL *PciIo;
329 PCI_TYPE00 Pci;
330
331 ASSERT (Device != NULL);
332 PciIo = Device->PciIo;
333 ASSERT (PciIo != NULL);
334 ASSERT (PciIo->Pci.Read != NULL);
335
336 Status = PciIo->Pci.Read (
337 PciIo, // (protocol, device)
338 // handle
339 EfiPciIoWidthUint32, // access width & copy
340 // mode
341 0, // Offset
342 sizeof (Pci) / sizeof (UINT32), // Count
343 &Pci // target buffer
344 );
345 if (EFI_ERROR (Status)) {
346 return Status;
347 }
348
349 //
350 // Copy protocol template
351 //
352 CopyMem (&Device->VirtioDevice, &mDeviceProtocolTemplate,
353 sizeof (VIRTIO_DEVICE_PROTOCOL));
354
355 //
356 // Initialize the protocol interface attributes
357 //
358 Device->VirtioDevice.Revision = VIRTIO_SPEC_REVISION (0, 9, 5);
359 Device->VirtioDevice.SubSystemDeviceId = Pci.Device.SubsystemID;
360
361 //
362 // Note: We don't support the MSI-X capability. If we did,
363 // the offset would become 24 after enabling MSI-X.
364 //
365 Device->DeviceSpecificConfigurationOffset =
366 VIRTIO_DEVICE_SPECIFIC_CONFIGURATION_OFFSET_PCI;
367
368 return EFI_SUCCESS;
369 }
370
371 /**
372
373 Uninitialize the internals of a virtio-pci device that has been successfully
374 set up with VirtioPciInit().
375
376 @param[in, out] Dev The device to clean up.
377
378 **/
379
380 STATIC
381 VOID
382 EFIAPI
VirtioPciUninit(IN OUT VIRTIO_PCI_DEVICE * Device)383 VirtioPciUninit (
384 IN OUT VIRTIO_PCI_DEVICE *Device
385 )
386 {
387 // Note: This function mirrors VirtioPciInit() that does not allocate any
388 // resources - there's nothing to free here.
389 }
390
391 /**
392
393 After we've pronounced support for a specific device in
394 DriverBindingSupported(), we start managing said device (passed in by the
395 Driver Execution Environment) with the following service.
396
397 See DriverBindingSupported() for specification references.
398
399 @param[in] This The EFI_DRIVER_BINDING_PROTOCOL object
400 incorporating this driver (independently of
401 any device).
402
403 @param[in] DeviceHandle The supported device to drive.
404
405 @param[in] RemainingDevicePath Relevant only for bus drivers, ignored.
406
407
408 @retval EFI_SUCCESS Driver instance has been created and
409 initialized for the virtio-pci device, it
410 is now accessible via VIRTIO_DEVICE_PROTOCOL.
411
412 @retval EFI_OUT_OF_RESOURCES Memory allocation failed.
413
414 @return Error codes from the OpenProtocol() boot
415 service, the PciIo protocol, VirtioPciInit(),
416 or the InstallProtocolInterface() boot service.
417
418 **/
419 STATIC
420 EFI_STATUS
421 EFIAPI
VirtioPciDeviceBindingStart(IN EFI_DRIVER_BINDING_PROTOCOL * This,IN EFI_HANDLE DeviceHandle,IN EFI_DEVICE_PATH_PROTOCOL * RemainingDevicePath)422 VirtioPciDeviceBindingStart (
423 IN EFI_DRIVER_BINDING_PROTOCOL *This,
424 IN EFI_HANDLE DeviceHandle,
425 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
426 )
427 {
428 VIRTIO_PCI_DEVICE *Device;
429 EFI_STATUS Status;
430
431 Device = (VIRTIO_PCI_DEVICE *) AllocateZeroPool (sizeof *Device);
432 if (Device == NULL) {
433 return EFI_OUT_OF_RESOURCES;
434 }
435
436 Status = gBS->OpenProtocol (DeviceHandle, &gEfiPciIoProtocolGuid,
437 (VOID **)&Device->PciIo, This->DriverBindingHandle,
438 DeviceHandle, EFI_OPEN_PROTOCOL_BY_DRIVER);
439 if (EFI_ERROR (Status)) {
440 goto FreeVirtioPci;
441 }
442
443 //
444 // We must retain and ultimately restore the original PCI attributes of the
445 // device. See Driver Writer's Guide for UEFI 2.3.1 v1.01, 18.3 PCI drivers /
446 // 18.3.2 Start() and Stop().
447 //
448 // The third parameter ("Attributes", input) is ignored by the Get operation.
449 // The fourth parameter ("Result", output) is ignored by the Enable and Set
450 // operations.
451 //
452 // For virtio-pci we only need IO space access.
453 //
454 Status = Device->PciIo->Attributes (Device->PciIo,
455 EfiPciIoAttributeOperationGet, 0, &Device->OriginalPciAttributes);
456 if (EFI_ERROR (Status)) {
457 goto ClosePciIo;
458 }
459
460 Status = Device->PciIo->Attributes (
461 Device->PciIo,
462 EfiPciIoAttributeOperationEnable,
463 (EFI_PCI_IO_ATTRIBUTE_IO |
464 EFI_PCI_IO_ATTRIBUTE_BUS_MASTER),
465 NULL
466 );
467 if (EFI_ERROR (Status)) {
468 goto ClosePciIo;
469 }
470
471 //
472 // PCI IO access granted, configure protocol instance
473 //
474
475 Status = VirtioPciInit (Device);
476 if (EFI_ERROR (Status)) {
477 goto RestorePciAttributes;
478 }
479
480 //
481 // Setup complete, attempt to export the driver instance's VirtioDevice
482 // interface.
483 //
484 Device->Signature = VIRTIO_PCI_DEVICE_SIGNATURE;
485 Status = gBS->InstallProtocolInterface (&DeviceHandle,
486 &gVirtioDeviceProtocolGuid, EFI_NATIVE_INTERFACE,
487 &Device->VirtioDevice);
488 if (EFI_ERROR (Status)) {
489 goto UninitDev;
490 }
491
492 return EFI_SUCCESS;
493
494 UninitDev:
495 VirtioPciUninit (Device);
496
497 RestorePciAttributes:
498 Device->PciIo->Attributes (Device->PciIo, EfiPciIoAttributeOperationSet,
499 Device->OriginalPciAttributes, NULL);
500
501 ClosePciIo:
502 gBS->CloseProtocol (DeviceHandle, &gEfiPciIoProtocolGuid,
503 This->DriverBindingHandle, DeviceHandle);
504
505 FreeVirtioPci:
506 FreePool (Device);
507
508 return Status;
509 }
510
511 /**
512
513 Stop driving the Virtio PCI device
514
515 @param[in] This The EFI_DRIVER_BINDING_PROTOCOL object
516 incorporating this driver (independently of any
517 device).
518
519 @param[in] DeviceHandle Stop driving this device.
520
521 @param[in] NumberOfChildren Since this function belongs to a device driver
522 only (as opposed to a bus driver), the caller
523 environment sets NumberOfChildren to zero, and
524 we ignore it.
525
526 @param[in] ChildHandleBuffer Ignored (corresponding to NumberOfChildren).
527
528 @retval EFI_SUCCESS Driver instance has been stopped and the PCI
529 configuration attributes have been restored.
530
531 @return Error codes from the OpenProtocol() or
532 CloseProtocol(), UninstallProtocolInterface()
533 boot services.
534
535 **/
536 STATIC
537 EFI_STATUS
538 EFIAPI
VirtioPciDeviceBindingStop(IN EFI_DRIVER_BINDING_PROTOCOL * This,IN EFI_HANDLE DeviceHandle,IN UINTN NumberOfChildren,IN EFI_HANDLE * ChildHandleBuffer)539 VirtioPciDeviceBindingStop (
540 IN EFI_DRIVER_BINDING_PROTOCOL *This,
541 IN EFI_HANDLE DeviceHandle,
542 IN UINTN NumberOfChildren,
543 IN EFI_HANDLE *ChildHandleBuffer
544 )
545 {
546 EFI_STATUS Status;
547 VIRTIO_DEVICE_PROTOCOL *VirtioDevice;
548 VIRTIO_PCI_DEVICE *Device;
549
550 Status = gBS->OpenProtocol (
551 DeviceHandle, // candidate device
552 &gVirtioDeviceProtocolGuid, // retrieve the VirtIo iface
553 (VOID **)&VirtioDevice, // target pointer
554 This->DriverBindingHandle, // requestor driver identity
555 DeviceHandle, // requesting lookup for dev.
556 EFI_OPEN_PROTOCOL_GET_PROTOCOL // lookup only, no ref. added
557 );
558 if (EFI_ERROR (Status)) {
559 return Status;
560 }
561
562 Device = VIRTIO_PCI_DEVICE_FROM_VIRTIO_DEVICE (VirtioDevice);
563
564 //
565 // Handle Stop() requests for in-use driver instances gracefully.
566 //
567 Status = gBS->UninstallProtocolInterface (DeviceHandle,
568 &gVirtioDeviceProtocolGuid, &Device->VirtioDevice);
569 if (EFI_ERROR (Status)) {
570 return Status;
571 }
572
573 VirtioPciUninit (Device);
574
575 Device->PciIo->Attributes (Device->PciIo, EfiPciIoAttributeOperationSet,
576 Device->OriginalPciAttributes, NULL);
577
578 Status = gBS->CloseProtocol (DeviceHandle, &gEfiPciIoProtocolGuid,
579 This->DriverBindingHandle, DeviceHandle);
580
581 FreePool (Device);
582
583 return Status;
584 }
585
586
587 //
588 // The static object that groups the Supported() (ie. probe), Start() and
589 // Stop() functions of the driver together. Refer to UEFI Spec 2.3.1 + Errata
590 // C, 10.1 EFI Driver Binding Protocol.
591 //
592 STATIC EFI_DRIVER_BINDING_PROTOCOL gDriverBinding = {
593 &VirtioPciDeviceBindingSupported,
594 &VirtioPciDeviceBindingStart,
595 &VirtioPciDeviceBindingStop,
596 0x10, // Version, must be in [0x10 .. 0xFFFFFFEF] for IHV-developed drivers
597 NULL, // ImageHandle, to be overwritten by
598 // EfiLibInstallDriverBindingComponentName2() in VirtioPciEntryPoint()
599 NULL // DriverBindingHandle, ditto
600 };
601
602
603 //
604 // The purpose of the following scaffolding (EFI_COMPONENT_NAME_PROTOCOL and
605 // EFI_COMPONENT_NAME2_PROTOCOL implementation) is to format the driver's name
606 // in English, for display on standard console devices. This is recommended for
607 // UEFI drivers that follow the UEFI Driver Model. Refer to the Driver Writer's
608 // Guide for UEFI 2.3.1 v1.01, 11 UEFI Driver and Controller Names.
609 //
610 STATIC
611 EFI_UNICODE_STRING_TABLE mDriverNameTable[] = {
612 { "eng;en", L"Virtio PCI Driver" },
613 { NULL, NULL }
614 };
615
616 STATIC
617 EFI_COMPONENT_NAME_PROTOCOL gComponentName;
618
619 EFI_STATUS
620 EFIAPI
VirtioPciGetDriverName(IN EFI_COMPONENT_NAME_PROTOCOL * This,IN CHAR8 * Language,OUT CHAR16 ** DriverName)621 VirtioPciGetDriverName (
622 IN EFI_COMPONENT_NAME_PROTOCOL *This,
623 IN CHAR8 *Language,
624 OUT CHAR16 **DriverName
625 )
626 {
627 return LookupUnicodeString2 (
628 Language,
629 This->SupportedLanguages,
630 mDriverNameTable,
631 DriverName,
632 (BOOLEAN)(This == &gComponentName) // Iso639Language
633 );
634 }
635
636 EFI_STATUS
637 EFIAPI
VirtioPciGetDeviceName(IN EFI_COMPONENT_NAME_PROTOCOL * This,IN EFI_HANDLE DeviceHandle,IN EFI_HANDLE ChildHandle,IN CHAR8 * Language,OUT CHAR16 ** ControllerName)638 VirtioPciGetDeviceName (
639 IN EFI_COMPONENT_NAME_PROTOCOL *This,
640 IN EFI_HANDLE DeviceHandle,
641 IN EFI_HANDLE ChildHandle,
642 IN CHAR8 *Language,
643 OUT CHAR16 **ControllerName
644 )
645 {
646 return EFI_UNSUPPORTED;
647 }
648
649 STATIC
650 EFI_COMPONENT_NAME_PROTOCOL gComponentName = {
651 &VirtioPciGetDriverName,
652 &VirtioPciGetDeviceName,
653 "eng" // SupportedLanguages, ISO 639-2 language codes
654 };
655
656 STATIC
657 EFI_COMPONENT_NAME2_PROTOCOL gComponentName2 = {
658 (EFI_COMPONENT_NAME2_GET_DRIVER_NAME) &VirtioPciGetDriverName,
659 (EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME) &VirtioPciGetDeviceName,
660 "en" // SupportedLanguages, RFC 4646 language codes
661 };
662
663
664 //
665 // Entry point of this driver.
666 //
667 EFI_STATUS
668 EFIAPI
VirtioPciDeviceEntryPoint(IN EFI_HANDLE ImageHandle,IN EFI_SYSTEM_TABLE * SystemTable)669 VirtioPciDeviceEntryPoint (
670 IN EFI_HANDLE ImageHandle,
671 IN EFI_SYSTEM_TABLE *SystemTable
672 )
673 {
674 return EfiLibInstallDriverBindingComponentName2 (
675 ImageHandle,
676 SystemTable,
677 &gDriverBinding,
678 ImageHandle,
679 &gComponentName,
680 &gComponentName2
681 );
682 }
683