VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/PrmPkg/PrmConfigDxe/PrmConfigDxe.c@ 101291

Last change on this file since 101291 was 101291, checked in by vboxsync, 17 months ago

EFI/FirmwareNew: Make edk2-stable202308 build on all supported platforms (using gcc at least, msvc not tested yet), bugref:4643
  • Property svn:eol-style set to native
File size: 15.4 KB
Line 
1/** @file
2
3 This file contains the implementation for a Platform Runtime Mechanism (PRM) configuration driver.
4
5 Copyright (c) Microsoft Corporation
6 Copyright (c) 2020, Intel Corporation. All rights reserved.<BR>
7 SPDX-License-Identifier: BSD-2-Clause-Patent
8
9**/
10
11#include <Library/BaseLib.h>
12#include <Library/BaseMemoryLib.h>
13#include <Library/DebugLib.h>
14#include <Library/DxeServicesTableLib.h>
15#include <Library/MemoryAllocationLib.h>
16#include <Library/UefiBootServicesTableLib.h>
17#include <Library/UefiRuntimeServicesTableLib.h>
18#include <Library/UefiLib.h>
19
20#include <PiDxe.h>
21#include <PrmContextBuffer.h>
22#include <PrmDataBuffer.h>
23#include <PrmMmio.h>
24#include <Protocol/PrmConfig.h>
25
26#define _DBGMSGID_ "[PRMCONFIG]"
27
28STATIC UINTN mMaxRuntimeMmioRangeCount;
29
30GLOBAL_REMOVE_IF_UNREFERENCED STATIC PRM_RUNTIME_MMIO_RANGES **mRuntimeMmioRanges;
31
32/**
33 Converts the runtime memory range physical addresses to virtual addresses.
34
35 @param[in] RuntimeMmioRanges A pointer to a PRM_RUNTIME_MMIO_RANGES buffer.
36
37**/
38VOID
39ConvertRuntimeMemoryRangeAddresses (
40 IN PRM_RUNTIME_MMIO_RANGES *RuntimeMmioRanges
41 )
42{
43 UINTN Index;
44
45 if ((RuntimeMmioRanges == NULL) || (RuntimeMmioRanges->Count == 0)) {
46 return;
47 }
48
49 for (Index = 0; Index < (UINTN)RuntimeMmioRanges->Count; Index++) {
50 RuntimeMmioRanges->Range[Index].VirtualBaseAddress = RuntimeMmioRanges->Range[Index].PhysicalBaseAddress;
51 gRT->ConvertPointer (0x0, (VOID **)&(RuntimeMmioRanges->Range[Index].VirtualBaseAddress));
52 }
53}
54
55/**
56 Sets the runtime memory range attributes.
57
58 The EFI_MEMORY_RUNTIME attribute is set for each PRM_RUNTIME_MMIO_RANGE present
59 in the buffer provided.
60
61 @param[in] RuntimeMmioRanges A pointer to a PRM_RUNTIME_MMIO_RANGES buffer.
62
63**/
64VOID
65SetRuntimeMemoryRangeAttributes (
66 IN PRM_RUNTIME_MMIO_RANGES *RuntimeMmioRanges
67 )
68{
69 EFI_STATUS Status;
70 EFI_STATUS Status2;
71 UINTN Index;
72 EFI_GCD_MEMORY_SPACE_DESCRIPTOR Descriptor;
73
74 DEBUG ((DEBUG_INFO, "%a %a - Entry.\n", _DBGMSGID_, __func__));
75
76 if ((RuntimeMmioRanges == NULL) || (RuntimeMmioRanges->Count == 0)) {
77 return;
78 }
79
80 for (Index = 0; Index < (UINTN)RuntimeMmioRanges->Count; Index++) {
81 DEBUG ((
82 DEBUG_INFO,
83 " %a %a: Runtime MMIO Range [%d].\n",
84 _DBGMSGID_,
85 __func__,
86 Index
87 ));
88 DEBUG ((
89 DEBUG_INFO,
90 " %a %a: Physical address = 0x%016x. Length = 0x%x.\n",
91 _DBGMSGID_,
92 __func__,
93 RuntimeMmioRanges->Range[Index].PhysicalBaseAddress,
94 RuntimeMmioRanges->Range[Index].Length
95 ));
96
97 // Runtime memory ranges should cover ranges on a page boundary
98 ASSERT ((RuntimeMmioRanges->Range[Index].PhysicalBaseAddress & EFI_PAGE_MASK) == 0);
99 ASSERT ((RuntimeMmioRanges->Range[Index].Length & EFI_PAGE_MASK) == 0);
100
101 Status2 = EFI_NOT_FOUND;
102 Status = gDS->GetMemorySpaceDescriptor (RuntimeMmioRanges->Range[Index].PhysicalBaseAddress, &Descriptor);
103 if (!EFI_ERROR (Status) &&
104 (
105 ((Descriptor.GcdMemoryType != EfiGcdMemoryTypeMemoryMappedIo) && (Descriptor.GcdMemoryType != EfiGcdMemoryTypeReserved)) ||
106 ((Descriptor.Length & EFI_PAGE_MASK) != 0)
107 )
108 )
109 {
110 Status2 = gDS->RemoveMemorySpace (
111 RuntimeMmioRanges->Range[Index].PhysicalBaseAddress,
112 Descriptor.Length
113 );
114 }
115
116 if ((Status == EFI_NOT_FOUND) || !EFI_ERROR (Status2)) {
117 Status = gDS->AddMemorySpace (
118 EfiGcdMemoryTypeMemoryMappedIo,
119 RuntimeMmioRanges->Range[Index].PhysicalBaseAddress,
120 (UINT64)RuntimeMmioRanges->Range[Index].Length,
121 EFI_MEMORY_UC | EFI_MEMORY_RUNTIME
122 );
123 ASSERT_EFI_ERROR (Status);
124
125 Status = gDS->AllocateMemorySpace (
126 EfiGcdAllocateAddress,
127 EfiGcdMemoryTypeMemoryMappedIo,
128 0,
129 (UINT64)RuntimeMmioRanges->Range[Index].Length,
130 &RuntimeMmioRanges->Range[Index].PhysicalBaseAddress,
131 gImageHandle,
132 NULL
133 );
134 ASSERT_EFI_ERROR (Status);
135 }
136
137 Status = gDS->GetMemorySpaceDescriptor (RuntimeMmioRanges->Range[Index].PhysicalBaseAddress, &Descriptor);
138 ASSERT_EFI_ERROR (Status);
139 if (EFI_ERROR (Status)) {
140 DEBUG ((
141 DEBUG_ERROR,
142 " %a %a: Error [%r] finding descriptor for runtime memory range 0x%016x.\n",
143 _DBGMSGID_,
144 __func__,
145 Status,
146 RuntimeMmioRanges->Range[Index].PhysicalBaseAddress
147 ));
148 continue;
149 }
150
151 if ((Descriptor.Attributes & EFI_MEMORY_RUNTIME) != 0) {
152 continue;
153 }
154
155 Status = gDS->SetMemorySpaceAttributes (
156 RuntimeMmioRanges->Range[Index].PhysicalBaseAddress,
157 (UINT64)RuntimeMmioRanges->Range[Index].Length,
158 Descriptor.Attributes | EFI_MEMORY_RUNTIME
159 );
160 ASSERT_EFI_ERROR (Status);
161 if (EFI_ERROR (Status)) {
162 DEBUG ((
163 DEBUG_ERROR,
164 " %a %a: Error [%r] setting descriptor for runtime memory range 0x%016x.\n",
165 _DBGMSGID_,
166 __func__,
167 Status,
168 RuntimeMmioRanges->Range[Index].PhysicalBaseAddress
169 ));
170 } else {
171 DEBUG ((DEBUG_INFO, " %a %a: Successfully set runtime attribute for the MMIO range.\n", _DBGMSGID_, __func__));
172 }
173 }
174}
175
176/**
177 Stores pointers or pointer to resources that should be converted in the virtual address change event.
178
179**/
180VOID
181StoreVirtualMemoryAddressChangePointers (
182 VOID
183 )
184{
185 EFI_STATUS Status;
186 UINTN HandleCount;
187 UINTN HandleIndex;
188 UINTN RangeIndex;
189 EFI_HANDLE *HandleBuffer;
190 PRM_CONFIG_PROTOCOL *PrmConfigProtocol;
191
192 DEBUG ((DEBUG_INFO, "%a %a - Entry.\n", _DBGMSGID_, __func__));
193
194 RangeIndex = 0;
195
196 mRuntimeMmioRanges = AllocateRuntimeZeroPool (sizeof (*mRuntimeMmioRanges) * mMaxRuntimeMmioRangeCount);
197 if ((mRuntimeMmioRanges == NULL) && (mMaxRuntimeMmioRangeCount > 0)) {
198 DEBUG ((
199 DEBUG_ERROR,
200 " %a %a: Memory allocation for runtime MMIO pointer array failed.\n",
201 _DBGMSGID_,
202 __func__
203 ));
204 ASSERT (FALSE);
205 return;
206 }
207
208 HandleBuffer = NULL;
209 Status = gBS->LocateHandleBuffer (
210 ByProtocol,
211 &gPrmConfigProtocolGuid,
212 NULL,
213 &HandleCount,
214 &HandleBuffer
215 );
216 if (!EFI_ERROR (Status)) {
217 for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) {
218 Status = gBS->HandleProtocol (
219 HandleBuffer[HandleIndex],
220 &gPrmConfigProtocolGuid,
221 (VOID **)&PrmConfigProtocol
222 );
223 ASSERT_EFI_ERROR (Status);
224 if (EFI_ERROR (Status) || (PrmConfigProtocol == NULL)) {
225 continue;
226 }
227
228 if (PrmConfigProtocol->ModuleContextBuffers.RuntimeMmioRanges != NULL) {
229 if (RangeIndex >= mMaxRuntimeMmioRangeCount) {
230 Status = EFI_BUFFER_TOO_SMALL;
231 DEBUG ((
232 DEBUG_ERROR,
233 " %a %a: Index out of bounds - Actual count (%d) of runtime MMIO ranges exceeds maximum count (%d).\n",
234 _DBGMSGID_,
235 __func__,
236 RangeIndex + 1,
237 mMaxRuntimeMmioRangeCount
238 ));
239 ASSERT_EFI_ERROR (Status);
240 return;
241 }
242
243 mRuntimeMmioRanges[RangeIndex++] = PrmConfigProtocol->ModuleContextBuffers.RuntimeMmioRanges;
244 }
245 }
246
247 DEBUG ((
248 DEBUG_INFO,
249 " %a %a: %d MMIO ranges buffers saved for future virtual memory conversion.\n",
250 _DBGMSGID_,
251 __func__,
252 RangeIndex
253 ));
254 }
255}
256
257/**
258 Validates a data buffer for a PRM module.
259
260 Verifies the buffer header signature is valid and the length meets the minimum size.
261
262 @param[in] PrmDataBuffer A pointer to the data buffer for this PRM module.
263
264 @retval EFI_SUCCESS The data buffer was validated successfully.
265 @retval EFI_INVALID_PARAMETER The pointer given for PrmDataBuffer is NULL.
266 @retval EFI_NOT_FOUND The data buffer signature is not valid.
267 @retval EFI_BUFFER_TOO_SMALL The buffer size is too small.
268
269**/
270EFI_STATUS
271ValidatePrmDataBuffer (
272 IN CONST PRM_DATA_BUFFER *PrmDataBuffer
273 )
274{
275 if (PrmDataBuffer == NULL) {
276 return EFI_INVALID_PARAMETER;
277 }
278
279 if (PrmDataBuffer->Header.Signature != PRM_DATA_BUFFER_HEADER_SIGNATURE) {
280 DEBUG ((DEBUG_ERROR, " %a %a: The PRM data buffer signature is invalid. PRM module.\n", _DBGMSGID_, __func__));
281 return EFI_NOT_FOUND;
282 }
283
284 if (PrmDataBuffer->Header.Length < sizeof (PRM_DATA_BUFFER_HEADER)) {
285 DEBUG ((DEBUG_ERROR, " %a %a: The PRM data buffer length is invalid.\n", _DBGMSGID_, __func__));
286 return EFI_BUFFER_TOO_SMALL;
287 }
288
289 return EFI_SUCCESS;
290}
291
292/**
293 Validates a PRM context buffer.
294
295 Verifies the buffer header signature is valid and the GUID is set to a non-zero value.
296
297 @param[in] PrmContextBuffer A pointer to the context buffer for this PRM handler.
298
299 @retval EFI_SUCCESS The context buffer was validated successfully.
300 @retval EFI_INVALID_PARAMETER The pointer given for ContextBuffer is NULL.
301 @retval EFI_NOT_FOUND The proper value for a field was not found.
302
303**/
304EFI_STATUS
305ValidatePrmContextBuffer (
306 IN CONST PRM_CONTEXT_BUFFER *PrmContextBuffer
307 )
308{
309 if (PrmContextBuffer == NULL) {
310 return EFI_INVALID_PARAMETER;
311 }
312
313 if (PrmContextBuffer->Signature != PRM_CONTEXT_BUFFER_SIGNATURE) {
314 DEBUG ((DEBUG_ERROR, " %a %a: The PRM context buffer signature is invalid.\n", _DBGMSGID_, __func__));
315 return EFI_NOT_FOUND;
316 }
317
318 if (IsZeroGuid (&PrmContextBuffer->HandlerGuid)) {
319 DEBUG ((DEBUG_ERROR, " %a %a: The PRM context buffer GUID is zero.\n", _DBGMSGID_, __func__));
320 return EFI_NOT_FOUND;
321 }
322
323 if ((PrmContextBuffer->StaticDataBuffer != NULL) && EFI_ERROR (ValidatePrmDataBuffer (PrmContextBuffer->StaticDataBuffer))) {
324 DEBUG ((
325 DEBUG_ERROR,
326 " %a %a: Error in static buffer for PRM handler %g.\n",
327 _DBGMSGID_,
328 __func__,
329 &PrmContextBuffer->HandlerGuid
330 ));
331 return EFI_NOT_FOUND;
332 }
333
334 return EFI_SUCCESS;
335}
336
337/**
338 Notification function of EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE.
339
340 This is notification function converts any registered PRM_RUNTIME_MMIO_RANGE
341 addresses to a virtual address.
342
343 @param[in] Event Event whose notification function is being invoked.
344 @param[in] Context Pointer to the notification function's context.
345
346**/
347VOID
348EFIAPI
349PrmConfigVirtualAddressChangeEvent (
350 IN EFI_EVENT Event,
351 IN VOID *Context
352 )
353{
354 UINTN Index;
355
356 //
357 // Convert runtime MMIO ranges
358 //
359 for (Index = 0; Index < mMaxRuntimeMmioRangeCount; Index++) {
360 ConvertRuntimeMemoryRangeAddresses (mRuntimeMmioRanges[Index]);
361 }
362}
363
364/**
365 The PRM Config END_OF_DXE protocol notification event handler.
366
367 Finds all of the PRM_CONFIG_PROTOCOL instances installed at end of DXE and
368 marks all PRM_RUNTIME_MMIO_RANGE entries as EFI_MEMORY_RUNTIME.
369
370 @param[in] Event Event whose notification function is being invoked.
371 @param[in] Context The pointer to the notification function's context,
372 which is implementation-dependent.
373
374**/
375VOID
376EFIAPI
377PrmConfigEndOfDxeNotification (
378 IN EFI_EVENT Event,
379 IN VOID *Context
380 )
381{
382 EFI_STATUS Status;
383 UINTN HandleCount;
384 UINTN BufferIndex;
385 UINTN HandleIndex;
386 EFI_HANDLE *HandleBuffer;
387 PRM_CONTEXT_BUFFER *CurrentContextBuffer;
388 PRM_CONFIG_PROTOCOL *PrmConfigProtocol;
389
390 DEBUG ((DEBUG_INFO, "%a %a - Entry.\n", _DBGMSGID_, __func__));
391
392 HandleBuffer = NULL;
393 Status = gBS->LocateHandleBuffer (
394 ByProtocol,
395 &gPrmConfigProtocolGuid,
396 NULL,
397 &HandleCount,
398 &HandleBuffer
399 );
400 if (!EFI_ERROR (Status)) {
401 for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) {
402 Status = gBS->HandleProtocol (
403 HandleBuffer[HandleIndex],
404 &gPrmConfigProtocolGuid,
405 (VOID **)&PrmConfigProtocol
406 );
407 ASSERT_EFI_ERROR (Status);
408 if (EFI_ERROR (Status) || (PrmConfigProtocol == NULL)) {
409 continue;
410 }
411
412 DEBUG ((
413 DEBUG_INFO,
414 " %a %a: Found PRM configuration protocol for PRM module %g.\n",
415 _DBGMSGID_,
416 __func__,
417 &PrmConfigProtocol->ModuleContextBuffers.ModuleGuid
418 ));
419
420 DEBUG ((DEBUG_INFO, " %a %a: Validating module context buffers...\n", _DBGMSGID_, __func__));
421 for (BufferIndex = 0; BufferIndex < PrmConfigProtocol->ModuleContextBuffers.BufferCount; BufferIndex++) {
422 CurrentContextBuffer = &(PrmConfigProtocol->ModuleContextBuffers.Buffer[BufferIndex]);
423
424 Status = ValidatePrmContextBuffer (CurrentContextBuffer);
425 if (EFI_ERROR (Status)) {
426 DEBUG ((
427 DEBUG_ERROR,
428 " %a %a: Context buffer validation failed for PRM handler %g.\n",
429 _DBGMSGID_,
430 __func__,
431 CurrentContextBuffer->HandlerGuid
432 ));
433 }
434 }
435
436 DEBUG ((DEBUG_INFO, " %a %a: Module context buffer validation complete.\n", _DBGMSGID_, __func__));
437
438 if (PrmConfigProtocol->ModuleContextBuffers.RuntimeMmioRanges != NULL) {
439 DEBUG ((
440 DEBUG_INFO,
441 " %a %a: Found %d PRM runtime MMIO ranges.\n",
442 _DBGMSGID_,
443 __func__,
444 PrmConfigProtocol->ModuleContextBuffers.RuntimeMmioRanges->Count
445 ));
446 SetRuntimeMemoryRangeAttributes (PrmConfigProtocol->ModuleContextBuffers.RuntimeMmioRanges);
447 mMaxRuntimeMmioRangeCount++;
448 }
449 }
450
451 StoreVirtualMemoryAddressChangePointers ();
452 }
453
454 if (HandleBuffer != NULL) {
455 gBS->FreePool (HandleBuffer);
456 }
457
458 gBS->CloseEvent (Event);
459}
460
461/**
462 The entry point for this module.
463
464 @param[in] ImageHandle The firmware allocated handle for the EFI image.
465 @param[in] SystemTable A pointer to the EFI System Table.
466
467 @retval EFI_SUCCESS The entry point is executed successfully.
468 @retval Others An error occurred when executing this entry point.
469
470**/
471EFI_STATUS
472EFIAPI
473PrmConfigEntryPoint (
474 IN EFI_HANDLE ImageHandle,
475 IN EFI_SYSTEM_TABLE *SystemTable
476 )
477{
478 EFI_STATUS Status;
479 EFI_EVENT Event;
480
481 DEBUG ((DEBUG_INFO, "%a %a - Entry.\n", _DBGMSGID_, __func__));
482
483 //
484 // Register a notification function to change memory attributes at end of DXE
485 //
486 Event = NULL;
487 Status = gBS->CreateEventEx (
488 EVT_NOTIFY_SIGNAL,
489 TPL_CALLBACK,
490 PrmConfigEndOfDxeNotification,
491 NULL,
492 &gEfiEndOfDxeEventGroupGuid,
493 &Event
494 );
495 ASSERT_EFI_ERROR (Status);
496
497 //
498 // Register a notification function for virtual address change
499 //
500 Event = NULL;
501 Status = gBS->CreateEventEx (
502 EVT_NOTIFY_SIGNAL,
503 TPL_NOTIFY,
504 PrmConfigVirtualAddressChangeEvent,
505 NULL,
506 &gEfiEventVirtualAddressChangeGuid,
507 &Event
508 );
509 ASSERT_EFI_ERROR (Status);
510
511 return EFI_SUCCESS;
512}
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