VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/OvmfPkg/VirtioRngDxe/VirtioRng.c@ 85716

Last change on this file since 85716 was 80721, checked in by vboxsync, 5 years ago

Devices/EFI/FirmwareNew: Start upgrade process to edk2-stable201908 (compiles on Windows and works to some extent), bugref:4643
  • Property svn:eol-style set to native
File size: 20.4 KB
Line 
1/** @file
2
3 This driver produces EFI_RNG_PROTOCOL instances for virtio-rng devices.
4
5 The implementation is based on OvmfPkg/VirtioScsiDxe/VirtioScsi.c
6
7 Copyright (C) 2012, Red Hat, Inc.
8 Copyright (c) 2012 - 2014, Intel Corporation. All rights reserved.<BR>
9 Copyright (c) 2017, AMD Inc, All rights reserved.<BR>
10
11 This driver:
12
13 Copyright (C) 2016, Linaro Ltd.
14
15 SPDX-License-Identifier: BSD-2-Clause-Patent
16
17**/
18
19#include <Library/BaseMemoryLib.h>
20#include <Library/DebugLib.h>
21#include <Library/MemoryAllocationLib.h>
22#include <Library/UefiBootServicesTableLib.h>
23#include <Library/UefiLib.h>
24#include <Library/VirtioLib.h>
25
26#include "VirtioRng.h"
27
28/**
29 Returns information about the random number generation implementation.
30
31 @param[in] This A pointer to the EFI_RNG_PROTOCOL
32 instance.
33 @param[in,out] RNGAlgorithmListSize On input, the size in bytes of
34 RNGAlgorithmList.
35 On output with a return code of
36 EFI_SUCCESS, the size in bytes of the
37 data returned in RNGAlgorithmList. On
38 output with a return code of
39 EFI_BUFFER_TOO_SMALL, the size of
40 RNGAlgorithmList required to obtain the
41 list.
42 @param[out] RNGAlgorithmList A caller-allocated memory buffer filled
43 by the driver with one EFI_RNG_ALGORITHM
44 element for each supported RNG algorithm.
45 The list must not change across multiple
46 calls to the same driver. The first
47 algorithm in the list is the default
48 algorithm for the driver.
49
50 @retval EFI_SUCCESS The RNG algorithm list was returned
51 successfully.
52 @retval EFI_UNSUPPORTED The services is not supported by this
53 driver.
54 @retval EFI_DEVICE_ERROR The list of algorithms could not be
55 retrieved due to a hardware or firmware
56 error.
57 @retval EFI_INVALID_PARAMETER One or more of the parameters are
58 incorrect.
59 @retval EFI_BUFFER_TOO_SMALL The buffer RNGAlgorithmList is too small
60 to hold the result.
61
62**/
63STATIC
64EFI_STATUS
65EFIAPI
66VirtioRngGetInfo (
67 IN EFI_RNG_PROTOCOL *This,
68 IN OUT UINTN *RNGAlgorithmListSize,
69 OUT EFI_RNG_ALGORITHM *RNGAlgorithmList
70 )
71{
72 if (This == NULL || RNGAlgorithmListSize == NULL) {
73 return EFI_INVALID_PARAMETER;
74 }
75
76 if (*RNGAlgorithmListSize < sizeof (EFI_RNG_ALGORITHM)) {
77 *RNGAlgorithmListSize = sizeof (EFI_RNG_ALGORITHM);
78 return EFI_BUFFER_TOO_SMALL;
79 }
80
81 if (RNGAlgorithmList == NULL) {
82 return EFI_INVALID_PARAMETER;
83 }
84
85 *RNGAlgorithmListSize = sizeof (EFI_RNG_ALGORITHM);
86 CopyGuid (RNGAlgorithmList, &gEfiRngAlgorithmRaw);
87
88 return EFI_SUCCESS;
89}
90
91/**
92 Produces and returns an RNG value using either the default or specified RNG
93 algorithm.
94
95 @param[in] This A pointer to the EFI_RNG_PROTOCOL
96 instance.
97 @param[in] RNGAlgorithm A pointer to the EFI_RNG_ALGORITHM that
98 identifies the RNG algorithm to use. May
99 be NULL in which case the function will
100 use its default RNG algorithm.
101 @param[in] RNGValueLength The length in bytes of the memory buffer
102 pointed to by RNGValue. The driver shall
103 return exactly this numbers of bytes.
104 @param[out] RNGValue A caller-allocated memory buffer filled
105 by the driver with the resulting RNG
106 value.
107
108 @retval EFI_SUCCESS The RNG value was returned successfully.
109 @retval EFI_UNSUPPORTED The algorithm specified by RNGAlgorithm
110 is not supported by this driver.
111 @retval EFI_DEVICE_ERROR An RNG value could not be retrieved due
112 to a hardware or firmware error.
113 @retval EFI_NOT_READY There is not enough random data available
114 to satisfy the length requested by
115 RNGValueLength.
116 @retval EFI_INVALID_PARAMETER RNGValue is NULL or RNGValueLength is
117 zero.
118
119**/
120STATIC
121EFI_STATUS
122EFIAPI
123VirtioRngGetRNG (
124 IN EFI_RNG_PROTOCOL *This,
125 IN EFI_RNG_ALGORITHM *RNGAlgorithm, OPTIONAL
126 IN UINTN RNGValueLength,
127 OUT UINT8 *RNGValue
128 )
129{
130 VIRTIO_RNG_DEV *Dev;
131 DESC_INDICES Indices;
132 volatile UINT8 *Buffer;
133 UINTN Index;
134 UINT32 Len;
135 UINT32 BufferSize;
136 EFI_STATUS Status;
137 EFI_PHYSICAL_ADDRESS DeviceAddress;
138 VOID *Mapping;
139
140 if (This == NULL || RNGValueLength == 0 || RNGValue == NULL) {
141 return EFI_INVALID_PARAMETER;
142 }
143
144 //
145 // We only support the raw algorithm, so reject requests for anything else
146 //
147 if (RNGAlgorithm != NULL &&
148 !CompareGuid (RNGAlgorithm, &gEfiRngAlgorithmRaw)) {
149 return EFI_UNSUPPORTED;
150 }
151
152 Buffer = (volatile UINT8 *)AllocatePool (RNGValueLength);
153 if (Buffer == NULL) {
154 return EFI_DEVICE_ERROR;
155 }
156
157 Dev = VIRTIO_ENTROPY_SOURCE_FROM_RNG (This);
158 //
159 // Map Buffer's system phyiscal address to device address
160 //
161 Status = VirtioMapAllBytesInSharedBuffer (
162 Dev->VirtIo,
163 VirtioOperationBusMasterWrite,
164 (VOID *)Buffer,
165 RNGValueLength,
166 &DeviceAddress,
167 &Mapping
168 );
169 if (EFI_ERROR (Status)) {
170 Status = EFI_DEVICE_ERROR;
171 goto FreeBuffer;
172 }
173
174 //
175 // The Virtio RNG device may return less data than we asked it to, and can
176 // only return MAX_UINT32 bytes per invocation. So loop as long as needed to
177 // get all the entropy we were asked for.
178 //
179 for (Index = 0; Index < RNGValueLength; Index += Len) {
180 BufferSize = (UINT32)MIN (RNGValueLength - Index, (UINTN)MAX_UINT32);
181
182 VirtioPrepare (&Dev->Ring, &Indices);
183 VirtioAppendDesc (&Dev->Ring,
184 DeviceAddress + Index,
185 BufferSize,
186 VRING_DESC_F_WRITE,
187 &Indices);
188
189 if (VirtioFlush (Dev->VirtIo, 0, &Dev->Ring, &Indices, &Len) !=
190 EFI_SUCCESS) {
191 Status = EFI_DEVICE_ERROR;
192 goto UnmapBuffer;
193 }
194 ASSERT (Len > 0);
195 ASSERT (Len <= BufferSize);
196 }
197
198 //
199 // Unmap the device buffer before accessing it.
200 //
201 Status = Dev->VirtIo->UnmapSharedBuffer (Dev->VirtIo, Mapping);
202 if (EFI_ERROR (Status)) {
203 Status = EFI_DEVICE_ERROR;
204 goto FreeBuffer;
205 }
206
207 for (Index = 0; Index < RNGValueLength; Index++) {
208 RNGValue[Index] = Buffer[Index];
209 }
210 Status = EFI_SUCCESS;
211
212UnmapBuffer:
213 //
214 // If we are reached here due to the error then unmap the buffer otherwise
215 // the buffer is already unmapped after VirtioFlush().
216 //
217 if (EFI_ERROR (Status)) {
218 Dev->VirtIo->UnmapSharedBuffer (Dev->VirtIo, Mapping);
219 }
220
221FreeBuffer:
222 FreePool ((VOID *)Buffer);
223 return Status;
224}
225
226STATIC
227EFI_STATUS
228EFIAPI
229VirtioRngInit (
230 IN OUT VIRTIO_RNG_DEV *Dev
231 )
232{
233 UINT8 NextDevStat;
234 EFI_STATUS Status;
235 UINT16 QueueSize;
236 UINT64 Features;
237 UINT64 RingBaseShift;
238
239 //
240 // Execute virtio-0.9.5, 2.2.1 Device Initialization Sequence.
241 //
242 NextDevStat = 0; // step 1 -- reset device
243 Status = Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat);
244 if (EFI_ERROR (Status)) {
245 goto Failed;
246 }
247
248 NextDevStat |= VSTAT_ACK; // step 2 -- acknowledge device presence
249 Status = Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat);
250 if (EFI_ERROR (Status)) {
251 goto Failed;
252 }
253
254 NextDevStat |= VSTAT_DRIVER; // step 3 -- we know how to drive it
255 Status = Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat);
256 if (EFI_ERROR (Status)) {
257 goto Failed;
258 }
259
260 //
261 // Set Page Size - MMIO VirtIo Specific
262 //
263 Status = Dev->VirtIo->SetPageSize (Dev->VirtIo, EFI_PAGE_SIZE);
264 if (EFI_ERROR (Status)) {
265 goto Failed;
266 }
267
268 //
269 // step 4a -- retrieve and validate features
270 //
271 Status = Dev->VirtIo->GetDeviceFeatures (Dev->VirtIo, &Features);
272 if (EFI_ERROR (Status)) {
273 goto Failed;
274 }
275
276 Features &= VIRTIO_F_VERSION_1 | VIRTIO_F_IOMMU_PLATFORM;
277
278 //
279 // In virtio-1.0, feature negotiation is expected to complete before queue
280 // discovery, and the device can also reject the selected set of features.
281 //
282 if (Dev->VirtIo->Revision >= VIRTIO_SPEC_REVISION (1, 0, 0)) {
283 Status = Virtio10WriteFeatures (Dev->VirtIo, Features, &NextDevStat);
284 if (EFI_ERROR (Status)) {
285 goto Failed;
286 }
287 }
288
289 //
290 // step 4b -- allocate request virtqueue, just use #0
291 //
292 Status = Dev->VirtIo->SetQueueSel (Dev->VirtIo, 0);
293 if (EFI_ERROR (Status)) {
294 goto Failed;
295 }
296 Status = Dev->VirtIo->GetQueueNumMax (Dev->VirtIo, &QueueSize);
297 if (EFI_ERROR (Status)) {
298 goto Failed;
299 }
300
301 //
302 // VirtioRngGetRNG() uses one descriptor
303 //
304 if (QueueSize < 1) {
305 Status = EFI_UNSUPPORTED;
306 goto Failed;
307 }
308
309 Status = VirtioRingInit (Dev->VirtIo, QueueSize, &Dev->Ring);
310 if (EFI_ERROR (Status)) {
311 goto Failed;
312 }
313
314 //
315 // If anything fails from here on, we must release the ring resources.
316 //
317 Status = VirtioRingMap (
318 Dev->VirtIo,
319 &Dev->Ring,
320 &RingBaseShift,
321 &Dev->RingMap
322 );
323 if (EFI_ERROR (Status)) {
324 goto ReleaseQueue;
325 }
326
327 //
328 // Additional steps for MMIO: align the queue appropriately, and set the
329 // size. If anything fails from here on, we must unmap the ring resources.
330 //
331 Status = Dev->VirtIo->SetQueueNum (Dev->VirtIo, QueueSize);
332 if (EFI_ERROR (Status)) {
333 goto UnmapQueue;
334 }
335
336 Status = Dev->VirtIo->SetQueueAlign (Dev->VirtIo, EFI_PAGE_SIZE);
337 if (EFI_ERROR (Status)) {
338 goto UnmapQueue;
339 }
340
341 //
342 // step 4c -- Report GPFN (guest-physical frame number) of queue.
343 //
344 Status = Dev->VirtIo->SetQueueAddress (
345 Dev->VirtIo,
346 &Dev->Ring,
347 RingBaseShift
348 );
349 if (EFI_ERROR (Status)) {
350 goto UnmapQueue;
351 }
352
353 //
354 // step 5 -- Report understood features and guest-tuneables.
355 //
356 if (Dev->VirtIo->Revision < VIRTIO_SPEC_REVISION (1, 0, 0)) {
357 Features &= ~(UINT64)(VIRTIO_F_VERSION_1 | VIRTIO_F_IOMMU_PLATFORM);
358 Status = Dev->VirtIo->SetGuestFeatures (Dev->VirtIo, Features);
359 if (EFI_ERROR (Status)) {
360 goto UnmapQueue;
361 }
362 }
363
364 //
365 // step 6 -- initialization complete
366 //
367 NextDevStat |= VSTAT_DRIVER_OK;
368 Status = Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat);
369 if (EFI_ERROR (Status)) {
370 goto UnmapQueue;
371 }
372
373 //
374 // populate the exported interface's attributes
375 //
376 Dev->Rng.GetInfo = VirtioRngGetInfo;
377 Dev->Rng.GetRNG = VirtioRngGetRNG;
378
379 return EFI_SUCCESS;
380
381UnmapQueue:
382 Dev->VirtIo->UnmapSharedBuffer (Dev->VirtIo, Dev->RingMap);
383
384ReleaseQueue:
385 VirtioRingUninit (Dev->VirtIo, &Dev->Ring);
386
387Failed:
388 //
389 // Notify the host about our failure to setup: virtio-0.9.5, 2.2.2.1 Device
390 // Status. VirtIo access failure here should not mask the original error.
391 //
392 NextDevStat |= VSTAT_FAILED;
393 Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat);
394
395 return Status; // reached only via Failed above
396}
397
398
399STATIC
400VOID
401EFIAPI
402VirtioRngUninit (
403 IN OUT VIRTIO_RNG_DEV *Dev
404 )
405{
406 //
407 // Reset the virtual device -- see virtio-0.9.5, 2.2.2.1 Device Status. When
408 // VIRTIO_CFG_WRITE() returns, the host will have learned to stay away from
409 // the old comms area.
410 //
411 Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, 0);
412
413 Dev->VirtIo->UnmapSharedBuffer (Dev->VirtIo, Dev->RingMap);
414
415 VirtioRingUninit (Dev->VirtIo, &Dev->Ring);
416}
417
418//
419// Event notification function enqueued by ExitBootServices().
420//
421
422STATIC
423VOID
424EFIAPI
425VirtioRngExitBoot (
426 IN EFI_EVENT Event,
427 IN VOID *Context
428 )
429{
430 VIRTIO_RNG_DEV *Dev;
431
432 DEBUG ((DEBUG_VERBOSE, "%a: Context=0x%p\n", __FUNCTION__, Context));
433 //
434 // Reset the device. This causes the hypervisor to forget about the virtio
435 // ring.
436 //
437 // We allocated said ring in EfiBootServicesData type memory, and code
438 // executing after ExitBootServices() is permitted to overwrite it.
439 //
440 Dev = Context;
441 Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, 0);
442}
443
444
445//
446// Probe, start and stop functions of this driver, called by the DXE core for
447// specific devices.
448//
449// The following specifications document these interfaces:
450// - Driver Writer's Guide for UEFI 2.3.1 v1.01, 9 Driver Binding Protocol
451// - UEFI Spec 2.3.1 + Errata C, 10.1 EFI Driver Binding Protocol
452//
453// The implementation follows:
454// - Driver Writer's Guide for UEFI 2.3.1 v1.01
455// - 5.1.3.4 OpenProtocol() and CloseProtocol()
456// - UEFI Spec 2.3.1 + Errata C
457// - 6.3 Protocol Handler Services
458//
459
460STATIC
461EFI_STATUS
462EFIAPI
463VirtioRngDriverBindingSupported (
464 IN EFI_DRIVER_BINDING_PROTOCOL *This,
465 IN EFI_HANDLE DeviceHandle,
466 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
467 )
468{
469 EFI_STATUS Status;
470 VIRTIO_DEVICE_PROTOCOL *VirtIo;
471
472 //
473 // Attempt to open the device with the VirtIo set of interfaces. On success,
474 // the protocol is "instantiated" for the VirtIo device. Covers duplicate
475 // open attempts (EFI_ALREADY_STARTED).
476 //
477 Status = gBS->OpenProtocol (
478 DeviceHandle, // candidate device
479 &gVirtioDeviceProtocolGuid, // for generic VirtIo access
480 (VOID **)&VirtIo, // handle to instantiate
481 This->DriverBindingHandle, // requestor driver identity
482 DeviceHandle, // ControllerHandle, according to
483 // the UEFI Driver Model
484 EFI_OPEN_PROTOCOL_BY_DRIVER // get exclusive VirtIo access to
485 // the device; to be released
486 );
487 if (EFI_ERROR (Status)) {
488 return Status;
489 }
490
491 if (VirtIo->SubSystemDeviceId != VIRTIO_SUBSYSTEM_ENTROPY_SOURCE) {
492 Status = EFI_UNSUPPORTED;
493 }
494
495 //
496 // We needed VirtIo access only transitorily, to see whether we support the
497 // device or not.
498 //
499 gBS->CloseProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid,
500 This->DriverBindingHandle, DeviceHandle);
501 return Status;
502}
503
504STATIC
505EFI_STATUS
506EFIAPI
507VirtioRngDriverBindingStart (
508 IN EFI_DRIVER_BINDING_PROTOCOL *This,
509 IN EFI_HANDLE DeviceHandle,
510 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
511 )
512{
513 VIRTIO_RNG_DEV *Dev;
514 EFI_STATUS Status;
515
516 Dev = (VIRTIO_RNG_DEV *) AllocateZeroPool (sizeof *Dev);
517 if (Dev == NULL) {
518 return EFI_OUT_OF_RESOURCES;
519 }
520
521 Status = gBS->OpenProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid,
522 (VOID **)&Dev->VirtIo, This->DriverBindingHandle,
523 DeviceHandle, EFI_OPEN_PROTOCOL_BY_DRIVER);
524 if (EFI_ERROR (Status)) {
525 goto FreeVirtioRng;
526 }
527
528 //
529 // VirtIo access granted, configure virtio-rng device.
530 //
531 Status = VirtioRngInit (Dev);
532 if (EFI_ERROR (Status)) {
533 goto CloseVirtIo;
534 }
535
536 Status = gBS->CreateEvent (EVT_SIGNAL_EXIT_BOOT_SERVICES, TPL_CALLBACK,
537 &VirtioRngExitBoot, Dev, &Dev->ExitBoot);
538 if (EFI_ERROR (Status)) {
539 goto UninitDev;
540 }
541
542 //
543 // Setup complete, attempt to export the driver instance's EFI_RNG_PROTOCOL
544 // interface.
545 //
546 Dev->Signature = VIRTIO_RNG_SIG;
547 Status = gBS->InstallProtocolInterface (&DeviceHandle,
548 &gEfiRngProtocolGuid, EFI_NATIVE_INTERFACE,
549 &Dev->Rng);
550 if (EFI_ERROR (Status)) {
551 goto CloseExitBoot;
552 }
553
554 return EFI_SUCCESS;
555
556CloseExitBoot:
557 gBS->CloseEvent (Dev->ExitBoot);
558
559UninitDev:
560 VirtioRngUninit (Dev);
561
562CloseVirtIo:
563 gBS->CloseProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid,
564 This->DriverBindingHandle, DeviceHandle);
565
566FreeVirtioRng:
567 FreePool (Dev);
568
569 return Status;
570}
571
572
573STATIC
574EFI_STATUS
575EFIAPI
576VirtioRngDriverBindingStop (
577 IN EFI_DRIVER_BINDING_PROTOCOL *This,
578 IN EFI_HANDLE DeviceHandle,
579 IN UINTN NumberOfChildren,
580 IN EFI_HANDLE *ChildHandleBuffer
581 )
582{
583 EFI_STATUS Status;
584 EFI_RNG_PROTOCOL *Rng;
585 VIRTIO_RNG_DEV *Dev;
586
587 Status = gBS->OpenProtocol (
588 DeviceHandle, // candidate device
589 &gEfiRngProtocolGuid, // retrieve the RNG iface
590 (VOID **)&Rng, // target pointer
591 This->DriverBindingHandle, // requestor driver ident.
592 DeviceHandle, // lookup req. for dev.
593 EFI_OPEN_PROTOCOL_GET_PROTOCOL // lookup only, no new ref.
594 );
595 if (EFI_ERROR (Status)) {
596 return Status;
597 }
598
599 Dev = VIRTIO_ENTROPY_SOURCE_FROM_RNG (Rng);
600
601 //
602 // Handle Stop() requests for in-use driver instances gracefully.
603 //
604 Status = gBS->UninstallProtocolInterface (DeviceHandle,
605 &gEfiRngProtocolGuid, &Dev->Rng);
606 if (EFI_ERROR (Status)) {
607 return Status;
608 }
609
610 gBS->CloseEvent (Dev->ExitBoot);
611
612 VirtioRngUninit (Dev);
613
614 gBS->CloseProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid,
615 This->DriverBindingHandle, DeviceHandle);
616
617 FreePool (Dev);
618
619 return EFI_SUCCESS;
620}
621
622
623//
624// The static object that groups the Supported() (ie. probe), Start() and
625// Stop() functions of the driver together. Refer to UEFI Spec 2.3.1 + Errata
626// C, 10.1 EFI Driver Binding Protocol.
627//
628STATIC EFI_DRIVER_BINDING_PROTOCOL gDriverBinding = {
629 &VirtioRngDriverBindingSupported,
630 &VirtioRngDriverBindingStart,
631 &VirtioRngDriverBindingStop,
632 0x10, // Version, must be in [0x10 .. 0xFFFFFFEF] for IHV-developed drivers
633 NULL, // ImageHandle, to be overwritten by
634 // EfiLibInstallDriverBindingComponentName2() in VirtioRngEntryPoint()
635 NULL // DriverBindingHandle, ditto
636};
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
647STATIC
648EFI_UNICODE_STRING_TABLE mDriverNameTable[] = {
649 { "eng;en", L"Virtio Random Number Generator Driver" },
650 { NULL, NULL }
651};
652
653STATIC
654EFI_COMPONENT_NAME_PROTOCOL gComponentName;
655
656STATIC
657EFI_STATUS
658EFIAPI
659VirtioRngGetDriverName (
660 IN EFI_COMPONENT_NAME_PROTOCOL *This,
661 IN CHAR8 *Language,
662 OUT CHAR16 **DriverName
663 )
664{
665 return LookupUnicodeString2 (
666 Language,
667 This->SupportedLanguages,
668 mDriverNameTable,
669 DriverName,
670 (BOOLEAN)(This == &gComponentName) // Iso639Language
671 );
672}
673
674STATIC
675EFI_STATUS
676EFIAPI
677VirtioRngGetDeviceName (
678 IN EFI_COMPONENT_NAME_PROTOCOL *This,
679 IN EFI_HANDLE DeviceHandle,
680 IN EFI_HANDLE ChildHandle,
681 IN CHAR8 *Language,
682 OUT CHAR16 **ControllerName
683 )
684{
685 return EFI_UNSUPPORTED;
686}
687
688STATIC
689EFI_COMPONENT_NAME_PROTOCOL gComponentName = {
690 &VirtioRngGetDriverName,
691 &VirtioRngGetDeviceName,
692 "eng" // SupportedLanguages, ISO 639-2 language codes
693};
694
695STATIC
696EFI_COMPONENT_NAME2_PROTOCOL gComponentName2 = {
697 (EFI_COMPONENT_NAME2_GET_DRIVER_NAME) &VirtioRngGetDriverName,
698 (EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME) &VirtioRngGetDeviceName,
699 "en" // SupportedLanguages, RFC 4646 language codes
700};
701
702
703//
704// Entry point of this driver.
705//
706EFI_STATUS
707EFIAPI
708VirtioRngEntryPoint (
709 IN EFI_HANDLE ImageHandle,
710 IN EFI_SYSTEM_TABLE *SystemTable
711 )
712{
713 return EfiLibInstallDriverBindingComponentName2 (
714 ImageHandle,
715 SystemTable,
716 &gDriverBinding,
717 ImageHandle,
718 &gComponentName,
719 &gComponentName2
720 );
721}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette