OvmfPkg/VirtioPciDeviceDxe/VirtioPciDevice.c

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