audk/OvmfPkg/VirtioGpuDxe/Commands.c

774 lines
23 KiB
C
Raw Normal View History

/** @file
VirtIo GPU initialization, and commands (primitives) for the GPU device.
Copyright (C) 2016, Red Hat, Inc.
Copyright (c) 2017, AMD Inc, All rights reserved.<BR>
This program and the accompanying materials are licensed and made available
under the terms and conditions of the BSD License which accompanies this
distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT
WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#include <Library/VirtioLib.h>
#include "VirtioGpu.h"
/**
Configure the VirtIo GPU device that underlies VgpuDev.
@param[in,out] VgpuDev The VGPU_DEV object to set up VirtIo messaging for.
On input, the caller is responsible for having
initialized VgpuDev->VirtIo. On output, VgpuDev->Ring
has been initialized, and synchronous VirtIo GPU
commands (primitives) can be submitted to the device.
@retval EFI_SUCCESS VirtIo GPU configuration successful.
@retval EFI_UNSUPPORTED The host-side configuration of the VirtIo GPU is not
supported by this driver.
@retval Error codes from underlying functions.
**/
EFI_STATUS
VirtioGpuInit (
IN OUT VGPU_DEV *VgpuDev
)
{
UINT8 NextDevStat;
EFI_STATUS Status;
UINT64 Features;
UINT16 QueueSize;
OvmfPkg/VirtioGpuDxe: map VRING for bus master common buffer operation VirtioGpuDxe uses one virtio ring, for VIRTIO_GPU_CONTROL_QUEUE. Map it for bus master common buffer operation with VirtioRingMap(), so that it can be accessed equally by both guest and hypervisor even if an IOMMU is used. (VirtioRingInit() already allocates the ring suitably for this, see commit b0338c53297c, "OvmfPkg/VirtioLib: alloc VRING buffer with AllocateSharedPages()", 2017-08-23). Pass the resultant translation offset ("RingBaseShift"), from system memory address to bus master device address, to VIRTIO_SET_QUEUE_ADDRESS. Unmap the ring in all contexts where the ring becomes unused (these contexts are mutually exclusive): - in VirtioGpuInit(): the ring has been mapped, but we cannot complete the virtio initialization for another reason, - in VirtioGpuUninit(): the virtio initialization has succeeded, but VirtioGpuDriverBindingStart() fails for another reason, or VirtioGpuDriverBindingStop() unbinds the device after use, - in VirtioGpuExitBoot(): ExitBootServices() is called after VirtioGpuDriverBindingStart() has successfully bound the device. (Unmapping the ring does not change the UEFI memory map.) Cc: Ard Biesheuvel <ard.biesheuvel@linaro.org> Cc: Brijesh Singh <brijesh.singh@amd.com> Cc: Jordan Justen <jordan.l.justen@intel.com> Cc: Tom Lendacky <thomas.lendacky@amd.com> Contributed-under: TianoCore Contribution Agreement 1.1 Signed-off-by: Laszlo Ersek <lersek@redhat.com> Tested-by: Brijesh Singh <brijesh.singh@amd.com>
2017-08-26 16:00:30 +02:00
UINT64 RingBaseShift;
//
// Execute virtio-v1.0-cs04, 3.1.1 Driver Requirements: Device
// Initialization.
//
// 1. Reset the device.
//
NextDevStat = 0;
Status = VgpuDev->VirtIo->SetDeviceStatus (VgpuDev->VirtIo, NextDevStat);
if (EFI_ERROR (Status)) {
goto Failed;
}
//
// 2. Set the ACKNOWLEDGE status bit [...]
//
NextDevStat |= VSTAT_ACK;
Status = VgpuDev->VirtIo->SetDeviceStatus (VgpuDev->VirtIo, NextDevStat);
if (EFI_ERROR (Status)) {
goto Failed;
}
//
// 3. Set the DRIVER status bit [...]
//
NextDevStat |= VSTAT_DRIVER;
Status = VgpuDev->VirtIo->SetDeviceStatus (VgpuDev->VirtIo, NextDevStat);
if (EFI_ERROR (Status)) {
goto Failed;
}
//
// 4. Read device feature bits...
//
Status = VgpuDev->VirtIo->GetDeviceFeatures (VgpuDev->VirtIo, &Features);
if (EFI_ERROR (Status)) {
goto Failed;
}
if ((Features & VIRTIO_F_VERSION_1) == 0) {
Status = EFI_UNSUPPORTED;
goto Failed;
}
//
// We only want the most basic 2D features.
//
Features &= VIRTIO_F_VERSION_1 | VIRTIO_F_IOMMU_PLATFORM;
//
// ... and write the subset of feature bits understood by the [...] driver to
// the device. [...]
// 5. Set the FEATURES_OK status bit.
// 6. Re-read device status to ensure the FEATURES_OK bit is still set [...]
//
Status = Virtio10WriteFeatures (VgpuDev->VirtIo, Features, &NextDevStat);
if (EFI_ERROR (Status)) {
goto Failed;
}
//
// 7. Perform device-specific setup, including discovery of virtqueues for
// the device [...]
//
Status = VgpuDev->VirtIo->SetQueueSel (VgpuDev->VirtIo,
VIRTIO_GPU_CONTROL_QUEUE);
if (EFI_ERROR (Status)) {
goto Failed;
}
Status = VgpuDev->VirtIo->GetQueueNumMax (VgpuDev->VirtIo, &QueueSize);
if (EFI_ERROR (Status)) {
goto Failed;
}
//
// We implement each VirtIo GPU command that we use with two descriptors:
// request, response.
//
if (QueueSize < 2) {
Status = EFI_UNSUPPORTED;
goto Failed;
}
//
// [...] population of virtqueues [...]
//
Status = VirtioRingInit (VgpuDev->VirtIo, QueueSize, &VgpuDev->Ring);
if (EFI_ERROR (Status)) {
goto Failed;
}
OvmfPkg/VirtioGpuDxe: map VRING for bus master common buffer operation VirtioGpuDxe uses one virtio ring, for VIRTIO_GPU_CONTROL_QUEUE. Map it for bus master common buffer operation with VirtioRingMap(), so that it can be accessed equally by both guest and hypervisor even if an IOMMU is used. (VirtioRingInit() already allocates the ring suitably for this, see commit b0338c53297c, "OvmfPkg/VirtioLib: alloc VRING buffer with AllocateSharedPages()", 2017-08-23). Pass the resultant translation offset ("RingBaseShift"), from system memory address to bus master device address, to VIRTIO_SET_QUEUE_ADDRESS. Unmap the ring in all contexts where the ring becomes unused (these contexts are mutually exclusive): - in VirtioGpuInit(): the ring has been mapped, but we cannot complete the virtio initialization for another reason, - in VirtioGpuUninit(): the virtio initialization has succeeded, but VirtioGpuDriverBindingStart() fails for another reason, or VirtioGpuDriverBindingStop() unbinds the device after use, - in VirtioGpuExitBoot(): ExitBootServices() is called after VirtioGpuDriverBindingStart() has successfully bound the device. (Unmapping the ring does not change the UEFI memory map.) Cc: Ard Biesheuvel <ard.biesheuvel@linaro.org> Cc: Brijesh Singh <brijesh.singh@amd.com> Cc: Jordan Justen <jordan.l.justen@intel.com> Cc: Tom Lendacky <thomas.lendacky@amd.com> Contributed-under: TianoCore Contribution Agreement 1.1 Signed-off-by: Laszlo Ersek <lersek@redhat.com> Tested-by: Brijesh Singh <brijesh.singh@amd.com>
2017-08-26 16:00:30 +02:00
//
// If anything fails from here on, we have to release the ring.
//
Status = VirtioRingMap (
VgpuDev->VirtIo,
&VgpuDev->Ring,
&RingBaseShift,
&VgpuDev->RingMap
);
if (EFI_ERROR (Status)) {
goto ReleaseQueue;
}
//
// If anything fails from here on, we have to unmap the ring.
//
Status = VgpuDev->VirtIo->SetQueueAddress (
VgpuDev->VirtIo,
&VgpuDev->Ring,
OvmfPkg/VirtioGpuDxe: map VRING for bus master common buffer operation VirtioGpuDxe uses one virtio ring, for VIRTIO_GPU_CONTROL_QUEUE. Map it for bus master common buffer operation with VirtioRingMap(), so that it can be accessed equally by both guest and hypervisor even if an IOMMU is used. (VirtioRingInit() already allocates the ring suitably for this, see commit b0338c53297c, "OvmfPkg/VirtioLib: alloc VRING buffer with AllocateSharedPages()", 2017-08-23). Pass the resultant translation offset ("RingBaseShift"), from system memory address to bus master device address, to VIRTIO_SET_QUEUE_ADDRESS. Unmap the ring in all contexts where the ring becomes unused (these contexts are mutually exclusive): - in VirtioGpuInit(): the ring has been mapped, but we cannot complete the virtio initialization for another reason, - in VirtioGpuUninit(): the virtio initialization has succeeded, but VirtioGpuDriverBindingStart() fails for another reason, or VirtioGpuDriverBindingStop() unbinds the device after use, - in VirtioGpuExitBoot(): ExitBootServices() is called after VirtioGpuDriverBindingStart() has successfully bound the device. (Unmapping the ring does not change the UEFI memory map.) Cc: Ard Biesheuvel <ard.biesheuvel@linaro.org> Cc: Brijesh Singh <brijesh.singh@amd.com> Cc: Jordan Justen <jordan.l.justen@intel.com> Cc: Tom Lendacky <thomas.lendacky@amd.com> Contributed-under: TianoCore Contribution Agreement 1.1 Signed-off-by: Laszlo Ersek <lersek@redhat.com> Tested-by: Brijesh Singh <brijesh.singh@amd.com>
2017-08-26 16:00:30 +02:00
RingBaseShift
);
if (EFI_ERROR (Status)) {
OvmfPkg/VirtioGpuDxe: map VRING for bus master common buffer operation VirtioGpuDxe uses one virtio ring, for VIRTIO_GPU_CONTROL_QUEUE. Map it for bus master common buffer operation with VirtioRingMap(), so that it can be accessed equally by both guest and hypervisor even if an IOMMU is used. (VirtioRingInit() already allocates the ring suitably for this, see commit b0338c53297c, "OvmfPkg/VirtioLib: alloc VRING buffer with AllocateSharedPages()", 2017-08-23). Pass the resultant translation offset ("RingBaseShift"), from system memory address to bus master device address, to VIRTIO_SET_QUEUE_ADDRESS. Unmap the ring in all contexts where the ring becomes unused (these contexts are mutually exclusive): - in VirtioGpuInit(): the ring has been mapped, but we cannot complete the virtio initialization for another reason, - in VirtioGpuUninit(): the virtio initialization has succeeded, but VirtioGpuDriverBindingStart() fails for another reason, or VirtioGpuDriverBindingStop() unbinds the device after use, - in VirtioGpuExitBoot(): ExitBootServices() is called after VirtioGpuDriverBindingStart() has successfully bound the device. (Unmapping the ring does not change the UEFI memory map.) Cc: Ard Biesheuvel <ard.biesheuvel@linaro.org> Cc: Brijesh Singh <brijesh.singh@amd.com> Cc: Jordan Justen <jordan.l.justen@intel.com> Cc: Tom Lendacky <thomas.lendacky@amd.com> Contributed-under: TianoCore Contribution Agreement 1.1 Signed-off-by: Laszlo Ersek <lersek@redhat.com> Tested-by: Brijesh Singh <brijesh.singh@amd.com>
2017-08-26 16:00:30 +02:00
goto UnmapQueue;
}
//
// 8. Set the DRIVER_OK status bit.
//
NextDevStat |= VSTAT_DRIVER_OK;
Status = VgpuDev->VirtIo->SetDeviceStatus (VgpuDev->VirtIo, NextDevStat);
if (EFI_ERROR (Status)) {
OvmfPkg/VirtioGpuDxe: map VRING for bus master common buffer operation VirtioGpuDxe uses one virtio ring, for VIRTIO_GPU_CONTROL_QUEUE. Map it for bus master common buffer operation with VirtioRingMap(), so that it can be accessed equally by both guest and hypervisor even if an IOMMU is used. (VirtioRingInit() already allocates the ring suitably for this, see commit b0338c53297c, "OvmfPkg/VirtioLib: alloc VRING buffer with AllocateSharedPages()", 2017-08-23). Pass the resultant translation offset ("RingBaseShift"), from system memory address to bus master device address, to VIRTIO_SET_QUEUE_ADDRESS. Unmap the ring in all contexts where the ring becomes unused (these contexts are mutually exclusive): - in VirtioGpuInit(): the ring has been mapped, but we cannot complete the virtio initialization for another reason, - in VirtioGpuUninit(): the virtio initialization has succeeded, but VirtioGpuDriverBindingStart() fails for another reason, or VirtioGpuDriverBindingStop() unbinds the device after use, - in VirtioGpuExitBoot(): ExitBootServices() is called after VirtioGpuDriverBindingStart() has successfully bound the device. (Unmapping the ring does not change the UEFI memory map.) Cc: Ard Biesheuvel <ard.biesheuvel@linaro.org> Cc: Brijesh Singh <brijesh.singh@amd.com> Cc: Jordan Justen <jordan.l.justen@intel.com> Cc: Tom Lendacky <thomas.lendacky@amd.com> Contributed-under: TianoCore Contribution Agreement 1.1 Signed-off-by: Laszlo Ersek <lersek@redhat.com> Tested-by: Brijesh Singh <brijesh.singh@amd.com>
2017-08-26 16:00:30 +02:00
goto UnmapQueue;
}
return EFI_SUCCESS;
OvmfPkg/VirtioGpuDxe: map VRING for bus master common buffer operation VirtioGpuDxe uses one virtio ring, for VIRTIO_GPU_CONTROL_QUEUE. Map it for bus master common buffer operation with VirtioRingMap(), so that it can be accessed equally by both guest and hypervisor even if an IOMMU is used. (VirtioRingInit() already allocates the ring suitably for this, see commit b0338c53297c, "OvmfPkg/VirtioLib: alloc VRING buffer with AllocateSharedPages()", 2017-08-23). Pass the resultant translation offset ("RingBaseShift"), from system memory address to bus master device address, to VIRTIO_SET_QUEUE_ADDRESS. Unmap the ring in all contexts where the ring becomes unused (these contexts are mutually exclusive): - in VirtioGpuInit(): the ring has been mapped, but we cannot complete the virtio initialization for another reason, - in VirtioGpuUninit(): the virtio initialization has succeeded, but VirtioGpuDriverBindingStart() fails for another reason, or VirtioGpuDriverBindingStop() unbinds the device after use, - in VirtioGpuExitBoot(): ExitBootServices() is called after VirtioGpuDriverBindingStart() has successfully bound the device. (Unmapping the ring does not change the UEFI memory map.) Cc: Ard Biesheuvel <ard.biesheuvel@linaro.org> Cc: Brijesh Singh <brijesh.singh@amd.com> Cc: Jordan Justen <jordan.l.justen@intel.com> Cc: Tom Lendacky <thomas.lendacky@amd.com> Contributed-under: TianoCore Contribution Agreement 1.1 Signed-off-by: Laszlo Ersek <lersek@redhat.com> Tested-by: Brijesh Singh <brijesh.singh@amd.com>
2017-08-26 16:00:30 +02:00
UnmapQueue:
VgpuDev->VirtIo->UnmapSharedBuffer (VgpuDev->VirtIo, VgpuDev->RingMap);
ReleaseQueue:
VirtioRingUninit (VgpuDev->VirtIo, &VgpuDev->Ring);
Failed:
//
// If any of these steps go irrecoverably wrong, the driver SHOULD set the
// FAILED status bit to indicate that it has given up on the device (it can
// reset the device later to restart if desired). [...]
//
// VirtIo access failure here should not mask the original error.
//
NextDevStat |= VSTAT_FAILED;
VgpuDev->VirtIo->SetDeviceStatus (VgpuDev->VirtIo, NextDevStat);
return Status;
}
/**
De-configure the VirtIo GPU device that underlies VgpuDev.
@param[in,out] VgpuDev The VGPU_DEV object to tear down VirtIo messaging
for. On input, the caller is responsible for having
called VirtioGpuInit(). On output, VgpuDev->Ring has
been uninitialized; VirtIo GPU commands (primitives)
can no longer be submitted to the device.
**/
VOID
VirtioGpuUninit (
IN OUT VGPU_DEV *VgpuDev
)
{
//
// Resetting the VirtIo device makes it release its resources and forget its
// configuration.
//
VgpuDev->VirtIo->SetDeviceStatus (VgpuDev->VirtIo, 0);
OvmfPkg/VirtioGpuDxe: map VRING for bus master common buffer operation VirtioGpuDxe uses one virtio ring, for VIRTIO_GPU_CONTROL_QUEUE. Map it for bus master common buffer operation with VirtioRingMap(), so that it can be accessed equally by both guest and hypervisor even if an IOMMU is used. (VirtioRingInit() already allocates the ring suitably for this, see commit b0338c53297c, "OvmfPkg/VirtioLib: alloc VRING buffer with AllocateSharedPages()", 2017-08-23). Pass the resultant translation offset ("RingBaseShift"), from system memory address to bus master device address, to VIRTIO_SET_QUEUE_ADDRESS. Unmap the ring in all contexts where the ring becomes unused (these contexts are mutually exclusive): - in VirtioGpuInit(): the ring has been mapped, but we cannot complete the virtio initialization for another reason, - in VirtioGpuUninit(): the virtio initialization has succeeded, but VirtioGpuDriverBindingStart() fails for another reason, or VirtioGpuDriverBindingStop() unbinds the device after use, - in VirtioGpuExitBoot(): ExitBootServices() is called after VirtioGpuDriverBindingStart() has successfully bound the device. (Unmapping the ring does not change the UEFI memory map.) Cc: Ard Biesheuvel <ard.biesheuvel@linaro.org> Cc: Brijesh Singh <brijesh.singh@amd.com> Cc: Jordan Justen <jordan.l.justen@intel.com> Cc: Tom Lendacky <thomas.lendacky@amd.com> Contributed-under: TianoCore Contribution Agreement 1.1 Signed-off-by: Laszlo Ersek <lersek@redhat.com> Tested-by: Brijesh Singh <brijesh.singh@amd.com>
2017-08-26 16:00:30 +02:00
VgpuDev->VirtIo->UnmapSharedBuffer (VgpuDev->VirtIo, VgpuDev->RingMap);
VirtioRingUninit (VgpuDev->VirtIo, &VgpuDev->Ring);
}
/**
Allocate, zero and map memory, for bus master common buffer operation, to be
attached as backing store to a host-side VirtIo GPU resource.
@param[in] VgpuDev The VGPU_DEV object that represents the VirtIo GPU
device.
@param[in] NumberOfPages The number of whole pages to allocate and map.
@param[out] HostAddress The system memory address of the allocated area.
@param[out] DeviceAddress The bus master device address of the allocated
area. The VirtIo GPU device may be programmed to
access the allocated area through DeviceAddress;
DeviceAddress is to be passed to the
VirtioGpuResourceAttachBacking() function, as the
BackingStoreDeviceAddress parameter.
@param[out] Mapping A resulting token to pass to
VirtioGpuUnmapAndFreeBackingStore().
@retval EFI_SUCCESS The requested number of pages has been allocated, zeroed
and mapped.
@return Status codes propagated from
VgpuDev->VirtIo->AllocateSharedPages() and
VirtioMapAllBytesInSharedBuffer().
**/
EFI_STATUS
VirtioGpuAllocateZeroAndMapBackingStore (
IN VGPU_DEV *VgpuDev,
IN UINTN NumberOfPages,
OUT VOID **HostAddress,
OUT EFI_PHYSICAL_ADDRESS *DeviceAddress,
OUT VOID **Mapping
)
{
EFI_STATUS Status;
VOID *NewHostAddress;
Status = VgpuDev->VirtIo->AllocateSharedPages (
VgpuDev->VirtIo,
NumberOfPages,
&NewHostAddress
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Avoid exposing stale data to the device even temporarily: zero the area
// before mapping it.
//
ZeroMem (NewHostAddress, EFI_PAGES_TO_SIZE (NumberOfPages));
Status = VirtioMapAllBytesInSharedBuffer (
VgpuDev->VirtIo, // VirtIo
VirtioOperationBusMasterCommonBuffer, // Operation
NewHostAddress, // HostAddress
EFI_PAGES_TO_SIZE (NumberOfPages), // NumberOfBytes
DeviceAddress, // DeviceAddress
Mapping // Mapping
);
if (EFI_ERROR (Status)) {
goto FreeSharedPages;
}
*HostAddress = NewHostAddress;
return EFI_SUCCESS;
FreeSharedPages:
VgpuDev->VirtIo->FreeSharedPages (
VgpuDev->VirtIo,
NumberOfPages,
NewHostAddress
);
return Status;
}
/**
Unmap and free memory originally allocated and mapped with
VirtioGpuAllocateZeroAndMapBackingStore().
If the memory allocated and mapped with
VirtioGpuAllocateZeroAndMapBackingStore() was attached to a host-side VirtIo
GPU resource with VirtioGpuResourceAttachBacking(), then the caller is
responsible for detaching the backing store from the same resource, with
VirtioGpuResourceDetachBacking(), before calling this function.
@param[in] VgpuDev The VGPU_DEV object that represents the VirtIo GPU
device.
@param[in] NumberOfPages The NumberOfPages parameter originally passed to
VirtioGpuAllocateZeroAndMapBackingStore().
@param[in] HostAddress The HostAddress value originally output by
VirtioGpuAllocateZeroAndMapBackingStore().
@param[in] Mapping The token that was originally output by
VirtioGpuAllocateZeroAndMapBackingStore().
**/
VOID
VirtioGpuUnmapAndFreeBackingStore (
IN VGPU_DEV *VgpuDev,
IN UINTN NumberOfPages,
IN VOID *HostAddress,
IN VOID *Mapping
)
{
VgpuDev->VirtIo->UnmapSharedBuffer (
VgpuDev->VirtIo,
Mapping
);
VgpuDev->VirtIo->FreeSharedPages (
VgpuDev->VirtIo,
NumberOfPages,
HostAddress
);
}
/**
EFI_EVENT_NOTIFY function for the VGPU_DEV.ExitBoot event. It resets the
VirtIo device, causing it to release its resources and to forget its
configuration.
This function may only be called (that is, VGPU_DEV.ExitBoot may only be
signaled) after VirtioGpuInit() returns and before VirtioGpuUninit() is
called.
@param[in] Event Event whose notification function is being invoked.
@param[in] Context Pointer to the associated VGPU_DEV object.
**/
VOID
EFIAPI
VirtioGpuExitBoot (
IN EFI_EVENT Event,
IN VOID *Context
)
{
VGPU_DEV *VgpuDev;
DEBUG ((DEBUG_VERBOSE, "%a: Context=0x%p\n", __FUNCTION__, Context));
VgpuDev = Context;
VgpuDev->VirtIo->SetDeviceStatus (VgpuDev->VirtIo, 0);
}
/**
Internal utility function that sends a request to the VirtIo GPU device
model, awaits the answer from the host, and returns a status.
@param[in,out] VgpuDev The VGPU_DEV object that represents the VirtIo GPU
device. The caller is responsible to have
successfully invoked VirtioGpuInit() on VgpuDev
previously, while VirtioGpuUninit() must not have
been called on VgpuDev.
@param[in] RequestType The type of the request. The caller is responsible
for providing a VirtioGpuCmd* RequestType which, on
success, elicits a VirtioGpuRespOkNodata response
from the host.
@param[in] Fence Whether to enable fencing for this request. Fencing
forces the host to complete the command before
producing a response. If Fence is TRUE, then
VgpuDev->FenceId is consumed, and incremented.
@param[in,out] Header Pointer to the caller-allocated request object. The
request must start with VIRTIO_GPU_CONTROL_HEADER.
This function overwrites all fields of Header before
submitting the request to the host:
- it sets Type from RequestType,
- it sets Flags and FenceId based on Fence,
- it zeroes CtxId and Padding.
@param[in] RequestSize Size of the entire caller-allocated request object,
including the leading VIRTIO_GPU_CONTROL_HEADER.
@retval EFI_SUCCESS Operation successful.
@retval EFI_DEVICE_ERROR The host rejected the request. The host error
code has been logged on the EFI_D_ERROR level.
@return Codes for unexpected errors in VirtIo
messaging, or request/response
mapping/unmapping.
**/
STATIC
EFI_STATUS
VirtioGpuSendCommand (
IN OUT VGPU_DEV *VgpuDev,
IN VIRTIO_GPU_CONTROL_TYPE RequestType,
IN BOOLEAN Fence,
IN OUT volatile VIRTIO_GPU_CONTROL_HEADER *Header,
IN UINTN RequestSize
)
{
DESC_INDICES Indices;
volatile VIRTIO_GPU_CONTROL_HEADER Response;
EFI_STATUS Status;
UINT32 ResponseSize;
EFI_PHYSICAL_ADDRESS RequestDeviceAddress;
VOID *RequestMap;
EFI_PHYSICAL_ADDRESS ResponseDeviceAddress;
VOID *ResponseMap;
//
// Initialize Header.
//
Header->Type = RequestType;
if (Fence) {
Header->Flags = VIRTIO_GPU_FLAG_FENCE;
Header->FenceId = VgpuDev->FenceId++;
} else {
Header->Flags = 0;
Header->FenceId = 0;
}
Header->CtxId = 0;
Header->Padding = 0;
ASSERT (RequestSize >= sizeof *Header);
ASSERT (RequestSize <= MAX_UINT32);
//
// Map request and response to bus master device addresses.
//
Status = VirtioMapAllBytesInSharedBuffer (
VgpuDev->VirtIo,
VirtioOperationBusMasterRead,
(VOID *)Header,
RequestSize,
&RequestDeviceAddress,
&RequestMap
);
if (EFI_ERROR (Status)) {
return Status;
}
Status = VirtioMapAllBytesInSharedBuffer (
VgpuDev->VirtIo,
VirtioOperationBusMasterWrite,
(VOID *)&Response,
sizeof Response,
&ResponseDeviceAddress,
&ResponseMap
);
if (EFI_ERROR (Status)) {
goto UnmapRequest;
}
//
// Compose the descriptor chain.
//
VirtioPrepare (&VgpuDev->Ring, &Indices);
VirtioAppendDesc (
&VgpuDev->Ring,
RequestDeviceAddress,
(UINT32)RequestSize,
VRING_DESC_F_NEXT,
&Indices
);
VirtioAppendDesc (
&VgpuDev->Ring,
ResponseDeviceAddress,
(UINT32)sizeof Response,
VRING_DESC_F_WRITE,
&Indices
);
//
// Send the command.
//
Status = VirtioFlush (VgpuDev->VirtIo, VIRTIO_GPU_CONTROL_QUEUE,
&VgpuDev->Ring, &Indices, &ResponseSize);
if (EFI_ERROR (Status)) {
goto UnmapResponse;
}
//
// Verify response size.
//
if (ResponseSize != sizeof Response) {
DEBUG ((EFI_D_ERROR, "%a: malformed response to Request=0x%x\n",
__FUNCTION__, (UINT32)RequestType));
Status = EFI_PROTOCOL_ERROR;
goto UnmapResponse;
}
//
// Unmap response and request, in reverse order of mapping. On error, the
// respective mapping is invalidated anyway, only the data may not have been
// committed to system memory (in case of VirtioOperationBusMasterWrite).
//
Status = VgpuDev->VirtIo->UnmapSharedBuffer (VgpuDev->VirtIo, ResponseMap);
if (EFI_ERROR (Status)) {
goto UnmapRequest;
}
Status = VgpuDev->VirtIo->UnmapSharedBuffer (VgpuDev->VirtIo, RequestMap);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Parse the response.
//
if (Response.Type == VirtioGpuRespOkNodata) {
return EFI_SUCCESS;
}
DEBUG ((EFI_D_ERROR, "%a: Request=0x%x Response=0x%x\n", __FUNCTION__,
(UINT32)RequestType, Response.Type));
return EFI_DEVICE_ERROR;
UnmapResponse:
VgpuDev->VirtIo->UnmapSharedBuffer (VgpuDev->VirtIo, ResponseMap);
UnmapRequest:
VgpuDev->VirtIo->UnmapSharedBuffer (VgpuDev->VirtIo, RequestMap);
return Status;
}
/**
The following functions send requests to the VirtIo GPU device model, await
the answer from the host, and return a status. They share the following
interface details:
@param[in,out] VgpuDev The VGPU_DEV object that represents the VirtIo GPU
device. The caller is responsible to have
successfully invoked VirtioGpuInit() on VgpuDev
previously, while VirtioGpuUninit() must not have
been called on VgpuDev.
@retval EFI_INVALID_PARAMETER Invalid command-specific parameters were
detected by this driver.
@retval EFI_SUCCESS Operation successful.
@retval EFI_DEVICE_ERROR The host rejected the request. The host error
code has been logged on the EFI_D_ERROR level.
@return Codes for unexpected errors in VirtIo
messaging.
For the command-specific parameters, please consult the GPU Device section of
the VirtIo 1.0 specification (see references in
"OvmfPkg/Include/IndustryStandard/VirtioGpu.h").
**/
EFI_STATUS
VirtioGpuResourceCreate2d (
IN OUT VGPU_DEV *VgpuDev,
IN UINT32 ResourceId,
IN VIRTIO_GPU_FORMATS Format,
IN UINT32 Width,
IN UINT32 Height
)
{
volatile VIRTIO_GPU_RESOURCE_CREATE_2D Request;
if (ResourceId == 0) {
return EFI_INVALID_PARAMETER;
}
Request.ResourceId = ResourceId;
Request.Format = (UINT32)Format;
Request.Width = Width;
Request.Height = Height;
return VirtioGpuSendCommand (
VgpuDev,
VirtioGpuCmdResourceCreate2d,
FALSE, // Fence
&Request.Header,
sizeof Request
);
}
EFI_STATUS
VirtioGpuResourceUnref (
IN OUT VGPU_DEV *VgpuDev,
IN UINT32 ResourceId
)
{
volatile VIRTIO_GPU_RESOURCE_UNREF Request;
if (ResourceId == 0) {
return EFI_INVALID_PARAMETER;
}
Request.ResourceId = ResourceId;
Request.Padding = 0;
return VirtioGpuSendCommand (
VgpuDev,
VirtioGpuCmdResourceUnref,
FALSE, // Fence
&Request.Header,
sizeof Request
);
}
EFI_STATUS
VirtioGpuResourceAttachBacking (
IN OUT VGPU_DEV *VgpuDev,
IN UINT32 ResourceId,
IN EFI_PHYSICAL_ADDRESS BackingStoreDeviceAddress,
IN UINTN NumberOfPages
)
{
volatile VIRTIO_GPU_RESOURCE_ATTACH_BACKING Request;
if (ResourceId == 0) {
return EFI_INVALID_PARAMETER;
}
Request.ResourceId = ResourceId;
Request.NrEntries = 1;
Request.Entry.Addr = BackingStoreDeviceAddress;
Request.Entry.Length = (UINT32)EFI_PAGES_TO_SIZE (NumberOfPages);
Request.Entry.Padding = 0;
return VirtioGpuSendCommand (
VgpuDev,
VirtioGpuCmdResourceAttachBacking,
FALSE, // Fence
&Request.Header,
sizeof Request
);
}
EFI_STATUS
VirtioGpuResourceDetachBacking (
IN OUT VGPU_DEV *VgpuDev,
IN UINT32 ResourceId
)
{
volatile VIRTIO_GPU_RESOURCE_DETACH_BACKING Request;
if (ResourceId == 0) {
return EFI_INVALID_PARAMETER;
}
Request.ResourceId = ResourceId;
Request.Padding = 0;
//
// In this case, we set Fence to TRUE, because after this function returns,
// the caller might reasonably want to repurpose the backing pages
// immediately. Thus we should ensure that the host releases all references
// to the backing pages before we return.
//
return VirtioGpuSendCommand (
VgpuDev,
VirtioGpuCmdResourceDetachBacking,
TRUE, // Fence
&Request.Header,
sizeof Request
);
}
EFI_STATUS
VirtioGpuSetScanout (
IN OUT VGPU_DEV *VgpuDev,
IN UINT32 X,
IN UINT32 Y,
IN UINT32 Width,
IN UINT32 Height,
IN UINT32 ScanoutId,
IN UINT32 ResourceId
)
{
volatile VIRTIO_GPU_SET_SCANOUT Request;
//
// Unlike for most other commands, ResourceId=0 is valid; it
// is used to disable a scanout.
//
Request.Rectangle.X = X;
Request.Rectangle.Y = Y;
Request.Rectangle.Width = Width;
Request.Rectangle.Height = Height;
Request.ScanoutId = ScanoutId;
Request.ResourceId = ResourceId;
return VirtioGpuSendCommand (
VgpuDev,
VirtioGpuCmdSetScanout,
FALSE, // Fence
&Request.Header,
sizeof Request
);
}
EFI_STATUS
VirtioGpuTransferToHost2d (
IN OUT VGPU_DEV *VgpuDev,
IN UINT32 X,
IN UINT32 Y,
IN UINT32 Width,
IN UINT32 Height,
IN UINT64 Offset,
IN UINT32 ResourceId
)
{
volatile VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D Request;
if (ResourceId == 0) {
return EFI_INVALID_PARAMETER;
}
Request.Rectangle.X = X;
Request.Rectangle.Y = Y;
Request.Rectangle.Width = Width;
Request.Rectangle.Height = Height;
Request.Offset = Offset;
Request.ResourceId = ResourceId;
Request.Padding = 0;
return VirtioGpuSendCommand (
VgpuDev,
VirtioGpuCmdTransferToHost2d,
FALSE, // Fence
&Request.Header,
sizeof Request
);
}
EFI_STATUS
VirtioGpuResourceFlush (
IN OUT VGPU_DEV *VgpuDev,
IN UINT32 X,
IN UINT32 Y,
IN UINT32 Width,
IN UINT32 Height,
IN UINT32 ResourceId
)
{
volatile VIRTIO_GPU_RESOURCE_FLUSH Request;
if (ResourceId == 0) {
return EFI_INVALID_PARAMETER;
}
Request.Rectangle.X = X;
Request.Rectangle.Y = Y;
Request.Rectangle.Width = Width;
Request.Rectangle.Height = Height;
Request.ResourceId = ResourceId;
Request.Padding = 0;
return VirtioGpuSendCommand (
VgpuDev,
VirtioGpuCmdResourceFlush,
FALSE, // Fence
&Request.Header,
sizeof Request
);
}