VirtioPciDevice.c@ 99404

Last change on this file since 99404 was 99404, checked in by vboxsync, 22 months ago
Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
Property svn:eol-style set to `native`
File size: 20.6 KB

Line
1	/** @file
2
3	This driver produces Virtio Device Protocol instances for Virtio PCI devices.
4
5	Copyright (C) 2012, Red Hat, Inc.
6	Copyright (c) 2012 - 2016, Intel Corporation. All rights reserved.<BR>
7	Copyright (C) 2013, ARM Ltd.
8	Copyright (C) 2017, AMD Inc, All rights reserved.<BR>
9
10	SPDX-License-Identifier: BSD-2-Clause-Patent
11
12	**/
13
14	#include <IndustryStandard/Pci.h>
15	#include <Library/BaseMemoryLib.h>
16	#include <Library/DebugLib.h>
17	#include <Library/MemoryAllocationLib.h>
18	#include <Library/UefiBootServicesTableLib.h>
19	#include <Library/UefiLib.h>
20
21	#include "VirtioPciDevice.h"
22
23	STATIC VIRTIO_DEVICE_PROTOCOL mDeviceProtocolTemplate = {
24	0, // Revision
25	0, // SubSystemDeviceId
26	VirtioPciGetDeviceFeatures, // GetDeviceFeatures
27	VirtioPciSetGuestFeatures, // SetGuestFeatures
28	VirtioPciSetQueueAddress, // SetQueueAddress
29	VirtioPciSetQueueSel, // SetQueueSel
30	VirtioPciSetQueueNotify, // SetQueueNotify
31	VirtioPciSetQueueAlignment, // SetQueueAlignment
32	VirtioPciSetPageSize, // SetPageSize
33	VirtioPciGetQueueSize, // GetQueueNumMax
34	VirtioPciSetQueueSize, // SetQueueNum
35	VirtioPciGetDeviceStatus, // GetDeviceStatus
36	VirtioPciSetDeviceStatus, // SetDeviceStatus
37	VirtioPciDeviceWrite, // WriteDevice
38	VirtioPciDeviceRead, // ReadDevice
39	VirtioPciAllocateSharedPages, // AllocateSharedPages
40	VirtioPciFreeSharedPages, // FreeSharedPages
41	VirtioPciMapSharedBuffer, // MapSharedBuffer
42	VirtioPciUnmapSharedBuffer, // UnmapSharedBuffer
43	};
44
45	/**
46
47	Read a word from Region 0 of the device specified by PciIo.
48
49	Region 0 must be an iomem region. This is an internal function for the PCI
50	implementation of the protocol.
51
52	@param[in] Dev Virtio PCI device.
53
54	@param[in] FieldOffset Source offset.
55
56	@param[in] FieldSize Source field size, must be in { 1, 2, 4, 8 }.
57
58	@param[in] BufferSize Number of bytes available in the target buffer. Must
59	equal FieldSize.
60
61	@param[out] Buffer Target buffer.
62
63
64	@return Status code returned by PciIo->Io.Read().
65
66	**/
67	EFI_STATUS
68	EFIAPI
69	VirtioPciIoRead (
70	IN VIRTIO_PCI_DEVICE *Dev,
71	IN UINTN FieldOffset,
72	IN UINTN FieldSize,
73	IN UINTN BufferSize,
74	OUT VOID *Buffer
75	)
76	{
77	UINTN Count;
78	EFI_PCI_IO_PROTOCOL_WIDTH Width;
79	EFI_PCI_IO_PROTOCOL *PciIo;
80
81	ASSERT (FieldSize == BufferSize);
82
83	PciIo = Dev->PciIo;
84	Count = 1;
85
86	switch (FieldSize) {
87	case 1:
88	Width = EfiPciIoWidthUint8;
89	break;
90
91	case 2:
92	Width = EfiPciIoWidthUint16;
93	break;
94
95	case 8:
96	//
97	// The 64bit PCI I/O is broken down into two 32bit reads to prevent
98	// any alignment or width issues.
99	// The UEFI spec says under EFI_PCI_IO_PROTOCOL.Io.Write():
100	//
101	// The I/O operations are carried out exactly as requested. The caller
102	// is responsible for any alignment and I/O width issues which the
103	// bus, device, platform, or type of I/O might require. For example on
104	// some platforms, width requests of EfiPciIoWidthUint64 do not work.
105	//
106	Count = 2;
107
108	//
109	// fall through
110	//
111	case 4:
112	Width = EfiPciIoWidthUint32;
113	break;
114
115	default:
116	ASSERT (FALSE);
117	return EFI_INVALID_PARAMETER;
118	}
119
120	return PciIo->Io.Read (
121	PciIo,
122	Width,
123	PCI_BAR_IDX0,
124	FieldOffset,
125	Count,
126	Buffer
127	);
128	}
129
130	/**
131
132	Write a word into Region 0 of the device specified by PciIo.
133
134	Region 0 must be an iomem region. This is an internal function for the PCI
135	implementation of the protocol.
136
137	@param[in] Dev Virtio PCI device.
138
139	@param[in] FieldOffset Destination offset.
140
141	@param[in] FieldSize Destination field size, must be in { 1, 2, 4, 8 }.
142
143	@param[in] Value Little endian value to write, converted to UINT64.
144	The least significant FieldSize bytes will be used.
145
146
147	@return Status code returned by PciIo->Io.Write().
148
149	**/
150	EFI_STATUS
151	EFIAPI
152	VirtioPciIoWrite (
153	IN VIRTIO_PCI_DEVICE *Dev,
154	IN UINTN FieldOffset,
155	IN UINTN FieldSize,
156	IN UINT64 Value
157	)
158	{
159	UINTN Count;
160	EFI_PCI_IO_PROTOCOL_WIDTH Width;
161	EFI_PCI_IO_PROTOCOL *PciIo;
162
163	PciIo = Dev->PciIo;
164	Count = 1;
165
166	switch (FieldSize) {
167	case 1:
168	Width = EfiPciIoWidthUint8;
169	break;
170
171	case 2:
172	Width = EfiPciIoWidthUint16;
173	break;
174
175	case 8:
176	//
177	// The 64bit PCI I/O is broken down into two 32bit writes to prevent
178	// any alignment or width issues.
179	// The UEFI spec says under EFI_PCI_IO_PROTOCOL.Io.Write():
180	//
181	// The I/O operations are carried out exactly as requested. The caller
182	// is responsible for any alignment and I/O width issues which the
183	// bus, device, platform, or type of I/O might require. For example on
184	// some platforms, width requests of EfiPciIoWidthUint64 do not work
185	//
186	Count = Count * 2;
187
188	//
189	// fall through
190	//
191	case 4:
192	Width = EfiPciIoWidthUint32;
193	break;
194
195	default:
196	ASSERT (FALSE);
197	return EFI_INVALID_PARAMETER;
198	}
199
200	return PciIo->Io.Write (
201	PciIo,
202	Width,
203	PCI_BAR_IDX0,
204	FieldOffset,
205	Count,
206	&Value
207	);
208	}
209
210	/**
211
212	Device probe function for this driver.
213
214	The DXE core calls this function for any given device in order to see if the
215	driver can drive the device.
216
217	@param[in] This The EFI_DRIVER_BINDING_PROTOCOL object
218	incorporating this driver (independently of
219	any device).
220
221	@param[in] DeviceHandle The device to probe.
222
223	@param[in] RemainingDevicePath Relevant only for bus drivers, ignored.
224
225
226	@retval EFI_SUCCESS The driver supports the device being probed.
227
228	@retval EFI_UNSUPPORTED Based on virtio-pci discovery, we do not support
229	the device.
230
231	@return Error codes from the OpenProtocol() boot service or
232	the PciIo protocol.
233
234	**/
235	STATIC
236	EFI_STATUS
237	EFIAPI
238	VirtioPciDeviceBindingSupported (
239	IN EFI_DRIVER_BINDING_PROTOCOL *This,
240	IN EFI_HANDLE DeviceHandle,
241	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
242	)
243	{
244	EFI_STATUS Status;
245	EFI_PCI_IO_PROTOCOL *PciIo;
246	PCI_TYPE00 Pci;
247
248	//
249	// Attempt to open the device with the PciIo set of interfaces. On success,
250	// the protocol is "instantiated" for the PCI device. Covers duplicate open
251	// attempts (EFI_ALREADY_STARTED).
252	//
253	Status = gBS->OpenProtocol (
254	DeviceHandle, // candidate device
255	&gEfiPciIoProtocolGuid, // for generic PCI access
256	(VOID **)&PciIo, // handle to instantiate
257	This->DriverBindingHandle, // requestor driver identity
258	DeviceHandle, // ControllerHandle, according to
259	// the UEFI Driver Model
260	EFI_OPEN_PROTOCOL_BY_DRIVER // get exclusive PciIo access to
261	// the device; to be released
262	);
263	if (EFI_ERROR (Status)) {
264	return Status;
265	}
266
267	//
268	// Read entire PCI configuration header for more extensive check ahead.
269	//
270	Status = PciIo->Pci.Read (
271	PciIo, // (protocol, device)
272	// handle
273	EfiPciIoWidthUint32, // access width & copy
274	// mode
275	0, // Offset
276	sizeof Pci / sizeof (UINT32), // Count
277	&Pci // target buffer
278	);
279
280	if (Status == EFI_SUCCESS) {
281	//
282	// virtio-0.9.5, 2.1 PCI Discovery
283	//
284	if ((Pci.Hdr.VendorId == VIRTIO_VENDOR_ID) &&
285	(Pci.Hdr.DeviceId >= 0x1000) &&
286	(Pci.Hdr.DeviceId <= 0x103F) &&
287	(Pci.Hdr.RevisionID == 0x00))
288	{
289	Status = EFI_SUCCESS;
290	} else {
291	Status = EFI_UNSUPPORTED;
292	}
293	}
294
295	//
296	// We needed PCI IO access only transitorily, to see whether we support the
297	// device or not.
298	//
299	gBS->CloseProtocol (
300	DeviceHandle,
301	&gEfiPciIoProtocolGuid,
302	This->DriverBindingHandle,
303	DeviceHandle
304	);
305
306	return Status;
307	}
308
309	/**
310
311	Initialize the VirtIo PCI Device
312
313	@param[in, out] Dev The driver instance to configure. The caller is
314	responsible for Device->PciIo's validity (ie. working IO
315	access to the underlying virtio-pci device).
316
317	@retval EFI_SUCCESS Setup complete.
318
319	@retval EFI_UNSUPPORTED The underlying IO device doesn't support the
320	provided address offset and read size.
321
322	@return Error codes from PciIo->Pci.Read().
323
324	**/
325	STATIC
326	EFI_STATUS
327	EFIAPI
328	VirtioPciInit (
329	IN OUT VIRTIO_PCI_DEVICE *Device
330	)
331	{
332	EFI_STATUS Status;
333	EFI_PCI_IO_PROTOCOL *PciIo;
334	PCI_TYPE00 Pci;
335
336	ASSERT (Device != NULL);
337	PciIo = Device->PciIo;
338	ASSERT (PciIo != NULL);
339	ASSERT (PciIo->Pci.Read != NULL);
340
341	Status = PciIo->Pci.Read (
342	PciIo, // (protocol, device)
343	// handle
344	EfiPciIoWidthUint32, // access width & copy
345	// mode
346	0, // Offset
347	sizeof (Pci) / sizeof (UINT32), // Count
348	&Pci // target buffer
349	);
350	if (EFI_ERROR (Status)) {
351	return Status;
352	}
353
354	//
355	// Copy protocol template
356	//
357	CopyMem (
358	&Device->VirtioDevice,
359	&mDeviceProtocolTemplate,
360	sizeof (VIRTIO_DEVICE_PROTOCOL)
361	);
362
363	//
364	// Initialize the protocol interface attributes
365	//
366	Device->VirtioDevice.Revision = VIRTIO_SPEC_REVISION (0, 9, 5);
367	Device->VirtioDevice.SubSystemDeviceId = Pci.Device.SubsystemID;
368
369	//
370	// Note: We don't support the MSI-X capability. If we did,
371	// the offset would become 24 after enabling MSI-X.
372	//
373	Device->DeviceSpecificConfigurationOffset =
374	VIRTIO_DEVICE_SPECIFIC_CONFIGURATION_OFFSET_PCI;
375
376	return EFI_SUCCESS;
377	}
378
379	/**
380
381	Uninitialize the internals of a virtio-pci device that has been successfully
382	set up with VirtioPciInit().
383
384	@param[in, out] Dev The device to clean up.
385
386	**/
387	STATIC
388	VOID
389	EFIAPI
390	VirtioPciUninit (
391	IN OUT VIRTIO_PCI_DEVICE *Device
392	)
393	{
394	// Note: This function mirrors VirtioPciInit() that does not allocate any
395	// resources - there's nothing to free here.
396	}
397
398	/**
399
400	After we've pronounced support for a specific device in
401	DriverBindingSupported(), we start managing said device (passed in by the
402	Driver Execution Environment) with the following service.
403
404	See DriverBindingSupported() for specification references.
405
406	@param[in] This The EFI_DRIVER_BINDING_PROTOCOL object
407	incorporating this driver (independently of
408	any device).
409
410	@param[in] DeviceHandle The supported device to drive.
411
412	@param[in] RemainingDevicePath Relevant only for bus drivers, ignored.
413
414
415	@retval EFI_SUCCESS Driver instance has been created and
416	initialized for the virtio-pci device, it
417	is now accessible via VIRTIO_DEVICE_PROTOCOL.
418
419	@retval EFI_OUT_OF_RESOURCES Memory allocation failed.
420
421	@return Error codes from the OpenProtocol() boot
422	service, the PciIo protocol, VirtioPciInit(),
423	or the InstallProtocolInterface() boot service.
424
425	**/
426	STATIC
427	EFI_STATUS
428	EFIAPI
429	VirtioPciDeviceBindingStart (
430	IN EFI_DRIVER_BINDING_PROTOCOL *This,
431	IN EFI_HANDLE DeviceHandle,
432	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
433	)
434	{
435	VIRTIO_PCI_DEVICE *Device;
436	EFI_STATUS Status;
437
438	Device = (VIRTIO_PCI_DEVICE )AllocateZeroPool (sizeof Device);
439	if (Device == NULL) {
440	return EFI_OUT_OF_RESOURCES;
441	}
442
443	Status = gBS->OpenProtocol (
444	DeviceHandle,
445	&gEfiPciIoProtocolGuid,
446	(VOID **)&Device->PciIo,
447	This->DriverBindingHandle,
448	DeviceHandle,
449	EFI_OPEN_PROTOCOL_BY_DRIVER
450	);
451	if (EFI_ERROR (Status)) {
452	goto FreeVirtioPci;
453	}
454
455	//
456	// We must retain and ultimately restore the original PCI attributes of the
457	// device. See Driver Writer's Guide for UEFI 2.3.1 v1.01, 18.3 PCI drivers /
458	// 18.3.2 Start() and Stop().
459	//
460	// The third parameter ("Attributes", input) is ignored by the Get operation.
461	// The fourth parameter ("Result", output) is ignored by the Enable and Set
462	// operations.
463	//
464	// For virtio-pci we only need IO space access.
465	//
466	Status = Device->PciIo->Attributes (
467	Device->PciIo,
468	EfiPciIoAttributeOperationGet,
469	0,
470	&Device->OriginalPciAttributes
471	);
472	if (EFI_ERROR (Status)) {
473	goto ClosePciIo;
474	}
475
476	Status = Device->PciIo->Attributes (
477	Device->PciIo,
478	EfiPciIoAttributeOperationEnable,
479	(EFI_PCI_IO_ATTRIBUTE_IO \|
480	EFI_PCI_IO_ATTRIBUTE_BUS_MASTER),
481	NULL
482	);
483	if (EFI_ERROR (Status)) {
484	goto ClosePciIo;
485	}
486
487	//
488	// PCI IO access granted, configure protocol instance
489	//
490
491	Status = VirtioPciInit (Device);
492	if (EFI_ERROR (Status)) {
493	goto RestorePciAttributes;
494	}
495
496	//
497	// Setup complete, attempt to export the driver instance's VirtioDevice
498	// interface.
499	//
500	Device->Signature = VIRTIO_PCI_DEVICE_SIGNATURE;
501	Status = gBS->InstallProtocolInterface (
502	&DeviceHandle,
503	&gVirtioDeviceProtocolGuid,
504	EFI_NATIVE_INTERFACE,
505	&Device->VirtioDevice
506	);
507	if (EFI_ERROR (Status)) {
508	goto UninitDev;
509	}
510
511	return EFI_SUCCESS;
512
513	UninitDev:
514	VirtioPciUninit (Device);
515
516	RestorePciAttributes:
517	Device->PciIo->Attributes (
518	Device->PciIo,
519	EfiPciIoAttributeOperationSet,
520	Device->OriginalPciAttributes,
521	NULL
522	);
523
524	ClosePciIo:
525	gBS->CloseProtocol (
526	DeviceHandle,
527	&gEfiPciIoProtocolGuid,
528	This->DriverBindingHandle,
529	DeviceHandle
530	);
531
532	FreeVirtioPci:
533	FreePool (Device);
534
535	return Status;
536	}
537
538	/**
539
540	Stop driving the Virtio PCI device
541
542	@param[in] This The EFI_DRIVER_BINDING_PROTOCOL object
543	incorporating this driver (independently of any
544	device).
545
546	@param[in] DeviceHandle Stop driving this device.
547
548	@param[in] NumberOfChildren Since this function belongs to a device driver
549	only (as opposed to a bus driver), the caller
550	environment sets NumberOfChildren to zero, and
551	we ignore it.
552
553	@param[in] ChildHandleBuffer Ignored (corresponding to NumberOfChildren).
554
555	@retval EFI_SUCCESS Driver instance has been stopped and the PCI
556	configuration attributes have been restored.
557
558	@return Error codes from the OpenProtocol() or
559	CloseProtocol(), UninstallProtocolInterface()
560	boot services.
561
562	**/
563	STATIC
564	EFI_STATUS
565	EFIAPI
566	VirtioPciDeviceBindingStop (
567	IN EFI_DRIVER_BINDING_PROTOCOL *This,
568	IN EFI_HANDLE DeviceHandle,
569	IN UINTN NumberOfChildren,
570	IN EFI_HANDLE *ChildHandleBuffer
571	)
572	{
573	EFI_STATUS Status;
574	VIRTIO_DEVICE_PROTOCOL *VirtioDevice;
575	VIRTIO_PCI_DEVICE *Device;
576
577	Status = gBS->OpenProtocol (
578	DeviceHandle, // candidate device
579	&gVirtioDeviceProtocolGuid, // retrieve the VirtIo iface
580	(VOID **)&VirtioDevice, // target pointer
581	This->DriverBindingHandle, // requestor driver identity
582	DeviceHandle, // requesting lookup for dev.
583	EFI_OPEN_PROTOCOL_GET_PROTOCOL // lookup only, no ref. added
584	);
585	if (EFI_ERROR (Status)) {
586	return Status;
587	}
588
589	Device = VIRTIO_PCI_DEVICE_FROM_VIRTIO_DEVICE (VirtioDevice);
590
591	//
592	// Handle Stop() requests for in-use driver instances gracefully.
593	//
594	Status = gBS->UninstallProtocolInterface (
595	DeviceHandle,
596	&gVirtioDeviceProtocolGuid,
597	&Device->VirtioDevice
598	);
599	if (EFI_ERROR (Status)) {
600	return Status;
601	}
602
603	VirtioPciUninit (Device);
604
605	Device->PciIo->Attributes (
606	Device->PciIo,
607	EfiPciIoAttributeOperationSet,
608	Device->OriginalPciAttributes,
609	NULL
610	);
611
612	Status = gBS->CloseProtocol (
613	DeviceHandle,
614	&gEfiPciIoProtocolGuid,
615	This->DriverBindingHandle,
616	DeviceHandle
617	);
618
619	FreePool (Device);
620
621	return Status;
622	}
623
624	//
625	// The static object that groups the Supported() (ie. probe), Start() and
626	// Stop() functions of the driver together. Refer to UEFI Spec 2.3.1 + Errata
627	// C, 10.1 EFI Driver Binding Protocol.
628	//
629	STATIC EFI_DRIVER_BINDING_PROTOCOL gDriverBinding = {
630	&VirtioPciDeviceBindingSupported,
631	&VirtioPciDeviceBindingStart,
632	&VirtioPciDeviceBindingStop,
633	0x10, // Version, must be in [0x10 .. 0xFFFFFFEF] for IHV-developed drivers
634	NULL, // ImageHandle, to be overwritten by
635	// EfiLibInstallDriverBindingComponentName2() in VirtioPciEntryPoint()
636	NULL // DriverBindingHandle, ditto
637	};
638
639	//
640	// The purpose of the following scaffolding (EFI_COMPONENT_NAME_PROTOCOL and
641	// EFI_COMPONENT_NAME2_PROTOCOL implementation) is to format the driver's name
642	// in English, for display on standard console devices. This is recommended for
643	// UEFI drivers that follow the UEFI Driver Model. Refer to the Driver Writer's
644	// Guide for UEFI 2.3.1 v1.01, 11 UEFI Driver and Controller Names.
645	//
646	STATIC
647	EFI_UNICODE_STRING_TABLE mDriverNameTable[] = {
648	{ "eng;en", L"Virtio PCI Driver" },
649	{ NULL, NULL }
650	};
651
652	STATIC
653	EFI_COMPONENT_NAME_PROTOCOL gComponentName;
654
655	EFI_STATUS
656	EFIAPI
657	VirtioPciGetDriverName (
658	IN EFI_COMPONENT_NAME_PROTOCOL *This,
659	IN CHAR8 *Language,
660	OUT CHAR16 **DriverName
661	)
662	{
663	return LookupUnicodeString2 (
664	Language,
665	This->SupportedLanguages,
666	mDriverNameTable,
667	DriverName,
668	(BOOLEAN)(This == &gComponentName) // Iso639Language
669	);
670	}
671
672	EFI_STATUS
673	EFIAPI
674	VirtioPciGetDeviceName (
675	IN EFI_COMPONENT_NAME_PROTOCOL *This,
676	IN EFI_HANDLE DeviceHandle,
677	IN EFI_HANDLE ChildHandle,
678	IN CHAR8 *Language,
679	OUT CHAR16 **ControllerName
680	)
681	{
682	return EFI_UNSUPPORTED;
683	}
684
685	STATIC
686	EFI_COMPONENT_NAME_PROTOCOL gComponentName = {
687	&VirtioPciGetDriverName,
688	&VirtioPciGetDeviceName,
689	"eng" // SupportedLanguages, ISO 639-2 language codes
690	};
691
692	STATIC
693	EFI_COMPONENT_NAME2_PROTOCOL gComponentName2 = {
694	(EFI_COMPONENT_NAME2_GET_DRIVER_NAME)&VirtioPciGetDriverName,
695	(EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME)&VirtioPciGetDeviceName,
696	"en" // SupportedLanguages, RFC 4646 language codes
697	};
698
699	//
700	// Entry point of this driver.
701	//
702	EFI_STATUS
703	EFIAPI
704	VirtioPciDeviceEntryPoint (
705	IN EFI_HANDLE ImageHandle,
706	IN EFI_SYSTEM_TABLE *SystemTable
707	)
708	{
709	return EfiLibInstallDriverBindingComponentName2 (
710	ImageHandle,
711	SystemTable,
712	&gDriverBinding,
713	ImageHandle,
714	&gComponentName,
715	&gComponentName2
716	);
717	}

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

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/OvmfPkg/VirtioPciDeviceDxe/VirtioPciDevice.c@ 99404

Download in other formats: