1/** @file
2
3  Internal type and macro definitions for the Virtio GPU hybrid driver.
4
5  Copyright (C) 2016, Red Hat, Inc.
6
7  This program and the accompanying materials are licensed and made available
8  under the terms and conditions of the BSD License which accompanies this
9  distribution. The full text of the license may be found at
10  http://opensource.org/licenses/bsd-license.php
11
12  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT
13  WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
14
15**/
16
17#ifndef _VIRTIO_GPU_DXE_H_
18#define _VIRTIO_GPU_DXE_H_
19
20#include <IndustryStandard/VirtioGpu.h>
21#include <Library/DebugLib.h>
22#include <Library/UefiLib.h>
23#include <Protocol/GraphicsOutput.h>
24#include <Protocol/VirtioDevice.h>
25
26//
27// Forward declaration of VGPU_GOP.
28//
29typedef struct VGPU_GOP_STRUCT VGPU_GOP;
30
31//
32// The abstraction that directly corresponds to a Virtio GPU device.
33//
34// This structure will be installed on the handle that has the VirtIo Device
35// Protocol interface, with GUID gEfiCallerIdGuid. A similar trick is employed
36// in TerminalDxe, and it is necessary so that we can look up VGPU_DEV just
37// from the VirtIo Device Protocol handle in the Component Name 2 Protocol
38// implementation.
39//
40typedef struct {
41  //
42  // VirtIo represents access to the Virtio GPU device. Never NULL.
43  //
44  VIRTIO_DEVICE_PROTOCOL   *VirtIo;
45
46  //
47  // BusName carries a customized name for
48  // EFI_COMPONENT_NAME2_PROTOCOL.GetControllerName(). It is expressed in table
49  // form because it can theoretically support several languages. Never NULL.
50  //
51  EFI_UNICODE_STRING_TABLE *BusName;
52
53  //
54  // VirtIo ring used for VirtIo communication.
55  //
56  VRING                    Ring;
57
58  //
59  // Event to be signaled at ExitBootServices().
60  //
61  EFI_EVENT                ExitBoot;
62
63  //
64  // Common running counter for all VirtIo GPU requests that ask for fencing.
65  //
66  UINT64                   FenceId;
67
68  //
69  // The Child field references the GOP wrapper structure. If this pointer is
70  // NULL, then the hybrid driver has bound (i.e., started) the
71  // VIRTIO_DEVICE_PROTOCOL controller without producing the child GOP
72  // controller (that is, after Start() was called with RemainingDevicePath
73  // pointing to and End of Device Path node). Child can be created and
74  // destroyed, even repeatedly, independently of VGPU_DEV.
75  //
76  // In practice, this field represents the single head (scanout) that we
77  // support.
78  //
79  VGPU_GOP                 *Child;
80} VGPU_DEV;
81
82//
83// The Graphics Output Protocol wrapper structure.
84//
85#define VGPU_GOP_SIG SIGNATURE_64 ('V', 'G', 'P', 'U', '_', 'G', 'O', 'P')
86
87struct VGPU_GOP_STRUCT {
88  UINT64                               Signature;
89
90  //
91  // ParentBus points to the parent VGPU_DEV object. Never NULL.
92  //
93  VGPU_DEV                             *ParentBus;
94
95  //
96  // GopName carries a customized name for
97  // EFI_COMPONENT_NAME2_PROTOCOL.GetControllerName(). It is expressed in table
98  // form because it can theoretically support several languages. Never NULL.
99  //
100  EFI_UNICODE_STRING_TABLE             *GopName;
101
102  //
103  // GopHandle is the UEFI child handle that carries the device path ending
104  // with the ACPI ADR node, and the Graphics Output Protocol. Never NULL.
105  //
106  EFI_HANDLE                           GopHandle;
107
108  //
109  // The GopDevicePath field is the device path installed on GopHandle,
110  // ending with an ACPI ADR node. Never NULL.
111  //
112  EFI_DEVICE_PATH_PROTOCOL             *GopDevicePath;
113
114  //
115  // The Gop field is installed on the child handle as Graphics Output Protocol
116  // interface.
117  //
118  EFI_GRAPHICS_OUTPUT_PROTOCOL         Gop;
119
120  //
121  // Referenced by Gop.Mode, GopMode provides a summary about the supported
122  // graphics modes, and the current mode.
123  //
124  EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE    GopMode;
125
126  //
127  // Referenced by GopMode.Info, GopModeInfo provides detailed information
128  // about the current mode.
129  //
130  EFI_GRAPHICS_OUTPUT_MODE_INFORMATION GopModeInfo;
131
132  //
133  // Identifier of the 2D host resource that is in use by this head (scanout)
134  // of the VirtIo GPU device. Zero until the first successful -- internal --
135  // Gop.SetMode() call, never zero afterwards.
136  //
137  UINT32                               ResourceId;
138
139  //
140  // A number of whole pages providing the backing store for the 2D host
141  // resource identified by ResourceId above. NULL until the first successful
142  // -- internal -- Gop.SetMode() call, never NULL afterwards.
143  //
144  UINT32                               *BackingStore;
145  UINTN                                NumberOfPages;
146};
147
148//
149// VirtIo GPU initialization, and commands (primitives) for the GPU device.
150//
151/**
152  Configure the VirtIo GPU device that underlies VgpuDev.
153
154  @param[in,out] VgpuDev  The VGPU_DEV object to set up VirtIo messaging for.
155                          On input, the caller is responsible for having
156                          initialized VgpuDev->VirtIo. On output, VgpuDev->Ring
157                          has been initialized, and synchronous VirtIo GPU
158                          commands (primitives) can be submitted to the device.
159
160  @retval EFI_SUCCESS      VirtIo GPU configuration successful.
161
162  @retval EFI_UNSUPPORTED  The host-side configuration of the VirtIo GPU is not
163                           supported by this driver.
164
165  @retval                  Error codes from underlying functions.
166**/
167EFI_STATUS
168VirtioGpuInit (
169  IN OUT VGPU_DEV *VgpuDev
170  );
171
172/**
173  De-configure the VirtIo GPU device that underlies VgpuDev.
174
175  @param[in,out] VgpuDev  The VGPU_DEV object to tear down VirtIo messaging
176                          for. On input, the caller is responsible for having
177                          called VirtioGpuInit(). On output, VgpuDev->Ring has
178                          been uninitialized; VirtIo GPU commands (primitives)
179                          can no longer be submitted to the device.
180**/
181VOID
182VirtioGpuUninit (
183  IN OUT VGPU_DEV *VgpuDev
184  );
185
186/**
187  EFI_EVENT_NOTIFY function for the VGPU_DEV.ExitBoot event. It resets the
188  VirtIo device, causing it to release its resources and to forget its
189  configuration.
190
191  This function may only be called (that is, VGPU_DEV.ExitBoot may only be
192  signaled) after VirtioGpuInit() returns and before VirtioGpuUninit() is
193  called.
194
195  @param[in] Event    Event whose notification function is being invoked.
196
197  @param[in] Context  Pointer to the associated VGPU_DEV object.
198**/
199VOID
200EFIAPI
201VirtioGpuExitBoot (
202  IN EFI_EVENT Event,
203  IN VOID      *Context
204  );
205
206/**
207  The following functions send requests to the VirtIo GPU device model, await
208  the answer from the host, and return a status. They share the following
209  interface details:
210
211  @param[in,out] VgpuDev  The VGPU_DEV object that represents the VirtIo GPU
212                          device. The caller is responsible to have
213                          successfully invoked VirtioGpuInit() on VgpuDev
214                          previously, while VirtioGpuUninit() must not have
215                          been called on VgpuDev.
216
217  @retval EFI_INVALID_PARAMETER  Invalid command-specific parameters were
218                                 detected by this driver.
219
220  @retval EFI_SUCCESS            Operation successful.
221
222  @retval EFI_DEVICE_ERROR       The host rejected the request. The host error
223                                 code has been logged on the EFI_D_ERROR level.
224
225  @return                        Codes for unexpected errors in VirtIo
226                                 messaging.
227
228  For the command-specific parameters, please consult the GPU Device section of
229  the VirtIo 1.0 specification (see references in
230  "OvmfPkg/Include/IndustryStandard/VirtioGpu.h").
231**/
232EFI_STATUS
233VirtioGpuResourceCreate2d (
234  IN OUT VGPU_DEV           *VgpuDev,
235  IN     UINT32             ResourceId,
236  IN     VIRTIO_GPU_FORMATS Format,
237  IN     UINT32             Width,
238  IN     UINT32             Height
239  );
240
241EFI_STATUS
242VirtioGpuResourceUnref (
243  IN OUT VGPU_DEV *VgpuDev,
244  IN     UINT32   ResourceId
245  );
246
247EFI_STATUS
248VirtioGpuResourceAttachBacking (
249  IN OUT VGPU_DEV *VgpuDev,
250  IN     UINT32   ResourceId,
251  IN     VOID     *FirstBackingPage,
252  IN     UINTN    NumberOfPages
253  );
254
255EFI_STATUS
256VirtioGpuResourceDetachBacking (
257  IN OUT VGPU_DEV *VgpuDev,
258  IN     UINT32   ResourceId
259  );
260
261EFI_STATUS
262VirtioGpuSetScanout (
263  IN OUT VGPU_DEV *VgpuDev,
264  IN     UINT32   X,
265  IN     UINT32   Y,
266  IN     UINT32   Width,
267  IN     UINT32   Height,
268  IN     UINT32   ScanoutId,
269  IN     UINT32   ResourceId
270  );
271
272EFI_STATUS
273VirtioGpuTransferToHost2d (
274  IN OUT VGPU_DEV *VgpuDev,
275  IN     UINT32   X,
276  IN     UINT32   Y,
277  IN     UINT32   Width,
278  IN     UINT32   Height,
279  IN     UINT64   Offset,
280  IN     UINT32   ResourceId
281  );
282
283EFI_STATUS
284VirtioGpuResourceFlush (
285  IN OUT VGPU_DEV *VgpuDev,
286  IN     UINT32   X,
287  IN     UINT32   Y,
288  IN     UINT32   Width,
289  IN     UINT32   Height,
290  IN     UINT32   ResourceId
291  );
292
293/**
294  Release guest-side and host-side resources that are related to an initialized
295  VGPU_GOP.Gop.
296
297  param[in,out] VgpuGop  The VGPU_GOP object to release resources for.
298
299                         On input, the caller is responsible for having called
300                         VgpuGop->Gop.SetMode() at least once successfully.
301                         (This is equivalent to the requirement that
302                         VgpuGop->BackingStore be non-NULL. It is also
303                         equivalent to the requirement that VgpuGop->ResourceId
304                         be nonzero.)
305
306                         On output, resources will be released, and
307                         VgpuGop->BackingStore and VgpuGop->ResourceId will be
308                         nulled.
309
310  param[in] DisableHead  Whether this head (scanout) currently references the
311                         resource identified by VgpuGop->ResourceId. Only pass
312                         FALSE when VgpuGop->Gop.SetMode() calls this function
313                         while switching between modes, and set it to TRUE
314                         every other time.
315**/
316VOID
317ReleaseGopResources (
318  IN OUT VGPU_GOP *VgpuGop,
319  IN     BOOLEAN  DisableHead
320  );
321
322//
323// Template for initializing VGPU_GOP.Gop.
324//
325extern CONST EFI_GRAPHICS_OUTPUT_PROTOCOL mGopTemplate;
326
327#endif // _VIRTIO_GPU_DXE_H_
328