| /** @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 | |
| ); | |
| } |