mirror of https://github.com/acidanthera/audk.git
718 lines
21 KiB
C
718 lines
21 KiB
C
/** @file
|
|
|
|
This driver produces Virtio Device Protocol instances for Virtio PCI devices.
|
|
|
|
Copyright (C) 2012, Red Hat, Inc.
|
|
Copyright (c) 2012 - 2016, Intel Corporation. All rights reserved.<BR>
|
|
Copyright (C) 2013, ARM Ltd.
|
|
Copyright (C) 2017, AMD Inc, All rights reserved.<BR>
|
|
|
|
SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
|
|
**/
|
|
|
|
#include <IndustryStandard/Pci.h>
|
|
#include <Library/BaseMemoryLib.h>
|
|
#include <Library/DebugLib.h>
|
|
#include <Library/MemoryAllocationLib.h>
|
|
#include <Library/UefiBootServicesTableLib.h>
|
|
#include <Library/UefiLib.h>
|
|
|
|
#include "VirtioPciDevice.h"
|
|
|
|
STATIC VIRTIO_DEVICE_PROTOCOL mDeviceProtocolTemplate = {
|
|
0, // Revision
|
|
0, // SubSystemDeviceId
|
|
VirtioPciGetDeviceFeatures, // GetDeviceFeatures
|
|
VirtioPciSetGuestFeatures, // SetGuestFeatures
|
|
VirtioPciSetQueueAddress, // SetQueueAddress
|
|
VirtioPciSetQueueSel, // SetQueueSel
|
|
VirtioPciSetQueueNotify, // SetQueueNotify
|
|
VirtioPciSetQueueAlignment, // SetQueueAlignment
|
|
VirtioPciSetPageSize, // SetPageSize
|
|
VirtioPciGetQueueSize, // GetQueueNumMax
|
|
VirtioPciSetQueueSize, // SetQueueNum
|
|
VirtioPciGetDeviceStatus, // GetDeviceStatus
|
|
VirtioPciSetDeviceStatus, // SetDeviceStatus
|
|
VirtioPciDeviceWrite, // WriteDevice
|
|
VirtioPciDeviceRead, // ReadDevice
|
|
VirtioPciAllocateSharedPages, // AllocateSharedPages
|
|
VirtioPciFreeSharedPages, // FreeSharedPages
|
|
VirtioPciMapSharedBuffer, // MapSharedBuffer
|
|
VirtioPciUnmapSharedBuffer, // UnmapSharedBuffer
|
|
};
|
|
|
|
/**
|
|
|
|
Read a word from Region 0 of the device specified by PciIo.
|
|
|
|
Region 0 must be an iomem region. This is an internal function for the PCI
|
|
implementation of the protocol.
|
|
|
|
@param[in] Dev Virtio PCI device.
|
|
|
|
@param[in] FieldOffset Source offset.
|
|
|
|
@param[in] FieldSize Source field size, must be in { 1, 2, 4, 8 }.
|
|
|
|
@param[in] BufferSize Number of bytes available in the target buffer. Must
|
|
equal FieldSize.
|
|
|
|
@param[out] Buffer Target buffer.
|
|
|
|
|
|
@return Status code returned by PciIo->Io.Read().
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
VirtioPciIoRead (
|
|
IN VIRTIO_PCI_DEVICE *Dev,
|
|
IN UINTN FieldOffset,
|
|
IN UINTN FieldSize,
|
|
IN UINTN BufferSize,
|
|
OUT VOID *Buffer
|
|
)
|
|
{
|
|
UINTN Count;
|
|
EFI_PCI_IO_PROTOCOL_WIDTH Width;
|
|
EFI_PCI_IO_PROTOCOL *PciIo;
|
|
|
|
ASSERT (FieldSize == BufferSize);
|
|
|
|
PciIo = Dev->PciIo;
|
|
Count = 1;
|
|
|
|
switch (FieldSize) {
|
|
case 1:
|
|
Width = EfiPciIoWidthUint8;
|
|
break;
|
|
|
|
case 2:
|
|
Width = EfiPciIoWidthUint16;
|
|
break;
|
|
|
|
case 8:
|
|
//
|
|
// The 64bit PCI I/O is broken down into two 32bit reads to prevent
|
|
// any alignment or width issues.
|
|
// The UEFI spec says under EFI_PCI_IO_PROTOCOL.Io.Write():
|
|
//
|
|
// The I/O operations are carried out exactly as requested. The caller
|
|
// is responsible for any alignment and I/O width issues which the
|
|
// bus, device, platform, or type of I/O might require. For example on
|
|
// some platforms, width requests of EfiPciIoWidthUint64 do not work.
|
|
//
|
|
Count = 2;
|
|
|
|
//
|
|
// fall through
|
|
//
|
|
case 4:
|
|
Width = EfiPciIoWidthUint32;
|
|
break;
|
|
|
|
default:
|
|
ASSERT (FALSE);
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
return PciIo->Io.Read (
|
|
PciIo,
|
|
Width,
|
|
PCI_BAR_IDX0,
|
|
FieldOffset,
|
|
Count,
|
|
Buffer
|
|
);
|
|
}
|
|
|
|
/**
|
|
|
|
Write a word into Region 0 of the device specified by PciIo.
|
|
|
|
Region 0 must be an iomem region. This is an internal function for the PCI
|
|
implementation of the protocol.
|
|
|
|
@param[in] Dev Virtio PCI device.
|
|
|
|
@param[in] FieldOffset Destination offset.
|
|
|
|
@param[in] FieldSize Destination field size, must be in { 1, 2, 4, 8 }.
|
|
|
|
@param[in] Value Little endian value to write, converted to UINT64.
|
|
The least significant FieldSize bytes will be used.
|
|
|
|
|
|
@return Status code returned by PciIo->Io.Write().
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
VirtioPciIoWrite (
|
|
IN VIRTIO_PCI_DEVICE *Dev,
|
|
IN UINTN FieldOffset,
|
|
IN UINTN FieldSize,
|
|
IN UINT64 Value
|
|
)
|
|
{
|
|
UINTN Count;
|
|
EFI_PCI_IO_PROTOCOL_WIDTH Width;
|
|
EFI_PCI_IO_PROTOCOL *PciIo;
|
|
|
|
PciIo = Dev->PciIo;
|
|
Count = 1;
|
|
|
|
switch (FieldSize) {
|
|
case 1:
|
|
Width = EfiPciIoWidthUint8;
|
|
break;
|
|
|
|
case 2:
|
|
Width = EfiPciIoWidthUint16;
|
|
break;
|
|
|
|
case 8:
|
|
//
|
|
// The 64bit PCI I/O is broken down into two 32bit writes to prevent
|
|
// any alignment or width issues.
|
|
// The UEFI spec says under EFI_PCI_IO_PROTOCOL.Io.Write():
|
|
//
|
|
// The I/O operations are carried out exactly as requested. The caller
|
|
// is responsible for any alignment and I/O width issues which the
|
|
// bus, device, platform, or type of I/O might require. For example on
|
|
// some platforms, width requests of EfiPciIoWidthUint64 do not work
|
|
//
|
|
Count = Count * 2;
|
|
|
|
//
|
|
// fall through
|
|
//
|
|
case 4:
|
|
Width = EfiPciIoWidthUint32;
|
|
break;
|
|
|
|
default:
|
|
ASSERT (FALSE);
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
return PciIo->Io.Write (
|
|
PciIo,
|
|
Width,
|
|
PCI_BAR_IDX0,
|
|
FieldOffset,
|
|
Count,
|
|
&Value
|
|
);
|
|
}
|
|
|
|
/**
|
|
|
|
Device probe function for this driver.
|
|
|
|
The DXE core calls this function for any given device in order to see if the
|
|
driver can drive the device.
|
|
|
|
@param[in] This The EFI_DRIVER_BINDING_PROTOCOL object
|
|
incorporating this driver (independently of
|
|
any device).
|
|
|
|
@param[in] DeviceHandle The device to probe.
|
|
|
|
@param[in] RemainingDevicePath Relevant only for bus drivers, ignored.
|
|
|
|
|
|
@retval EFI_SUCCESS The driver supports the device being probed.
|
|
|
|
@retval EFI_UNSUPPORTED Based on virtio-pci discovery, we do not support
|
|
the device.
|
|
|
|
@return Error codes from the OpenProtocol() boot service or
|
|
the PciIo protocol.
|
|
|
|
**/
|
|
STATIC
|
|
EFI_STATUS
|
|
EFIAPI
|
|
VirtioPciDeviceBindingSupported (
|
|
IN EFI_DRIVER_BINDING_PROTOCOL *This,
|
|
IN EFI_HANDLE DeviceHandle,
|
|
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
EFI_PCI_IO_PROTOCOL *PciIo;
|
|
PCI_TYPE00 Pci;
|
|
|
|
//
|
|
// Attempt to open the device with the PciIo set of interfaces. On success,
|
|
// the protocol is "instantiated" for the PCI device. Covers duplicate open
|
|
// attempts (EFI_ALREADY_STARTED).
|
|
//
|
|
Status = gBS->OpenProtocol (
|
|
DeviceHandle, // candidate device
|
|
&gEfiPciIoProtocolGuid, // for generic PCI access
|
|
(VOID **)&PciIo, // handle to instantiate
|
|
This->DriverBindingHandle, // requestor driver identity
|
|
DeviceHandle, // ControllerHandle, according to
|
|
// the UEFI Driver Model
|
|
EFI_OPEN_PROTOCOL_BY_DRIVER // get exclusive PciIo access to
|
|
// the device; to be released
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Read entire PCI configuration header for more extensive check ahead.
|
|
//
|
|
Status = PciIo->Pci.Read (
|
|
PciIo, // (protocol, device)
|
|
// handle
|
|
EfiPciIoWidthUint32, // access width & copy
|
|
// mode
|
|
0, // Offset
|
|
sizeof Pci / sizeof (UINT32), // Count
|
|
&Pci // target buffer
|
|
);
|
|
|
|
if (Status == EFI_SUCCESS) {
|
|
//
|
|
// virtio-0.9.5, 2.1 PCI Discovery
|
|
//
|
|
if ((Pci.Hdr.VendorId == VIRTIO_VENDOR_ID) &&
|
|
(Pci.Hdr.DeviceId >= 0x1000) &&
|
|
(Pci.Hdr.DeviceId <= 0x103F) &&
|
|
(Pci.Hdr.RevisionID == 0x00))
|
|
{
|
|
Status = EFI_SUCCESS;
|
|
} else {
|
|
Status = EFI_UNSUPPORTED;
|
|
}
|
|
}
|
|
|
|
//
|
|
// We needed PCI IO access only transitorily, to see whether we support the
|
|
// device or not.
|
|
//
|
|
gBS->CloseProtocol (
|
|
DeviceHandle,
|
|
&gEfiPciIoProtocolGuid,
|
|
This->DriverBindingHandle,
|
|
DeviceHandle
|
|
);
|
|
|
|
return Status;
|
|
}
|
|
|
|
/**
|
|
|
|
Initialize the VirtIo PCI Device
|
|
|
|
@param[in, out] Dev The driver instance to configure. The caller is
|
|
responsible for Device->PciIo's validity (ie. working IO
|
|
access to the underlying virtio-pci device).
|
|
|
|
@retval EFI_SUCCESS Setup complete.
|
|
|
|
@retval EFI_UNSUPPORTED The underlying IO device doesn't support the
|
|
provided address offset and read size.
|
|
|
|
@return Error codes from PciIo->Pci.Read().
|
|
|
|
**/
|
|
STATIC
|
|
EFI_STATUS
|
|
EFIAPI
|
|
VirtioPciInit (
|
|
IN OUT VIRTIO_PCI_DEVICE *Device
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
EFI_PCI_IO_PROTOCOL *PciIo;
|
|
PCI_TYPE00 Pci;
|
|
|
|
ASSERT (Device != NULL);
|
|
PciIo = Device->PciIo;
|
|
ASSERT (PciIo != NULL);
|
|
ASSERT (PciIo->Pci.Read != NULL);
|
|
|
|
Status = PciIo->Pci.Read (
|
|
PciIo, // (protocol, device)
|
|
// handle
|
|
EfiPciIoWidthUint32, // access width & copy
|
|
// mode
|
|
0, // Offset
|
|
sizeof (Pci) / sizeof (UINT32), // Count
|
|
&Pci // target buffer
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Copy protocol template
|
|
//
|
|
CopyMem (
|
|
&Device->VirtioDevice,
|
|
&mDeviceProtocolTemplate,
|
|
sizeof (VIRTIO_DEVICE_PROTOCOL)
|
|
);
|
|
|
|
//
|
|
// Initialize the protocol interface attributes
|
|
//
|
|
Device->VirtioDevice.Revision = VIRTIO_SPEC_REVISION (0, 9, 5);
|
|
Device->VirtioDevice.SubSystemDeviceId = Pci.Device.SubsystemID;
|
|
|
|
//
|
|
// Note: We don't support the MSI-X capability. If we did,
|
|
// the offset would become 24 after enabling MSI-X.
|
|
//
|
|
Device->DeviceSpecificConfigurationOffset =
|
|
VIRTIO_DEVICE_SPECIFIC_CONFIGURATION_OFFSET_PCI;
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
|
|
Uninitialize the internals of a virtio-pci device that has been successfully
|
|
set up with VirtioPciInit().
|
|
|
|
@param[in, out] Dev The device to clean up.
|
|
|
|
**/
|
|
STATIC
|
|
VOID
|
|
EFIAPI
|
|
VirtioPciUninit (
|
|
IN OUT VIRTIO_PCI_DEVICE *Device
|
|
)
|
|
{
|
|
// Note: This function mirrors VirtioPciInit() that does not allocate any
|
|
// resources - there's nothing to free here.
|
|
}
|
|
|
|
/**
|
|
|
|
After we've pronounced support for a specific device in
|
|
DriverBindingSupported(), we start managing said device (passed in by the
|
|
Driver Execution Environment) with the following service.
|
|
|
|
See DriverBindingSupported() for specification references.
|
|
|
|
@param[in] This The EFI_DRIVER_BINDING_PROTOCOL object
|
|
incorporating this driver (independently of
|
|
any device).
|
|
|
|
@param[in] DeviceHandle The supported device to drive.
|
|
|
|
@param[in] RemainingDevicePath Relevant only for bus drivers, ignored.
|
|
|
|
|
|
@retval EFI_SUCCESS Driver instance has been created and
|
|
initialized for the virtio-pci device, it
|
|
is now accessible via VIRTIO_DEVICE_PROTOCOL.
|
|
|
|
@retval EFI_OUT_OF_RESOURCES Memory allocation failed.
|
|
|
|
@return Error codes from the OpenProtocol() boot
|
|
service, the PciIo protocol, VirtioPciInit(),
|
|
or the InstallProtocolInterface() boot service.
|
|
|
|
**/
|
|
STATIC
|
|
EFI_STATUS
|
|
EFIAPI
|
|
VirtioPciDeviceBindingStart (
|
|
IN EFI_DRIVER_BINDING_PROTOCOL *This,
|
|
IN EFI_HANDLE DeviceHandle,
|
|
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
|
|
)
|
|
{
|
|
VIRTIO_PCI_DEVICE *Device;
|
|
EFI_STATUS Status;
|
|
|
|
Device = (VIRTIO_PCI_DEVICE *)AllocateZeroPool (sizeof *Device);
|
|
if (Device == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
Status = gBS->OpenProtocol (
|
|
DeviceHandle,
|
|
&gEfiPciIoProtocolGuid,
|
|
(VOID **)&Device->PciIo,
|
|
This->DriverBindingHandle,
|
|
DeviceHandle,
|
|
EFI_OPEN_PROTOCOL_BY_DRIVER
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
goto FreeVirtioPci;
|
|
}
|
|
|
|
//
|
|
// We must retain and ultimately restore the original PCI attributes of the
|
|
// device. See Driver Writer's Guide for UEFI 2.3.1 v1.01, 18.3 PCI drivers /
|
|
// 18.3.2 Start() and Stop().
|
|
//
|
|
// The third parameter ("Attributes", input) is ignored by the Get operation.
|
|
// The fourth parameter ("Result", output) is ignored by the Enable and Set
|
|
// operations.
|
|
//
|
|
// For virtio-pci we only need IO space access.
|
|
//
|
|
Status = Device->PciIo->Attributes (
|
|
Device->PciIo,
|
|
EfiPciIoAttributeOperationGet,
|
|
0,
|
|
&Device->OriginalPciAttributes
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
goto ClosePciIo;
|
|
}
|
|
|
|
Status = Device->PciIo->Attributes (
|
|
Device->PciIo,
|
|
EfiPciIoAttributeOperationEnable,
|
|
(EFI_PCI_IO_ATTRIBUTE_IO |
|
|
EFI_PCI_IO_ATTRIBUTE_BUS_MASTER),
|
|
NULL
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
goto ClosePciIo;
|
|
}
|
|
|
|
//
|
|
// PCI IO access granted, configure protocol instance
|
|
//
|
|
|
|
Status = VirtioPciInit (Device);
|
|
if (EFI_ERROR (Status)) {
|
|
goto RestorePciAttributes;
|
|
}
|
|
|
|
//
|
|
// Setup complete, attempt to export the driver instance's VirtioDevice
|
|
// interface.
|
|
//
|
|
Device->Signature = VIRTIO_PCI_DEVICE_SIGNATURE;
|
|
Status = gBS->InstallProtocolInterface (
|
|
&DeviceHandle,
|
|
&gVirtioDeviceProtocolGuid,
|
|
EFI_NATIVE_INTERFACE,
|
|
&Device->VirtioDevice
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
goto UninitDev;
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
|
|
UninitDev:
|
|
VirtioPciUninit (Device);
|
|
|
|
RestorePciAttributes:
|
|
Device->PciIo->Attributes (
|
|
Device->PciIo,
|
|
EfiPciIoAttributeOperationSet,
|
|
Device->OriginalPciAttributes,
|
|
NULL
|
|
);
|
|
|
|
ClosePciIo:
|
|
gBS->CloseProtocol (
|
|
DeviceHandle,
|
|
&gEfiPciIoProtocolGuid,
|
|
This->DriverBindingHandle,
|
|
DeviceHandle
|
|
);
|
|
|
|
FreeVirtioPci:
|
|
FreePool (Device);
|
|
|
|
return Status;
|
|
}
|
|
|
|
/**
|
|
|
|
Stop driving the Virtio PCI device
|
|
|
|
@param[in] This The EFI_DRIVER_BINDING_PROTOCOL object
|
|
incorporating this driver (independently of any
|
|
device).
|
|
|
|
@param[in] DeviceHandle Stop driving this device.
|
|
|
|
@param[in] NumberOfChildren Since this function belongs to a device driver
|
|
only (as opposed to a bus driver), the caller
|
|
environment sets NumberOfChildren to zero, and
|
|
we ignore it.
|
|
|
|
@param[in] ChildHandleBuffer Ignored (corresponding to NumberOfChildren).
|
|
|
|
@retval EFI_SUCCESS Driver instance has been stopped and the PCI
|
|
configuration attributes have been restored.
|
|
|
|
@return Error codes from the OpenProtocol() or
|
|
CloseProtocol(), UninstallProtocolInterface()
|
|
boot services.
|
|
|
|
**/
|
|
STATIC
|
|
EFI_STATUS
|
|
EFIAPI
|
|
VirtioPciDeviceBindingStop (
|
|
IN EFI_DRIVER_BINDING_PROTOCOL *This,
|
|
IN EFI_HANDLE DeviceHandle,
|
|
IN UINTN NumberOfChildren,
|
|
IN EFI_HANDLE *ChildHandleBuffer
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
VIRTIO_DEVICE_PROTOCOL *VirtioDevice;
|
|
VIRTIO_PCI_DEVICE *Device;
|
|
|
|
Status = gBS->OpenProtocol (
|
|
DeviceHandle, // candidate device
|
|
&gVirtioDeviceProtocolGuid, // retrieve the VirtIo iface
|
|
(VOID **)&VirtioDevice, // target pointer
|
|
This->DriverBindingHandle, // requestor driver identity
|
|
DeviceHandle, // requesting lookup for dev.
|
|
EFI_OPEN_PROTOCOL_GET_PROTOCOL // lookup only, no ref. added
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
return Status;
|
|
}
|
|
|
|
Device = VIRTIO_PCI_DEVICE_FROM_VIRTIO_DEVICE (VirtioDevice);
|
|
|
|
//
|
|
// Handle Stop() requests for in-use driver instances gracefully.
|
|
//
|
|
Status = gBS->UninstallProtocolInterface (
|
|
DeviceHandle,
|
|
&gVirtioDeviceProtocolGuid,
|
|
&Device->VirtioDevice
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
return Status;
|
|
}
|
|
|
|
VirtioPciUninit (Device);
|
|
|
|
Device->PciIo->Attributes (
|
|
Device->PciIo,
|
|
EfiPciIoAttributeOperationSet,
|
|
Device->OriginalPciAttributes,
|
|
NULL
|
|
);
|
|
|
|
Status = gBS->CloseProtocol (
|
|
DeviceHandle,
|
|
&gEfiPciIoProtocolGuid,
|
|
This->DriverBindingHandle,
|
|
DeviceHandle
|
|
);
|
|
|
|
FreePool (Device);
|
|
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// The static object that groups the Supported() (ie. probe), Start() and
|
|
// Stop() functions of the driver together. Refer to UEFI Spec 2.3.1 + Errata
|
|
// C, 10.1 EFI Driver Binding Protocol.
|
|
//
|
|
STATIC EFI_DRIVER_BINDING_PROTOCOL gDriverBinding = {
|
|
&VirtioPciDeviceBindingSupported,
|
|
&VirtioPciDeviceBindingStart,
|
|
&VirtioPciDeviceBindingStop,
|
|
0x10, // Version, must be in [0x10 .. 0xFFFFFFEF] for IHV-developed drivers
|
|
NULL, // ImageHandle, to be overwritten by
|
|
// EfiLibInstallDriverBindingComponentName2() in VirtioPciEntryPoint()
|
|
NULL // DriverBindingHandle, ditto
|
|
};
|
|
|
|
//
|
|
// The purpose of the following scaffolding (EFI_COMPONENT_NAME_PROTOCOL and
|
|
// EFI_COMPONENT_NAME2_PROTOCOL implementation) is to format the driver's name
|
|
// in English, for display on standard console devices. This is recommended for
|
|
// UEFI drivers that follow the UEFI Driver Model. Refer to the Driver Writer's
|
|
// Guide for UEFI 2.3.1 v1.01, 11 UEFI Driver and Controller Names.
|
|
//
|
|
STATIC
|
|
EFI_UNICODE_STRING_TABLE mDriverNameTable[] = {
|
|
{ "eng;en", L"Virtio PCI Driver" },
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
STATIC
|
|
EFI_COMPONENT_NAME_PROTOCOL gComponentName;
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
VirtioPciGetDriverName (
|
|
IN EFI_COMPONENT_NAME_PROTOCOL *This,
|
|
IN CHAR8 *Language,
|
|
OUT CHAR16 **DriverName
|
|
)
|
|
{
|
|
return LookupUnicodeString2 (
|
|
Language,
|
|
This->SupportedLanguages,
|
|
mDriverNameTable,
|
|
DriverName,
|
|
(BOOLEAN)(This == &gComponentName) // Iso639Language
|
|
);
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
VirtioPciGetDeviceName (
|
|
IN EFI_COMPONENT_NAME_PROTOCOL *This,
|
|
IN EFI_HANDLE DeviceHandle,
|
|
IN EFI_HANDLE ChildHandle,
|
|
IN CHAR8 *Language,
|
|
OUT CHAR16 **ControllerName
|
|
)
|
|
{
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
STATIC
|
|
EFI_COMPONENT_NAME_PROTOCOL gComponentName = {
|
|
&VirtioPciGetDriverName,
|
|
&VirtioPciGetDeviceName,
|
|
"eng" // SupportedLanguages, ISO 639-2 language codes
|
|
};
|
|
|
|
STATIC
|
|
EFI_COMPONENT_NAME2_PROTOCOL gComponentName2 = {
|
|
(EFI_COMPONENT_NAME2_GET_DRIVER_NAME)&VirtioPciGetDriverName,
|
|
(EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME)&VirtioPciGetDeviceName,
|
|
"en" // SupportedLanguages, RFC 4646 language codes
|
|
};
|
|
|
|
//
|
|
// Entry point of this driver.
|
|
//
|
|
EFI_STATUS
|
|
EFIAPI
|
|
VirtioPciDeviceEntryPoint (
|
|
IN EFI_HANDLE ImageHandle,
|
|
IN EFI_SYSTEM_TABLE *SystemTable
|
|
)
|
|
{
|
|
return EfiLibInstallDriverBindingComponentName2 (
|
|
ImageHandle,
|
|
SystemTable,
|
|
&gDriverBinding,
|
|
ImageHandle,
|
|
&gComponentName,
|
|
&gComponentName2
|
|
);
|
|
}
|