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 if (Instance
>= mFvbCount
) {
362 return EFI_INVALID_PARAMETER
;
365 if (EfiAtRuntime() && !mFvbEntry
[Instance
].IsRuntimeAccess
) {
366 return EFI_INVALID_PARAMETER
;
369 return mFvbEntry
[Instance
].Fvb
->Read (mFvbEntry
[Instance
].Fvb
, Lba
, Offset
, NumBytes
, Buffer
);
373 Writes specified number of bytes from the input buffer to the block
375 @param Instance The FV instance to be written to
376 @param Lba The starting logical block index to write to
377 @param Offset Offset into the block at which to begin writing
378 @param NumBytes Pointer that on input contains the total size of
379 the buffer. On output, it contains the total number
380 of bytes actually written
381 @param Buffer Pointer to a caller allocated buffer that contains
382 the source for the write
384 @retval EFI_INVALID_PARAMETER Invalid parameter
385 @retval EFI_SUCESS Sucess to write block
386 @retval Others Fail to write block
393 IN OUT UINTN
*NumBytes
,
397 if (Instance
>= mFvbCount
) {
398 return EFI_INVALID_PARAMETER
;
401 if (EfiAtRuntime() && !mFvbEntry
[Instance
].IsRuntimeAccess
) {
402 return EFI_INVALID_PARAMETER
;
405 return mFvbEntry
[Instance
].Fvb
->Write (mFvbEntry
[Instance
].Fvb
, Lba
, Offset
, NumBytes
, Buffer
);
409 Erases and initializes a firmware volume block
411 @param Instance The FV instance to be erased
412 @param Lba The logical block index to be erased
414 @retval EFI_INVALID_PARAMETER Invalid parameter
415 @retval EFI_SUCESS Sucess to erase block
416 @retval Others Fail to erase block
424 if (Instance
>= mFvbCount
) {
425 return EFI_INVALID_PARAMETER
;
428 if (EfiAtRuntime() && !mFvbEntry
[Instance
].IsRuntimeAccess
) {
429 return EFI_INVALID_PARAMETER
;
432 return mFvbEntry
[Instance
].Fvb
->EraseBlocks (mFvbEntry
[Instance
].Fvb
, Lba
, 1, EFI_LBA_LIST_TERMINATOR
);
436 Retrieves attributes, insures positive polarity of attribute bits, returns
437 resulting attributes in output parameter
439 @param Instance The FV instance whose attributes is going to be returned
440 @param Attributes Output buffer which contains attributes
442 @retval EFI_INVALID_PARAMETER Invalid parameter
443 @retval EFI_SUCESS Sucess to get Fv attribute
444 @retval Others Fail to get Fv attribute
447 EfiFvbGetVolumeAttributes (
449 OUT EFI_FVB_ATTRIBUTES
*Attributes
452 if (Instance
>= mFvbCount
) {
453 return EFI_INVALID_PARAMETER
;
456 if (EfiAtRuntime() && !mFvbEntry
[Instance
].IsRuntimeAccess
) {
457 return EFI_INVALID_PARAMETER
;
460 return mFvbEntry
[Instance
].Fvb
->GetAttributes (mFvbEntry
[Instance
].Fvb
, Attributes
);
464 Modifies the current settings of the firmware volume according to the
465 input parameter, and returns the new setting of the volume
467 @param Instance The FV instance whose attributes is going to be
469 @param Attributes On input, it is a pointer to EFI_FVB_ATTRIBUTES
470 containing the desired firmware volume settings.
471 On successful return, it contains the new settings
472 of the firmware volume
474 @retval EFI_INVALID_PARAMETER Invalid parameter
475 @retval EFI_SUCESS Sucess to set Fv attribute
476 @retval Others Fail to set Fv attribute
479 EfiFvbSetVolumeAttributes (
481 IN OUT EFI_FVB_ATTRIBUTES
*Attributes
484 if (Instance
>= mFvbCount
) {
485 return EFI_INVALID_PARAMETER
;
488 if (EfiAtRuntime() && !mFvbEntry
[Instance
].IsRuntimeAccess
) {
489 return EFI_INVALID_PARAMETER
;
492 return mFvbEntry
[Instance
].Fvb
->SetAttributes (mFvbEntry
[Instance
].Fvb
, Attributes
);
496 Retrieves the physical address of a memory mapped FV
498 @param Instance The FV instance whose base address is going to be
500 @param BaseAddress Pointer to a caller allocated EFI_PHYSICAL_ADDRESS
501 that on successful return, contains the base address
502 of the firmware volume.
504 @retval EFI_INVALID_PARAMETER Invalid parameter
505 @retval EFI_SUCESS Sucess to get physical address
506 @retval Others Fail to get physical address
509 EfiFvbGetPhysicalAddress (
511 OUT EFI_PHYSICAL_ADDRESS
*BaseAddress
514 if (Instance
>= mFvbCount
) {
515 return EFI_INVALID_PARAMETER
;
518 if (EfiAtRuntime() && !mFvbEntry
[Instance
].IsRuntimeAccess
) {
519 return EFI_INVALID_PARAMETER
;
522 return mFvbEntry
[Instance
].Fvb
->GetPhysicalAddress (mFvbEntry
[Instance
].Fvb
, BaseAddress
);
526 Retrieve the size of a logical block
528 @param Instance The FV instance whose block size is going to be
530 @param Lba Indicates which block to return the size for.
531 @param BlockSize A pointer to a caller allocated UINTN in which
532 the size of the block is returned
533 @param NumOfBlocks a pointer to a caller allocated UINTN in which the
534 number of consecutive blocks starting with Lba is
535 returned. All blocks in this range have a size of
538 @retval EFI_INVALID_PARAMETER Invalid parameter
539 @retval EFI_SUCESS Sucess to get block size
540 @retval Others Fail to get block size
546 OUT UINTN
*BlockSize
,
547 OUT UINTN
*NumOfBlocks
550 if (Instance
>= mFvbCount
) {
551 return EFI_INVALID_PARAMETER
;
554 if (EfiAtRuntime() && !mFvbEntry
[Instance
].IsRuntimeAccess
) {
555 return EFI_INVALID_PARAMETER
;
558 return mFvbEntry
[Instance
].Fvb
->GetBlockSize (mFvbEntry
[Instance
].Fvb
, Lba
, BlockSize
, NumOfBlocks
);
562 Erases and initializes a specified range of a firmware volume
564 @param Instance The FV instance to be erased
565 @param StartLba The starting logical block index to be erased
566 @param OffsetStartLba Offset into the starting block at which to
568 @param LastLba The last logical block index to be erased
569 @param OffsetLastLba Offset into the last block at which to end erasing
571 @retval EFI_INVALID_PARAMETER Invalid parameter
572 @retval EFI_SUCESS Sucess to erase custom block range
573 @retval Others Fail to erase custom block range
576 EfiFvbEraseCustomBlockRange (
579 IN UINTN OffsetStartLba
,
581 IN UINTN OffsetLastLba
584 if (Instance
>= mFvbCount
) {
585 return EFI_INVALID_PARAMETER
;
588 if (EfiAtRuntime() && !mFvbEntry
[Instance
].IsRuntimeAccess
) {
589 return EFI_INVALID_PARAMETER
;
592 if (!(mFvbEntry
[Instance
].FvbExtension
)) {
593 return EFI_UNSUPPORTED
;
596 if (!(mFvbEntry
[Instance
].FvbExtension
->EraseFvbCustomBlock
)) {
597 return EFI_UNSUPPORTED
;
600 return mFvbEntry
[Instance
].FvbExtension
->EraseFvbCustomBlock (
601 mFvbEntry
[Instance
].FvbExtension
,