3 Firmware Volume Block Protocol Runtime Abstraction
5 mFvbEntry is an array of Handle Fvb pairs. The Fvb Lib Instance matches the
6 index in the mFvbEntry array. This should be the same sequence as the FVB's
7 were described in the HOB. We have to remember the handle so we can tell if
8 the protocol has been reinstalled and it needs updateing.
10 If you are using any of these lib functions.you must first call FvbInitialize ().
12 Copyright (c) 2006, Intel Corporation
13 All rights reserved. This program and the accompanying materials
14 are licensed and made available under the terms and conditions of the BSD License
15 which accompanies this distribution. The full text of the license may be found at
16 http://opensource.org/licenses/bsd-license.php
18 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
19 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
27 // Event for Set Virtual Map Changed Event
29 STATIC EFI_EVENT mSetVirtualMapChangedEvent
= NULL
;
32 // Lib will ASSERT if more FVB devices than this are added to the system.
34 STATIC FVB_ENTRY
*mFvbEntry
;
35 STATIC EFI_EVENT mFvbRegistration
;
36 STATIC UINTN mFvbCount
;
39 Check whether an address is runtime memory or not.
41 @param Address The Address being checked.
43 @retval TRUE The address is runtime memory.
44 @retval FALSE The address is not runtime memory.
52 UINT8 TmpMemoryMap
[1];
55 UINT32 DescriptorVersion
;
57 EFI_MEMORY_DESCRIPTOR
*MemoryMap
;
58 EFI_MEMORY_DESCRIPTOR
*MemoryMapPtr
;
65 // Get System MemoryMapSize
68 Status
= gBS
->GetMemoryMap (
70 (EFI_MEMORY_DESCRIPTOR
*)TmpMemoryMap
,
75 ASSERT (Status
== EFI_BUFFER_TOO_SMALL
);
77 // Enlarge space here, because we will allocate pool now.
79 MemoryMapSize
+= EFI_PAGE_SIZE
;
80 Status
= gBS
->AllocatePool (
85 ASSERT_EFI_ERROR (Status
);
88 // Get System MemoryMap
90 Status
= gBS
->GetMemoryMap (
97 ASSERT_EFI_ERROR (Status
);
99 MemoryMapPtr
= MemoryMap
;
101 // Search the request Address
103 for (Index
= 0; Index
< (MemoryMapSize
/ DescriptorSize
); Index
++) {
104 if (((EFI_PHYSICAL_ADDRESS
)(UINTN
)Address
>= MemoryMap
->PhysicalStart
) &&
105 ((EFI_PHYSICAL_ADDRESS
)(UINTN
)Address
< MemoryMap
->PhysicalStart
106 + LShiftU64 (MemoryMap
->NumberOfPages
, EFI_PAGE_SHIFT
))) {
110 if (MemoryMap
->Attribute
& EFI_MEMORY_RUNTIME
) {
118 MemoryMap
= (EFI_MEMORY_DESCRIPTOR
*)((UINTN
)MemoryMap
+ DescriptorSize
);
124 gBS
->FreePool (MemoryMapPtr
);
130 Update mFvbEntry. Add new entry, or update existing entry if Fvb protocol is
133 @param Event The Event that is being processed
134 @param Context Event Context
140 FvbNotificationEvent (
152 BufferSize
= sizeof (Handle
);
153 Status
= gBS
->LocateHandle (
155 &gEfiFirmwareVolumeBlockProtocolGuid
,
160 if (EFI_ERROR (Status
)) {
162 // Exit Path of While Loop....
167 UpdateIndex
= MAX_FVB_COUNT
;
168 for (Index
= 0; Index
< mFvbCount
; Index
++) {
169 if (mFvbEntry
[Index
].Handle
== Handle
) {
171 // If the handle is already in the table just update the protocol
178 if (UpdateIndex
== MAX_FVB_COUNT
) {
180 // Use the next free slot for a new entry
182 UpdateIndex
= mFvbCount
++;
184 // Check the UpdateIndex whether exceed the maximum value.
186 ASSERT (UpdateIndex
< MAX_FVB_COUNT
);
187 mFvbEntry
[UpdateIndex
].Handle
= Handle
;
190 // The array does not have enough entries
192 ASSERT (UpdateIndex
< MAX_FVB_COUNT
);
195 // Get the interface pointer and if it's ours, skip it
197 Status
= gBS
->HandleProtocol (
199 &gEfiFirmwareVolumeBlockProtocolGuid
,
200 (VOID
**) &mFvbEntry
[UpdateIndex
].Fvb
202 ASSERT_EFI_ERROR (Status
);
204 Status
= gBS
->HandleProtocol (
206 &gEfiFvbExtensionProtocolGuid
,
207 (VOID
**) &mFvbEntry
[UpdateIndex
].FvbExtension
209 if (Status
!= EFI_SUCCESS
) {
210 mFvbEntry
[UpdateIndex
].FvbExtension
= NULL
;
214 // Check the FVB can be accessed in RUNTIME, The FVBs in FVB handle list comes
216 // 1) Dxe Core. (FVB information is transferred from FV HOB).
218 // The FVB produced Dxe core is used for discoverying DXE driver and dispatch. These
219 // FVBs can only be accessed in boot time.
220 // FVB driver will discovery all FV in FLASH and these FVBs can be accessed in runtime.
221 // The FVB itself produced by FVB driver is allocated in runtime memory. So we can
222 // determine the what FVB can be accessed in RUNTIME by judging whether FVB itself is allocated
223 // in RUNTIME memory.
225 mFvbEntry
[UpdateIndex
].IsRuntimeAccess
= IsRuntimeMemory (mFvbEntry
[UpdateIndex
].Fvb
);
230 Convert all pointers in mFvbEntry after ExitBootServices.
232 @param Event The Event that is being processed
233 @param Context Event Context
238 FvbVirtualAddressChangeNotifyEvent (
244 if (mFvbEntry
!= NULL
) {
245 for (Index
= 0; Index
< MAX_FVB_COUNT
; Index
++) {
246 if (!mFvbEntry
[Index
].IsRuntimeAccess
) {
250 if (NULL
!= mFvbEntry
[Index
].Fvb
) {
251 EfiConvertPointer (0x0, (VOID
**) &mFvbEntry
[Index
].Fvb
->GetBlockSize
);
252 EfiConvertPointer (0x0, (VOID
**) &mFvbEntry
[Index
].Fvb
->GetPhysicalAddress
);
253 EfiConvertPointer (0x0, (VOID
**) &mFvbEntry
[Index
].Fvb
->GetAttributes
);
254 EfiConvertPointer (0x0, (VOID
**) &mFvbEntry
[Index
].Fvb
->SetAttributes
);
255 EfiConvertPointer (0x0, (VOID
**) &mFvbEntry
[Index
].Fvb
->Read
);
256 EfiConvertPointer (0x0, (VOID
**) &mFvbEntry
[Index
].Fvb
->Write
);
257 EfiConvertPointer (0x0, (VOID
**) &mFvbEntry
[Index
].Fvb
->EraseBlocks
);
258 EfiConvertPointer (0x0, (VOID
**) &mFvbEntry
[Index
].Fvb
);
261 if (NULL
!= mFvbEntry
[Index
].FvbExtension
) {
262 EfiConvertPointer (0x0, (VOID
**) &mFvbEntry
[Index
].FvbExtension
->EraseFvbCustomBlock
);
263 EfiConvertPointer (0x0, (VOID
**) &mFvbEntry
[Index
].FvbExtension
);
267 EfiConvertPointer (0x0, (VOID
**) &mFvbEntry
);
272 Library constructor function entry.
274 @param ImageHandle The handle of image who call this libary.
275 @param SystemTable The point of System Table.
277 @retval EFI_SUCESS Sucess construct this library.
278 @retval Others Fail to contruct this libary.
283 IN EFI_HANDLE ImageHandle
,
284 IN EFI_SYSTEM_TABLE
*SystemTable
290 Status
= gBS
->AllocatePool (
291 EfiRuntimeServicesData
,
292 (UINTN
) sizeof (FVB_ENTRY
) * MAX_FVB_COUNT
,
296 if (EFI_ERROR (Status
)) {
300 ZeroMem (mFvbEntry
, sizeof (FVB_ENTRY
) * MAX_FVB_COUNT
);
302 EfiCreateProtocolNotifyEvent (
303 &gEfiFirmwareVolumeBlockProtocolGuid
,
305 FvbNotificationEvent
,
311 // Register SetVirtualAddressMap () notify function
313 Status
= gBS
->CreateEvent (
314 EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE
,
316 FvbVirtualAddressChangeNotifyEvent
,
318 &mSetVirtualMapChangedEvent
320 ASSERT_EFI_ERROR (Status
);
326 // =============================================================================
327 // The following functions wrap Fvb protocol in the Runtime Lib functions.
328 // The Instance translates into Fvb instance. The Fvb order defined by HOBs and
329 // thus the sequence of FVB protocol addition define Instance.
331 // EfiFvbInitialize () must be called before any of the following functions
333 // =============================================================================
337 Reads specified number of bytes into a buffer from the specified block
339 @param Instance The FV instance to be read from.
340 @param Lba The logical block address to be read from
341 @param Offset Offset into the block at which to begin reading
342 @param NumBytes Pointer that on input contains the total size of
343 the buffer. On output, it contains the total number
345 @param Buffer Pointer to a caller allocated buffer that will be
346 used to hold the data read
348 @retval EFI_INVALID_PARAMETER Invalid parameter
349 @retval EFI_SUCESS Sucess to Read block
350 @retval Others Fail to read block
357 IN OUT UINTN
*NumBytes
,
361 ASSERT (NumBytes
!= NULL
);
362 ASSERT (Buffer
!= NULL
);
364 if (Instance
>= mFvbCount
) {
365 return EFI_INVALID_PARAMETER
;
368 if (EfiAtRuntime() && !mFvbEntry
[Instance
].IsRuntimeAccess
) {
369 return EFI_INVALID_PARAMETER
;
372 return mFvbEntry
[Instance
].Fvb
->Read (mFvbEntry
[Instance
].Fvb
, Lba
, Offset
, NumBytes
, Buffer
);
376 Writes specified number of bytes from the input buffer to the block
378 @param Instance The FV instance to be written to
379 @param Lba The starting logical block index to write to
380 @param Offset Offset into the block at which to begin writing
381 @param NumBytes Pointer that on input contains the total size of
382 the buffer. On output, it contains the total number
383 of bytes actually written
384 @param Buffer Pointer to a caller allocated buffer that contains
385 the source for the write
387 @retval EFI_INVALID_PARAMETER Invalid parameter
388 @retval EFI_SUCESS Sucess to write block
389 @retval Others Fail to write block
396 IN OUT UINTN
*NumBytes
,
400 ASSERT (NumBytes
!= NULL
);
402 if (Instance
>= mFvbCount
) {
403 return EFI_INVALID_PARAMETER
;
406 if (EfiAtRuntime() && !mFvbEntry
[Instance
].IsRuntimeAccess
) {
407 return EFI_INVALID_PARAMETER
;
410 return mFvbEntry
[Instance
].Fvb
->Write (mFvbEntry
[Instance
].Fvb
, Lba
, Offset
, NumBytes
, Buffer
);
414 Erases and initializes a firmware volume block
416 @param Instance The FV instance to be erased
417 @param Lba The logical block index to be erased
419 @retval EFI_INVALID_PARAMETER Invalid parameter
420 @retval EFI_SUCESS Sucess to erase block
421 @retval Others Fail to erase block
429 if (Instance
>= mFvbCount
) {
430 return EFI_INVALID_PARAMETER
;
433 if (EfiAtRuntime() && !mFvbEntry
[Instance
].IsRuntimeAccess
) {
434 return EFI_INVALID_PARAMETER
;
437 return mFvbEntry
[Instance
].Fvb
->EraseBlocks (mFvbEntry
[Instance
].Fvb
, Lba
, 1, EFI_LBA_LIST_TERMINATOR
);
441 Retrieves attributes, insures positive polarity of attribute bits, returns
442 resulting attributes in output parameter
444 @param Instance The FV instance whose attributes is going to be returned
445 @param Attributes Output buffer which contains attributes
447 @retval EFI_INVALID_PARAMETER Invalid parameter
448 @retval EFI_SUCESS Sucess to get Fv attribute
449 @retval Others Fail to get Fv attribute
452 EfiFvbGetVolumeAttributes (
454 OUT EFI_FVB_ATTRIBUTES
*Attributes
457 ASSERT (Attributes
!= NULL
);
459 if (Instance
>= mFvbCount
) {
460 return EFI_INVALID_PARAMETER
;
463 if (EfiAtRuntime() && !mFvbEntry
[Instance
].IsRuntimeAccess
) {
464 return EFI_INVALID_PARAMETER
;
467 return mFvbEntry
[Instance
].Fvb
->GetAttributes (mFvbEntry
[Instance
].Fvb
, Attributes
);
471 Modifies the current settings of the firmware volume according to the
472 input parameter, and returns the new setting of the volume
474 @param Instance The FV instance whose attributes is going to be
476 @param Attributes On input, it is a pointer to EFI_FVB_ATTRIBUTES
477 containing the desired firmware volume settings.
478 On successful return, it contains the new settings
479 of the firmware volume
481 @retval EFI_INVALID_PARAMETER Invalid parameter
482 @retval EFI_SUCESS Sucess to set Fv attribute
483 @retval Others Fail to set Fv attribute
486 EfiFvbSetVolumeAttributes (
488 IN OUT EFI_FVB_ATTRIBUTES
*Attributes
491 ASSERT (Attributes
!= NULL
);
493 if (Instance
>= mFvbCount
) {
494 return EFI_INVALID_PARAMETER
;
497 if (EfiAtRuntime() && !mFvbEntry
[Instance
].IsRuntimeAccess
) {
498 return EFI_INVALID_PARAMETER
;
501 return mFvbEntry
[Instance
].Fvb
->SetAttributes (mFvbEntry
[Instance
].Fvb
, Attributes
);
505 Retrieves the physical address of a memory mapped FV
507 @param Instance The FV instance whose base address is going to be
509 @param BaseAddress Pointer to a caller allocated EFI_PHYSICAL_ADDRESS
510 that on successful return, contains the base address
511 of the firmware volume.
513 @retval EFI_INVALID_PARAMETER Invalid parameter
514 @retval EFI_SUCESS Sucess to get physical address
515 @retval Others Fail to get physical address
518 EfiFvbGetPhysicalAddress (
520 OUT EFI_PHYSICAL_ADDRESS
*BaseAddress
523 ASSERT (BaseAddress
!= NULL
);
525 if (Instance
>= mFvbCount
) {
526 return EFI_INVALID_PARAMETER
;
529 if (EfiAtRuntime() && !mFvbEntry
[Instance
].IsRuntimeAccess
) {
530 return EFI_INVALID_PARAMETER
;
533 return mFvbEntry
[Instance
].Fvb
->GetPhysicalAddress (mFvbEntry
[Instance
].Fvb
, BaseAddress
);
537 Retrieve the size of a logical block
539 @param Instance The FV instance whose block size is going to be
541 @param Lba Indicates which block to return the size for.
542 @param BlockSize A pointer to a caller allocated UINTN in which
543 the size of the block is returned
544 @param NumOfBlocks a pointer to a caller allocated UINTN in which the
545 number of consecutive blocks starting with Lba is
546 returned. All blocks in this range have a size of
549 @retval EFI_INVALID_PARAMETER Invalid parameter
550 @retval EFI_SUCESS Sucess to get block size
551 @retval Others Fail to get block size
557 OUT UINTN
*BlockSize
,
558 OUT UINTN
*NumOfBlocks
561 ASSERT (BlockSize
!= NULL
);
562 ASSERT (NumOfBlocks
!= NULL
);
564 if (Instance
>= mFvbCount
) {
565 return EFI_INVALID_PARAMETER
;
568 if (EfiAtRuntime() && !mFvbEntry
[Instance
].IsRuntimeAccess
) {
569 return EFI_INVALID_PARAMETER
;
572 return mFvbEntry
[Instance
].Fvb
->GetBlockSize (mFvbEntry
[Instance
].Fvb
, Lba
, BlockSize
, NumOfBlocks
);
576 Erases and initializes a specified range of a firmware volume
578 @param Instance The FV instance to be erased
579 @param StartLba The starting logical block index to be erased
580 @param OffsetStartLba Offset into the starting block at which to
582 @param LastLba The last logical block index to be erased
583 @param OffsetLastLba Offset into the last block at which to end erasing
585 @retval EFI_INVALID_PARAMETER Invalid parameter
586 @retval EFI_SUCESS Sucess to erase custom block range
587 @retval Others Fail to erase custom block range
590 EfiFvbEraseCustomBlockRange (
593 IN UINTN OffsetStartLba
,
595 IN UINTN OffsetLastLba
598 if (Instance
>= mFvbCount
) {
599 return EFI_INVALID_PARAMETER
;
602 if (EfiAtRuntime() && !mFvbEntry
[Instance
].IsRuntimeAccess
) {
603 return EFI_INVALID_PARAMETER
;
606 if (!(mFvbEntry
[Instance
].FvbExtension
)) {
607 return EFI_UNSUPPORTED
;
610 if (!(mFvbEntry
[Instance
].FvbExtension
->EraseFvbCustomBlock
)) {
611 return EFI_UNSUPPORTED
;
614 return mFvbEntry
[Instance
].FvbExtension
->EraseFvbCustomBlock (
615 mFvbEntry
[Instance
].FvbExtension
,