Commands.c@ 77662

Last change on this file since 77662 was 77662, checked in by vboxsync, 6 years ago
EFI: First step in UDK2018 merge. Does not build yet.
Property svn:eol-style set to `native`
File size: 22.4 KB

Line
1	/** @file
2
3	VirtIo GPU initialization, and commands (primitives) for the GPU device.
4
5	Copyright (C) 2016, Red Hat, Inc.
6	Copyright (c) 2017, AMD Inc, All rights reserved.<BR>
7
8	This program and the accompanying materials are licensed and made available
9	under the terms and conditions of the BSD License which accompanies this
10	distribution. The full text of the license may be found at
11	http://opensource.org/licenses/bsd-license.php
12
13	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT
14	WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
15
16	**/
17
18	#include <Library/VirtioLib.h>
19
20	#include "VirtioGpu.h"
21
22	/**
23	Configure the VirtIo GPU device that underlies VgpuDev.
24
25	@param[in,out] VgpuDev The VGPU_DEV object to set up VirtIo messaging for.
26	On input, the caller is responsible for having
27	initialized VgpuDev->VirtIo. On output, VgpuDev->Ring
28	has been initialized, and synchronous VirtIo GPU
29	commands (primitives) can be submitted to the device.
30
31	@retval EFI_SUCCESS VirtIo GPU configuration successful.
32
33	@retval EFI_UNSUPPORTED The host-side configuration of the VirtIo GPU is not
34	supported by this driver.
35
36	@retval Error codes from underlying functions.
37	**/
38	EFI_STATUS
39	VirtioGpuInit (
40	IN OUT VGPU_DEV *VgpuDev
41	)
42	{
43	UINT8 NextDevStat;
44	EFI_STATUS Status;
45	UINT64 Features;
46	UINT16 QueueSize;
47	UINT64 RingBaseShift;
48
49	//
50	// Execute virtio-v1.0-cs04, 3.1.1 Driver Requirements: Device
51	// Initialization.
52	//
53	// 1. Reset the device.
54	//
55	NextDevStat = 0;
56	Status = VgpuDev->VirtIo->SetDeviceStatus (VgpuDev->VirtIo, NextDevStat);
57	if (EFI_ERROR (Status)) {
58	goto Failed;
59	}
60
61	//
62	// 2. Set the ACKNOWLEDGE status bit [...]
63	//
64	NextDevStat \|= VSTAT_ACK;
65	Status = VgpuDev->VirtIo->SetDeviceStatus (VgpuDev->VirtIo, NextDevStat);
66	if (EFI_ERROR (Status)) {
67	goto Failed;
68	}
69
70	//
71	// 3. Set the DRIVER status bit [...]
72	//
73	NextDevStat \|= VSTAT_DRIVER;
74	Status = VgpuDev->VirtIo->SetDeviceStatus (VgpuDev->VirtIo, NextDevStat);
75	if (EFI_ERROR (Status)) {
76	goto Failed;
77	}
78
79	//
80	// 4. Read device feature bits...
81	//
82	Status = VgpuDev->VirtIo->GetDeviceFeatures (VgpuDev->VirtIo, &Features);
83	if (EFI_ERROR (Status)) {
84	goto Failed;
85	}
86	if ((Features & VIRTIO_F_VERSION_1) == 0) {
87	Status = EFI_UNSUPPORTED;
88	goto Failed;
89	}
90	//
91	// We only want the most basic 2D features.
92	//
93	Features &= VIRTIO_F_VERSION_1 \| VIRTIO_F_IOMMU_PLATFORM;
94
95	//
96	// ... and write the subset of feature bits understood by the [...] driver to
97	// the device. [...]
98	// 5. Set the FEATURES_OK status bit.
99	// 6. Re-read device status to ensure the FEATURES_OK bit is still set [...]
100	//
101	Status = Virtio10WriteFeatures (VgpuDev->VirtIo, Features, &NextDevStat);
102	if (EFI_ERROR (Status)) {
103	goto Failed;
104	}
105
106	//
107	// 7. Perform device-specific setup, including discovery of virtqueues for
108	// the device [...]
109	//
110	Status = VgpuDev->VirtIo->SetQueueSel (VgpuDev->VirtIo,
111	VIRTIO_GPU_CONTROL_QUEUE);
112	if (EFI_ERROR (Status)) {
113	goto Failed;
114	}
115	Status = VgpuDev->VirtIo->GetQueueNumMax (VgpuDev->VirtIo, &QueueSize);
116	if (EFI_ERROR (Status)) {
117	goto Failed;
118	}
119
120	//
121	// We implement each VirtIo GPU command that we use with two descriptors:
122	// request, response.
123	//
124	if (QueueSize < 2) {
125	Status = EFI_UNSUPPORTED;
126	goto Failed;
127	}
128
129	//
130	// [...] population of virtqueues [...]
131	//
132	Status = VirtioRingInit (VgpuDev->VirtIo, QueueSize, &VgpuDev->Ring);
133	if (EFI_ERROR (Status)) {
134	goto Failed;
135	}
136	//
137	// If anything fails from here on, we have to release the ring.
138	//
139	Status = VirtioRingMap (
140	VgpuDev->VirtIo,
141	&VgpuDev->Ring,
142	&RingBaseShift,
143	&VgpuDev->RingMap
144	);
145	if (EFI_ERROR (Status)) {
146	goto ReleaseQueue;
147	}
148	//
149	// If anything fails from here on, we have to unmap the ring.
150	//
151	Status = VgpuDev->VirtIo->SetQueueAddress (
152	VgpuDev->VirtIo,
153	&VgpuDev->Ring,
154	RingBaseShift
155	);
156	if (EFI_ERROR (Status)) {
157	goto UnmapQueue;
158	}
159
160	//
161	// 8. Set the DRIVER_OK status bit.
162	//
163	NextDevStat \|= VSTAT_DRIVER_OK;
164	Status = VgpuDev->VirtIo->SetDeviceStatus (VgpuDev->VirtIo, NextDevStat);
165	if (EFI_ERROR (Status)) {
166	goto UnmapQueue;
167	}
168
169	return EFI_SUCCESS;
170
171	UnmapQueue:
172	VgpuDev->VirtIo->UnmapSharedBuffer (VgpuDev->VirtIo, VgpuDev->RingMap);
173
174	ReleaseQueue:
175	VirtioRingUninit (VgpuDev->VirtIo, &VgpuDev->Ring);
176
177	Failed:
178	//
179	// If any of these steps go irrecoverably wrong, the driver SHOULD set the
180	// FAILED status bit to indicate that it has given up on the device (it can
181	// reset the device later to restart if desired). [...]
182	//
183	// VirtIo access failure here should not mask the original error.
184	//
185	NextDevStat \|= VSTAT_FAILED;
186	VgpuDev->VirtIo->SetDeviceStatus (VgpuDev->VirtIo, NextDevStat);
187
188	return Status;
189	}
190
191	/**
192	De-configure the VirtIo GPU device that underlies VgpuDev.
193
194	@param[in,out] VgpuDev The VGPU_DEV object to tear down VirtIo messaging
195	for. On input, the caller is responsible for having
196	called VirtioGpuInit(). On output, VgpuDev->Ring has
197	been uninitialized; VirtIo GPU commands (primitives)
198	can no longer be submitted to the device.
199	**/
200	VOID
201	VirtioGpuUninit (
202	IN OUT VGPU_DEV *VgpuDev
203	)
204	{
205	//
206	// Resetting the VirtIo device makes it release its resources and forget its
207	// configuration.
208	//
209	VgpuDev->VirtIo->SetDeviceStatus (VgpuDev->VirtIo, 0);
210	VgpuDev->VirtIo->UnmapSharedBuffer (VgpuDev->VirtIo, VgpuDev->RingMap);
211	VirtioRingUninit (VgpuDev->VirtIo, &VgpuDev->Ring);
212	}
213
214	/**
215	Allocate, zero and map memory, for bus master common buffer operation, to be
216	attached as backing store to a host-side VirtIo GPU resource.
217
218	@param[in] VgpuDev The VGPU_DEV object that represents the VirtIo GPU
219	device.
220
221	@param[in] NumberOfPages The number of whole pages to allocate and map.
222
223	@param[out] HostAddress The system memory address of the allocated area.
224
225	@param[out] DeviceAddress The bus master device address of the allocated
226	area. The VirtIo GPU device may be programmed to
227	access the allocated area through DeviceAddress;
228	DeviceAddress is to be passed to the
229	VirtioGpuResourceAttachBacking() function, as the
230	BackingStoreDeviceAddress parameter.
231
232	@param[out] Mapping A resulting token to pass to
233	VirtioGpuUnmapAndFreeBackingStore().
234
235	@retval EFI_SUCCESS The requested number of pages has been allocated, zeroed
236	and mapped.
237
238	@return Status codes propagated from
239	VgpuDev->VirtIo->AllocateSharedPages() and
240	VirtioMapAllBytesInSharedBuffer().
241	**/
242	EFI_STATUS
243	VirtioGpuAllocateZeroAndMapBackingStore (
244	IN VGPU_DEV *VgpuDev,
245	IN UINTN NumberOfPages,
246	OUT VOID **HostAddress,
247	OUT EFI_PHYSICAL_ADDRESS *DeviceAddress,
248	OUT VOID **Mapping
249	)
250	{
251	EFI_STATUS Status;
252	VOID *NewHostAddress;
253
254	Status = VgpuDev->VirtIo->AllocateSharedPages (
255	VgpuDev->VirtIo,
256	NumberOfPages,
257	&NewHostAddress
258	);
259	if (EFI_ERROR (Status)) {
260	return Status;
261	}
262
263	//
264	// Avoid exposing stale data to the device even temporarily: zero the area
265	// before mapping it.
266	//
267	ZeroMem (NewHostAddress, EFI_PAGES_TO_SIZE (NumberOfPages));
268
269	Status = VirtioMapAllBytesInSharedBuffer (
270	VgpuDev->VirtIo, // VirtIo
271	VirtioOperationBusMasterCommonBuffer, // Operation
272	NewHostAddress, // HostAddress
273	EFI_PAGES_TO_SIZE (NumberOfPages), // NumberOfBytes
274	DeviceAddress, // DeviceAddress
275	Mapping // Mapping
276	);
277	if (EFI_ERROR (Status)) {
278	goto FreeSharedPages;
279	}
280
281	*HostAddress = NewHostAddress;
282	return EFI_SUCCESS;
283
284	FreeSharedPages:
285	VgpuDev->VirtIo->FreeSharedPages (
286	VgpuDev->VirtIo,
287	NumberOfPages,
288	NewHostAddress
289	);
290	return Status;
291	}
292
293	/**
294	Unmap and free memory originally allocated and mapped with
295	VirtioGpuAllocateZeroAndMapBackingStore().
296
297	If the memory allocated and mapped with
298	VirtioGpuAllocateZeroAndMapBackingStore() was attached to a host-side VirtIo
299	GPU resource with VirtioGpuResourceAttachBacking(), then the caller is
300	responsible for detaching the backing store from the same resource, with
301	VirtioGpuResourceDetachBacking(), before calling this function.
302
303	@param[in] VgpuDev The VGPU_DEV object that represents the VirtIo GPU
304	device.
305
306	@param[in] NumberOfPages The NumberOfPages parameter originally passed to
307	VirtioGpuAllocateZeroAndMapBackingStore().
308
309	@param[in] HostAddress The HostAddress value originally output by
310	VirtioGpuAllocateZeroAndMapBackingStore().
311
312	@param[in] Mapping The token that was originally output by
313	VirtioGpuAllocateZeroAndMapBackingStore().
314	**/
315	VOID
316	VirtioGpuUnmapAndFreeBackingStore (
317	IN VGPU_DEV *VgpuDev,
318	IN UINTN NumberOfPages,
319	IN VOID *HostAddress,
320	IN VOID *Mapping
321	)
322	{
323	VgpuDev->VirtIo->UnmapSharedBuffer (
324	VgpuDev->VirtIo,
325	Mapping
326	);
327	VgpuDev->VirtIo->FreeSharedPages (
328	VgpuDev->VirtIo,
329	NumberOfPages,
330	HostAddress
331	);
332	}
333
334	/**
335	EFI_EVENT_NOTIFY function for the VGPU_DEV.ExitBoot event. It resets the
336	VirtIo device, causing it to release its resources and to forget its
337	configuration.
338
339	This function may only be called (that is, VGPU_DEV.ExitBoot may only be
340	signaled) after VirtioGpuInit() returns and before VirtioGpuUninit() is
341	called.
342
343	@param[in] Event Event whose notification function is being invoked.
344
345	@param[in] Context Pointer to the associated VGPU_DEV object.
346	**/
347	VOID
348	EFIAPI
349	VirtioGpuExitBoot (
350	IN EFI_EVENT Event,
351	IN VOID *Context
352	)
353	{
354	VGPU_DEV *VgpuDev;
355
356	DEBUG ((DEBUG_VERBOSE, "%a: Context=0x%p\n", __FUNCTION__, Context));
357	VgpuDev = Context;
358	VgpuDev->VirtIo->SetDeviceStatus (VgpuDev->VirtIo, 0);
359	}
360
361	/**
362	Internal utility function that sends a request to the VirtIo GPU device
363	model, awaits the answer from the host, and returns a status.
364
365	@param[in,out] VgpuDev The VGPU_DEV object that represents the VirtIo GPU
366	device. The caller is responsible to have
367	successfully invoked VirtioGpuInit() on VgpuDev
368	previously, while VirtioGpuUninit() must not have
369	been called on VgpuDev.
370
371	@param[in] RequestType The type of the request. The caller is responsible
372	for providing a VirtioGpuCmd* RequestType which, on
373	success, elicits a VirtioGpuRespOkNodata response
374	from the host.
375
376	@param[in] Fence Whether to enable fencing for this request. Fencing
377	forces the host to complete the command before
378	producing a response. If Fence is TRUE, then
379	VgpuDev->FenceId is consumed, and incremented.
380
381	@param[in,out] Header Pointer to the caller-allocated request object. The
382	request must start with VIRTIO_GPU_CONTROL_HEADER.
383	This function overwrites all fields of Header before
384	submitting the request to the host:
385
386	- it sets Type from RequestType,
387
388	- it sets Flags and FenceId based on Fence,
389
390	- it zeroes CtxId and Padding.
391
392	@param[in] RequestSize Size of the entire caller-allocated request object,
393	including the leading VIRTIO_GPU_CONTROL_HEADER.
394
395	@retval EFI_SUCCESS Operation successful.
396
397	@retval EFI_DEVICE_ERROR The host rejected the request. The host error
398	code has been logged on the EFI_D_ERROR level.
399
400	@return Codes for unexpected errors in VirtIo
401	messaging, or request/response
402	mapping/unmapping.
403	**/
404	STATIC
405	EFI_STATUS
406	VirtioGpuSendCommand (
407	IN OUT VGPU_DEV *VgpuDev,
408	IN VIRTIO_GPU_CONTROL_TYPE RequestType,
409	IN BOOLEAN Fence,
410	IN OUT volatile VIRTIO_GPU_CONTROL_HEADER *Header,
411	IN UINTN RequestSize
412	)
413	{
414	DESC_INDICES Indices;
415	volatile VIRTIO_GPU_CONTROL_HEADER Response;
416	EFI_STATUS Status;
417	UINT32 ResponseSize;
418	EFI_PHYSICAL_ADDRESS RequestDeviceAddress;
419	VOID *RequestMap;
420	EFI_PHYSICAL_ADDRESS ResponseDeviceAddress;
421	VOID *ResponseMap;
422
423	//
424	// Initialize Header.
425	//
426	Header->Type = RequestType;
427	if (Fence) {
428	Header->Flags = VIRTIO_GPU_FLAG_FENCE;
429	Header->FenceId = VgpuDev->FenceId++;
430	} else {
431	Header->Flags = 0;
432	Header->FenceId = 0;
433	}
434	Header->CtxId = 0;
435	Header->Padding = 0;
436
437	ASSERT (RequestSize >= sizeof *Header);
438	ASSERT (RequestSize <= MAX_UINT32);
439
440	//
441	// Map request and response to bus master device addresses.
442	//
443	Status = VirtioMapAllBytesInSharedBuffer (
444	VgpuDev->VirtIo,
445	VirtioOperationBusMasterRead,
446	(VOID *)Header,
447	RequestSize,
448	&RequestDeviceAddress,
449	&RequestMap
450	);
451	if (EFI_ERROR (Status)) {
452	return Status;
453	}
454	Status = VirtioMapAllBytesInSharedBuffer (
455	VgpuDev->VirtIo,
456	VirtioOperationBusMasterWrite,
457	(VOID *)&Response,
458	sizeof Response,
459	&ResponseDeviceAddress,
460	&ResponseMap
461	);
462	if (EFI_ERROR (Status)) {
463	goto UnmapRequest;
464	}
465
466	//
467	// Compose the descriptor chain.
468	//
469	VirtioPrepare (&VgpuDev->Ring, &Indices);
470	VirtioAppendDesc (
471	&VgpuDev->Ring,
472	RequestDeviceAddress,
473	(UINT32)RequestSize,
474	VRING_DESC_F_NEXT,
475	&Indices
476	);
477	VirtioAppendDesc (
478	&VgpuDev->Ring,
479	ResponseDeviceAddress,
480	(UINT32)sizeof Response,
481	VRING_DESC_F_WRITE,
482	&Indices
483	);
484
485	//
486	// Send the command.
487	//
488	Status = VirtioFlush (VgpuDev->VirtIo, VIRTIO_GPU_CONTROL_QUEUE,
489	&VgpuDev->Ring, &Indices, &ResponseSize);
490	if (EFI_ERROR (Status)) {
491	goto UnmapResponse;
492	}
493
494	//
495	// Verify response size.
496	//
497	if (ResponseSize != sizeof Response) {
498	DEBUG ((EFI_D_ERROR, "%a: malformed response to Request=0x%x\n",
499	__FUNCTION__, (UINT32)RequestType));
500	Status = EFI_PROTOCOL_ERROR;
501	goto UnmapResponse;
502	}
503
504	//
505	// Unmap response and request, in reverse order of mapping. On error, the
506	// respective mapping is invalidated anyway, only the data may not have been
507	// committed to system memory (in case of VirtioOperationBusMasterWrite).
508	//
509	Status = VgpuDev->VirtIo->UnmapSharedBuffer (VgpuDev->VirtIo, ResponseMap);
510	if (EFI_ERROR (Status)) {
511	goto UnmapRequest;
512	}
513	Status = VgpuDev->VirtIo->UnmapSharedBuffer (VgpuDev->VirtIo, RequestMap);
514	if (EFI_ERROR (Status)) {
515	return Status;
516	}
517
518	//
519	// Parse the response.
520	//
521	if (Response.Type == VirtioGpuRespOkNodata) {
522	return EFI_SUCCESS;
523	}
524
525	DEBUG ((EFI_D_ERROR, "%a: Request=0x%x Response=0x%x\n", __FUNCTION__,
526	(UINT32)RequestType, Response.Type));
527	return EFI_DEVICE_ERROR;
528
529	UnmapResponse:
530	VgpuDev->VirtIo->UnmapSharedBuffer (VgpuDev->VirtIo, ResponseMap);
531
532	UnmapRequest:
533	VgpuDev->VirtIo->UnmapSharedBuffer (VgpuDev->VirtIo, RequestMap);
534
535	return Status;
536	}
537
538	/**
539	The following functions send requests to the VirtIo GPU device model, await
540	the answer from the host, and return a status. They share the following
541	interface details:
542
543	@param[in,out] VgpuDev The VGPU_DEV object that represents the VirtIo GPU
544	device. The caller is responsible to have
545	successfully invoked VirtioGpuInit() on VgpuDev
546	previously, while VirtioGpuUninit() must not have
547	been called on VgpuDev.
548
549	@retval EFI_INVALID_PARAMETER Invalid command-specific parameters were
550	detected by this driver.
551
552	@retval EFI_SUCCESS Operation successful.
553
554	@retval EFI_DEVICE_ERROR The host rejected the request. The host error
555	code has been logged on the EFI_D_ERROR level.
556
557	@return Codes for unexpected errors in VirtIo
558	messaging.
559
560	For the command-specific parameters, please consult the GPU Device section of
561	the VirtIo 1.0 specification (see references in
562	"OvmfPkg/Include/IndustryStandard/VirtioGpu.h").
563	**/
564	EFI_STATUS
565	VirtioGpuResourceCreate2d (
566	IN OUT VGPU_DEV *VgpuDev,
567	IN UINT32 ResourceId,
568	IN VIRTIO_GPU_FORMATS Format,
569	IN UINT32 Width,
570	IN UINT32 Height
571	)
572	{
573	volatile VIRTIO_GPU_RESOURCE_CREATE_2D Request;
574
575	if (ResourceId == 0) {
576	return EFI_INVALID_PARAMETER;
577	}
578
579	Request.ResourceId = ResourceId;
580	Request.Format = (UINT32)Format;
581	Request.Width = Width;
582	Request.Height = Height;
583
584	return VirtioGpuSendCommand (
585	VgpuDev,
586	VirtioGpuCmdResourceCreate2d,
587	FALSE, // Fence
588	&Request.Header,
589	sizeof Request
590	);
591	}
592
593	EFI_STATUS
594	VirtioGpuResourceUnref (
595	IN OUT VGPU_DEV *VgpuDev,
596	IN UINT32 ResourceId
597	)
598	{
599	volatile VIRTIO_GPU_RESOURCE_UNREF Request;
600
601	if (ResourceId == 0) {
602	return EFI_INVALID_PARAMETER;
603	}
604
605	Request.ResourceId = ResourceId;
606	Request.Padding = 0;
607
608	return VirtioGpuSendCommand (
609	VgpuDev,
610	VirtioGpuCmdResourceUnref,
611	FALSE, // Fence
612	&Request.Header,
613	sizeof Request
614	);
615	}
616
617	EFI_STATUS
618	VirtioGpuResourceAttachBacking (
619	IN OUT VGPU_DEV *VgpuDev,
620	IN UINT32 ResourceId,
621	IN EFI_PHYSICAL_ADDRESS BackingStoreDeviceAddress,
622	IN UINTN NumberOfPages
623	)
624	{
625	volatile VIRTIO_GPU_RESOURCE_ATTACH_BACKING Request;
626
627	if (ResourceId == 0) {
628	return EFI_INVALID_PARAMETER;
629	}
630
631	Request.ResourceId = ResourceId;
632	Request.NrEntries = 1;
633	Request.Entry.Addr = BackingStoreDeviceAddress;
634	Request.Entry.Length = (UINT32)EFI_PAGES_TO_SIZE (NumberOfPages);
635	Request.Entry.Padding = 0;
636
637	return VirtioGpuSendCommand (
638	VgpuDev,
639	VirtioGpuCmdResourceAttachBacking,
640	FALSE, // Fence
641	&Request.Header,
642	sizeof Request
643	);
644	}
645
646	EFI_STATUS
647	VirtioGpuResourceDetachBacking (
648	IN OUT VGPU_DEV *VgpuDev,
649	IN UINT32 ResourceId
650	)
651	{
652	volatile VIRTIO_GPU_RESOURCE_DETACH_BACKING Request;
653
654	if (ResourceId == 0) {
655	return EFI_INVALID_PARAMETER;
656	}
657
658	Request.ResourceId = ResourceId;
659	Request.Padding = 0;
660
661	//
662	// In this case, we set Fence to TRUE, because after this function returns,
663	// the caller might reasonably want to repurpose the backing pages
664	// immediately. Thus we should ensure that the host releases all references
665	// to the backing pages before we return.
666	//
667	return VirtioGpuSendCommand (
668	VgpuDev,
669	VirtioGpuCmdResourceDetachBacking,
670	TRUE, // Fence
671	&Request.Header,
672	sizeof Request
673	);
674	}
675
676	EFI_STATUS
677	VirtioGpuSetScanout (
678	IN OUT VGPU_DEV *VgpuDev,
679	IN UINT32 X,
680	IN UINT32 Y,
681	IN UINT32 Width,
682	IN UINT32 Height,
683	IN UINT32 ScanoutId,
684	IN UINT32 ResourceId
685	)
686	{
687	volatile VIRTIO_GPU_SET_SCANOUT Request;
688
689	//
690	// Unlike for most other commands, ResourceId=0 is valid; it
691	// is used to disable a scanout.
692	//
693	Request.Rectangle.X = X;
694	Request.Rectangle.Y = Y;
695	Request.Rectangle.Width = Width;
696	Request.Rectangle.Height = Height;
697	Request.ScanoutId = ScanoutId;
698	Request.ResourceId = ResourceId;
699
700	return VirtioGpuSendCommand (
701	VgpuDev,
702	VirtioGpuCmdSetScanout,
703	FALSE, // Fence
704	&Request.Header,
705	sizeof Request
706	);
707	}
708
709	EFI_STATUS
710	VirtioGpuTransferToHost2d (
711	IN OUT VGPU_DEV *VgpuDev,
712	IN UINT32 X,
713	IN UINT32 Y,
714	IN UINT32 Width,
715	IN UINT32 Height,
716	IN UINT64 Offset,
717	IN UINT32 ResourceId
718	)
719	{
720	volatile VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D Request;
721
722	if (ResourceId == 0) {
723	return EFI_INVALID_PARAMETER;
724	}
725
726	Request.Rectangle.X = X;
727	Request.Rectangle.Y = Y;
728	Request.Rectangle.Width = Width;
729	Request.Rectangle.Height = Height;
730	Request.Offset = Offset;
731	Request.ResourceId = ResourceId;
732	Request.Padding = 0;
733
734	return VirtioGpuSendCommand (
735	VgpuDev,
736	VirtioGpuCmdTransferToHost2d,
737	FALSE, // Fence
738	&Request.Header,
739	sizeof Request
740	);
741	}
742
743	EFI_STATUS
744	VirtioGpuResourceFlush (
745	IN OUT VGPU_DEV *VgpuDev,
746	IN UINT32 X,
747	IN UINT32 Y,
748	IN UINT32 Width,
749	IN UINT32 Height,
750	IN UINT32 ResourceId
751	)
752	{
753	volatile VIRTIO_GPU_RESOURCE_FLUSH Request;
754
755	if (ResourceId == 0) {
756	return EFI_INVALID_PARAMETER;
757	}
758
759	Request.Rectangle.X = X;
760	Request.Rectangle.Y = Y;
761	Request.Rectangle.Width = Width;
762	Request.Rectangle.Height = Height;
763	Request.ResourceId = ResourceId;
764	Request.Padding = 0;
765
766	return VirtioGpuSendCommand (
767	VgpuDev,
768	VirtioGpuCmdResourceFlush,
769	FALSE, // Fence
770	&Request.Header,
771	sizeof Request
772	);
773	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/OvmfPkg/VirtioGpuDxe/Commands.c@ 77662

Download in other formats: