1 /** @file NorFlashDxe.c
3 Copyright (c) 2011 - 2020, Arm Limited. All rights reserved.<BR>
5 SPDX-License-Identifier: BSD-2-Clause-Patent
9 #include <Library/UefiLib.h>
10 #include <Library/BaseMemoryLib.h>
11 #include <Library/MemoryAllocationLib.h>
12 #include <Library/UefiBootServicesTableLib.h>
13 #include <Library/PcdLib.h>
15 #include "NorFlashDxe.h"
17 STATIC EFI_EVENT mNorFlashVirtualAddrChangeEvent
;
20 // Global variable declarations
22 NOR_FLASH_INSTANCE
**mNorFlashInstances
;
23 UINT32 mNorFlashDeviceCount
;
25 NOR_FLASH_INSTANCE mNorFlashInstanceTemplate
= {
26 NOR_FLASH_SIGNATURE
, // Signature
27 NULL
, // Handle ... NEED TO BE FILLED
29 0, // DeviceBaseAddress ... NEED TO BE FILLED
30 0, // RegionBaseAddress ... NEED TO BE FILLED
31 0, // Size ... NEED TO BE FILLED
35 EFI_BLOCK_IO_PROTOCOL_REVISION2
, // Revision
36 NULL
, // Media ... NEED TO BE FILLED
37 NorFlashBlockIoReset
, // Reset;
38 NorFlashBlockIoReadBlocks
, // ReadBlocks
39 NorFlashBlockIoWriteBlocks
, // WriteBlocks
40 NorFlashBlockIoFlushBlocks
// FlushBlocks
44 0, // MediaId ... NEED TO BE FILLED
45 FALSE
, // RemovableMedia
47 FALSE
, // LogicalPartition
49 FALSE
, // WriteCaching;
50 0, // BlockSize ... NEED TO BE FILLED
52 0, // LastBlock ... NEED TO BE FILLED
53 0, // LowestAlignedLba
54 1, // LogicalBlocksPerPhysicalBlock
58 EFI_DISK_IO_PROTOCOL_REVISION
, // Revision
59 NorFlashDiskIoReadDisk
, // ReadDisk
60 NorFlashDiskIoWriteDisk
// WriteDisk
64 FvbGetAttributes
, // GetAttributes
65 FvbSetAttributes
, // SetAttributes
66 FvbGetPhysicalAddress
, // GetPhysicalAddress
67 FvbGetBlockSize
, // GetBlockSize
70 FvbEraseBlocks
, // EraseBlocks
80 (UINT8
)(OFFSET_OF (NOR_FLASH_DEVICE_PATH
, End
)),
81 (UINT8
)(OFFSET_OF (NOR_FLASH_DEVICE_PATH
, End
) >> 8)
84 { 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } }, // GUID ... NEED TO BE FILLED
89 END_ENTIRE_DEVICE_PATH_SUBTYPE
,
90 { sizeof (EFI_DEVICE_PATH_PROTOCOL
), 0 }
96 NorFlashCreateInstance (
97 IN UINTN NorFlashDeviceBase
,
98 IN UINTN NorFlashRegionBase
,
99 IN UINTN NorFlashSize
,
102 IN BOOLEAN SupportFvb
,
103 OUT NOR_FLASH_INSTANCE
** NorFlashInstance
107 NOR_FLASH_INSTANCE
* Instance
;
109 ASSERT(NorFlashInstance
!= NULL
);
111 Instance
= AllocateRuntimeCopyPool (sizeof(NOR_FLASH_INSTANCE
),&mNorFlashInstanceTemplate
);
112 if (Instance
== NULL
) {
113 return EFI_OUT_OF_RESOURCES
;
116 Instance
->DeviceBaseAddress
= NorFlashDeviceBase
;
117 Instance
->RegionBaseAddress
= NorFlashRegionBase
;
118 Instance
->Size
= NorFlashSize
;
120 Instance
->BlockIoProtocol
.Media
= &Instance
->Media
;
121 Instance
->Media
.MediaId
= Index
;
122 Instance
->Media
.BlockSize
= BlockSize
;
123 Instance
->Media
.LastBlock
= (NorFlashSize
/ BlockSize
)-1;
125 CopyGuid (&Instance
->DevicePath
.Vendor
.Guid
, &gEfiCallerIdGuid
);
126 Instance
->DevicePath
.Index
= (UINT8
)Index
;
128 Instance
->ShadowBuffer
= AllocateRuntimePool (BlockSize
);;
129 if (Instance
->ShadowBuffer
== NULL
) {
130 return EFI_OUT_OF_RESOURCES
;
134 NorFlashFvbInitialize (Instance
);
136 Status
= gBS
->InstallMultipleProtocolInterfaces (
138 &gEfiDevicePathProtocolGuid
, &Instance
->DevicePath
,
139 &gEfiBlockIoProtocolGuid
, &Instance
->BlockIoProtocol
,
140 &gEfiFirmwareVolumeBlockProtocolGuid
, &Instance
->FvbProtocol
,
143 if (EFI_ERROR(Status
)) {
148 Status
= gBS
->InstallMultipleProtocolInterfaces (
150 &gEfiDevicePathProtocolGuid
, &Instance
->DevicePath
,
151 &gEfiBlockIoProtocolGuid
, &Instance
->BlockIoProtocol
,
152 &gEfiDiskIoProtocolGuid
, &Instance
->DiskIoProtocol
,
155 if (EFI_ERROR(Status
)) {
161 *NorFlashInstance
= Instance
;
166 NorFlashReadStatusRegister (
167 IN NOR_FLASH_INSTANCE
*Instance
,
171 // Prepare to read the status register
172 SEND_NOR_COMMAND (Instance
->DeviceBaseAddress
, 0, P30_CMD_READ_STATUS_REGISTER
);
173 return MmioRead32 (Instance
->DeviceBaseAddress
);
178 NorFlashBlockIsLocked (
179 IN NOR_FLASH_INSTANCE
*Instance
,
180 IN UINTN BlockAddress
185 // Send command for reading device id
186 SEND_NOR_COMMAND (BlockAddress
, 2, P30_CMD_READ_DEVICE_ID
);
188 // Read block lock status
189 LockStatus
= MmioRead32 (CREATE_NOR_ADDRESS(BlockAddress
, 2));
191 // Decode block lock status
192 LockStatus
= FOLD_32BIT_INTO_16BIT(LockStatus
);
194 if ((LockStatus
& 0x2) != 0) {
195 DEBUG((EFI_D_ERROR
, "NorFlashBlockIsLocked: WARNING: Block LOCKED DOWN\n"));
198 return ((LockStatus
& 0x1) != 0);
203 NorFlashUnlockSingleBlock (
204 IN NOR_FLASH_INSTANCE
*Instance
,
205 IN UINTN BlockAddress
210 // Raise the Task Priority Level to TPL_NOTIFY to serialise all its operations
211 // and to protect shared data structures.
213 if (FeaturePcdGet (PcdNorFlashCheckBlockLocked
) == TRUE
) {
215 // Request a lock setup
216 SEND_NOR_COMMAND (BlockAddress
, 0, P30_CMD_LOCK_BLOCK_SETUP
);
219 SEND_NOR_COMMAND (BlockAddress
, 0, P30_CMD_UNLOCK_BLOCK
);
221 // Send command for reading device id
222 SEND_NOR_COMMAND (BlockAddress
, 2, P30_CMD_READ_DEVICE_ID
);
224 // Read block lock status
225 LockStatus
= MmioRead32 (CREATE_NOR_ADDRESS(BlockAddress
, 2));
227 // Decode block lock status
228 LockStatus
= FOLD_32BIT_INTO_16BIT(LockStatus
);
229 } while ((LockStatus
& 0x1) == 1);
231 // Request a lock setup
232 SEND_NOR_COMMAND (BlockAddress
, 0, P30_CMD_LOCK_BLOCK_SETUP
);
235 SEND_NOR_COMMAND (BlockAddress
, 0, P30_CMD_UNLOCK_BLOCK
);
237 // Wait until the status register gives us the all clear
239 LockStatus
= NorFlashReadStatusRegister (Instance
, BlockAddress
);
240 } while ((LockStatus
& P30_SR_BIT_WRITE
) != P30_SR_BIT_WRITE
);
243 // Put device back into Read Array mode
244 SEND_NOR_COMMAND (BlockAddress
, 0, P30_CMD_READ_ARRAY
);
246 DEBUG((DEBUG_BLKIO
, "UnlockSingleBlock: BlockAddress=0x%08x\n", BlockAddress
));
253 NorFlashUnlockSingleBlockIfNecessary (
254 IN NOR_FLASH_INSTANCE
*Instance
,
255 IN UINTN BlockAddress
260 Status
= EFI_SUCCESS
;
262 if (NorFlashBlockIsLocked (Instance
, BlockAddress
)) {
263 Status
= NorFlashUnlockSingleBlock (Instance
, BlockAddress
);
271 * The following function presumes that the block has already been unlocked.
275 NorFlashEraseSingleBlock (
276 IN NOR_FLASH_INSTANCE
*Instance
,
277 IN UINTN BlockAddress
281 UINT32 StatusRegister
;
283 Status
= EFI_SUCCESS
;
285 // Request a block erase and then confirm it
286 SEND_NOR_COMMAND(BlockAddress
, 0, P30_CMD_BLOCK_ERASE_SETUP
);
287 SEND_NOR_COMMAND(BlockAddress
, 0, P30_CMD_BLOCK_ERASE_CONFIRM
);
289 // Wait until the status register gives us the all clear
291 StatusRegister
= NorFlashReadStatusRegister (Instance
, BlockAddress
);
292 } while ((StatusRegister
& P30_SR_BIT_WRITE
) != P30_SR_BIT_WRITE
);
294 if (StatusRegister
& P30_SR_BIT_VPP
) {
295 DEBUG((EFI_D_ERROR
,"EraseSingleBlock(BlockAddress=0x%08x: VPP Range Error\n", BlockAddress
));
296 Status
= EFI_DEVICE_ERROR
;
299 if ((StatusRegister
& (P30_SR_BIT_ERASE
| P30_SR_BIT_PROGRAM
)) == (P30_SR_BIT_ERASE
| P30_SR_BIT_PROGRAM
)) {
300 DEBUG((EFI_D_ERROR
,"EraseSingleBlock(BlockAddress=0x%08x: Command Sequence Error\n", BlockAddress
));
301 Status
= EFI_DEVICE_ERROR
;
304 if (StatusRegister
& P30_SR_BIT_ERASE
) {
305 DEBUG((EFI_D_ERROR
,"EraseSingleBlock(BlockAddress=0x%08x: Block Erase Error StatusRegister:0x%X\n", BlockAddress
, StatusRegister
));
306 Status
= EFI_DEVICE_ERROR
;
309 if (StatusRegister
& P30_SR_BIT_BLOCK_LOCKED
) {
310 // The debug level message has been reduced because a device lock might happen. In this case we just retry it ...
311 DEBUG((EFI_D_INFO
,"EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error\n", BlockAddress
));
312 Status
= EFI_WRITE_PROTECTED
;
315 if (EFI_ERROR(Status
)) {
316 // Clear the Status Register
317 SEND_NOR_COMMAND (Instance
->DeviceBaseAddress
, 0, P30_CMD_CLEAR_STATUS_REGISTER
);
320 // Put device back into Read Array mode
321 SEND_NOR_COMMAND (Instance
->DeviceBaseAddress
, 0, P30_CMD_READ_ARRAY
);
327 * This function unlock and erase an entire NOR Flash block.
330 NorFlashUnlockAndEraseSingleBlock (
331 IN NOR_FLASH_INSTANCE
*Instance
,
332 IN UINTN BlockAddress
339 if (!EfiAtRuntime ()) {
340 // Raise TPL to TPL_HIGH to stop anyone from interrupting us.
341 OriginalTPL
= gBS
->RaiseTPL (TPL_HIGH_LEVEL
);
343 // This initialization is only to prevent the compiler to complain about the
344 // use of uninitialized variables
345 OriginalTPL
= TPL_HIGH_LEVEL
;
349 // The block erase might fail a first time (SW bug ?). Retry it ...
351 // Unlock the block if we have to
352 Status
= NorFlashUnlockSingleBlockIfNecessary (Instance
, BlockAddress
);
353 if (EFI_ERROR (Status
)) {
356 Status
= NorFlashEraseSingleBlock (Instance
, BlockAddress
);
358 } while ((Index
< NOR_FLASH_ERASE_RETRY
) && (Status
== EFI_WRITE_PROTECTED
));
360 if (Index
== NOR_FLASH_ERASE_RETRY
) {
361 DEBUG((EFI_D_ERROR
,"EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error (try to erase %d times)\n", BlockAddress
,Index
));
364 if (!EfiAtRuntime ()) {
365 // Interruptions can resume.
366 gBS
->RestoreTPL (OriginalTPL
);
375 NorFlashWriteSingleWord (
376 IN NOR_FLASH_INSTANCE
*Instance
,
377 IN UINTN WordAddress
,
382 UINT32 StatusRegister
;
384 Status
= EFI_SUCCESS
;
386 // Request a write single word command
387 SEND_NOR_COMMAND(WordAddress
, 0, P30_CMD_WORD_PROGRAM_SETUP
);
389 // Store the word into NOR Flash;
390 MmioWrite32 (WordAddress
, WriteData
);
392 // Wait for the write to complete and then check for any errors; i.e. check the Status Register
394 // Prepare to read the status register
395 StatusRegister
= NorFlashReadStatusRegister (Instance
, WordAddress
);
396 // The chip is busy while the WRITE bit is not asserted
397 } while ((StatusRegister
& P30_SR_BIT_WRITE
) != P30_SR_BIT_WRITE
);
400 // Perform a full status check:
401 // Mask the relevant bits of Status Register.
402 // Everything should be zero, if not, we have a problem
404 if (StatusRegister
& P30_SR_BIT_VPP
) {
405 DEBUG((EFI_D_ERROR
,"NorFlashWriteSingleWord(WordAddress:0x%X): VPP Range Error\n",WordAddress
));
406 Status
= EFI_DEVICE_ERROR
;
409 if (StatusRegister
& P30_SR_BIT_PROGRAM
) {
410 DEBUG((EFI_D_ERROR
,"NorFlashWriteSingleWord(WordAddress:0x%X): Program Error\n",WordAddress
));
411 Status
= EFI_DEVICE_ERROR
;
414 if (StatusRegister
& P30_SR_BIT_BLOCK_LOCKED
) {
415 DEBUG((EFI_D_ERROR
,"NorFlashWriteSingleWord(WordAddress:0x%X): Device Protect Error\n",WordAddress
));
416 Status
= EFI_DEVICE_ERROR
;
419 if (!EFI_ERROR(Status
)) {
420 // Clear the Status Register
421 SEND_NOR_COMMAND (Instance
->DeviceBaseAddress
, 0, P30_CMD_CLEAR_STATUS_REGISTER
);
424 // Put device back into Read Array mode
425 SEND_NOR_COMMAND (Instance
->DeviceBaseAddress
, 0, P30_CMD_READ_ARRAY
);
431 * Writes data to the NOR Flash using the Buffered Programming method.
433 * The maximum size of the on-chip buffer is 32-words, because of hardware restrictions.
434 * Therefore this function will only handle buffers up to 32 words or 128 bytes.
435 * To deal with larger buffers, call this function again.
437 * This function presumes that both the TargetAddress and the TargetAddress+BufferSize
438 * exist entirely within the NOR Flash. Therefore these conditions will not be checked here.
440 * In buffered programming, if the target address not at the beginning of a 32-bit word boundary,
441 * then programming time is doubled and power consumption is increased.
442 * Therefore, it is a requirement to align buffer writes to 32-bit word boundaries.
443 * i.e. the last 4 bits of the target start address must be zero: 0x......00
446 NorFlashWriteBuffer (
447 IN NOR_FLASH_INSTANCE
*Instance
,
448 IN UINTN TargetAddress
,
449 IN UINTN BufferSizeInBytes
,
454 UINTN BufferSizeInWords
;
456 volatile UINT32
*Data
;
458 BOOLEAN BufferAvailable
;
459 UINT32 StatusRegister
;
461 WaitForBuffer
= MAX_BUFFERED_PROG_ITERATIONS
;
462 BufferAvailable
= FALSE
;
464 // Check that the target address does not cross a 32-word boundary.
465 if ((TargetAddress
& BOUNDARY_OF_32_WORDS
) != 0) {
466 return EFI_INVALID_PARAMETER
;
469 // Check there are some data to program
470 if (BufferSizeInBytes
== 0) {
471 return EFI_BUFFER_TOO_SMALL
;
474 // Check that the buffer size does not exceed the maximum hardware buffer size on chip.
475 if (BufferSizeInBytes
> P30_MAX_BUFFER_SIZE_IN_BYTES
) {
476 return EFI_BAD_BUFFER_SIZE
;
479 // Check that the buffer size is a multiple of 32-bit words
480 if ((BufferSizeInBytes
% 4) != 0) {
481 return EFI_BAD_BUFFER_SIZE
;
484 // Pre-programming conditions checked, now start the algorithm.
486 // Prepare the data destination address
487 Data
= (UINT32
*)TargetAddress
;
489 // Check the availability of the buffer
491 // Issue the Buffered Program Setup command
492 SEND_NOR_COMMAND(TargetAddress
, 0, P30_CMD_BUFFERED_PROGRAM_SETUP
);
494 // Read back the status register bit#7 from the same address
495 if (((*Data
) & P30_SR_BIT_WRITE
) == P30_SR_BIT_WRITE
) {
496 BufferAvailable
= TRUE
;
499 // Update the loop counter
502 } while ((WaitForBuffer
> 0) && (BufferAvailable
== FALSE
));
504 // The buffer was not available for writing
505 if (WaitForBuffer
== 0) {
506 Status
= EFI_DEVICE_ERROR
;
510 // From now on we work in 32-bit words
511 BufferSizeInWords
= BufferSizeInBytes
/ (UINTN
)4;
513 // Write the word count, which is (buffer_size_in_words - 1),
514 // because word count 0 means one word.
515 SEND_NOR_COMMAND(TargetAddress
, 0, (BufferSizeInWords
- 1));
517 // Write the data to the NOR Flash, advancing each address by 4 bytes
518 for(Count
=0; Count
< BufferSizeInWords
; Count
++, Data
++, Buffer
++) {
519 MmioWrite32 ((UINTN
)Data
, *Buffer
);
522 // Issue the Buffered Program Confirm command, to start the programming operation
523 SEND_NOR_COMMAND (Instance
->DeviceBaseAddress
, 0, P30_CMD_BUFFERED_PROGRAM_CONFIRM
);
525 // Wait for the write to complete and then check for any errors; i.e. check the Status Register
527 StatusRegister
= NorFlashReadStatusRegister (Instance
, TargetAddress
);
528 // The chip is busy while the WRITE bit is not asserted
529 } while ((StatusRegister
& P30_SR_BIT_WRITE
) != P30_SR_BIT_WRITE
);
532 // Perform a full status check:
533 // Mask the relevant bits of Status Register.
534 // Everything should be zero, if not, we have a problem
536 Status
= EFI_SUCCESS
;
538 if (StatusRegister
& P30_SR_BIT_VPP
) {
539 DEBUG((EFI_D_ERROR
,"NorFlashWriteBuffer(TargetAddress:0x%X): VPP Range Error\n", TargetAddress
));
540 Status
= EFI_DEVICE_ERROR
;
543 if (StatusRegister
& P30_SR_BIT_PROGRAM
) {
544 DEBUG((EFI_D_ERROR
,"NorFlashWriteBuffer(TargetAddress:0x%X): Program Error\n", TargetAddress
));
545 Status
= EFI_DEVICE_ERROR
;
548 if (StatusRegister
& P30_SR_BIT_BLOCK_LOCKED
) {
549 DEBUG((EFI_D_ERROR
,"NorFlashWriteBuffer(TargetAddress:0x%X): Device Protect Error\n",TargetAddress
));
550 Status
= EFI_DEVICE_ERROR
;
553 if (!EFI_ERROR(Status
)) {
554 // Clear the Status Register
555 SEND_NOR_COMMAND (Instance
->DeviceBaseAddress
, 0, P30_CMD_CLEAR_STATUS_REGISTER
);
559 // Put device back into Read Array mode
560 SEND_NOR_COMMAND (Instance
->DeviceBaseAddress
, 0, P30_CMD_READ_ARRAY
);
567 NorFlashWriteFullBlock (
568 IN NOR_FLASH_INSTANCE
*Instance
,
570 IN UINT32
*DataBuffer
,
571 IN UINT32 BlockSizeInWords
579 UINTN BuffersInBlock
;
580 UINTN RemainingWords
;
584 Status
= EFI_SUCCESS
;
586 // Get the physical address of the block
587 BlockAddress
= GET_NOR_BLOCK_ADDRESS (Instance
->RegionBaseAddress
, Lba
, BlockSizeInWords
* 4);
589 // Start writing from the first address at the start of the block
590 WordAddress
= BlockAddress
;
592 if (!EfiAtRuntime ()) {
593 // Raise TPL to TPL_HIGH to stop anyone from interrupting us.
594 OriginalTPL
= gBS
->RaiseTPL (TPL_HIGH_LEVEL
);
596 // This initialization is only to prevent the compiler to complain about the
597 // use of uninitialized variables
598 OriginalTPL
= TPL_HIGH_LEVEL
;
601 Status
= NorFlashUnlockAndEraseSingleBlock (Instance
, BlockAddress
);
602 if (EFI_ERROR(Status
)) {
603 DEBUG((EFI_D_ERROR
, "WriteSingleBlock: ERROR - Failed to Unlock and Erase the single block at 0x%X\n", BlockAddress
));
607 // To speed up the programming operation, NOR Flash is programmed using the Buffered Programming method.
609 // Check that the address starts at a 32-word boundary, i.e. last 7 bits must be zero
610 if ((WordAddress
& BOUNDARY_OF_32_WORDS
) == 0x00) {
612 // First, break the entire block into buffer-sized chunks.
613 BuffersInBlock
= (UINTN
)(BlockSizeInWords
* 4) / P30_MAX_BUFFER_SIZE_IN_BYTES
;
615 // Then feed each buffer chunk to the NOR Flash
616 // If a buffer does not contain any data, don't write it.
618 BufferIndex
< BuffersInBlock
;
619 BufferIndex
++, WordAddress
+= P30_MAX_BUFFER_SIZE_IN_BYTES
, DataBuffer
+= P30_MAX_BUFFER_SIZE_IN_WORDS
621 // Check the buffer to see if it contains any data (not set all 1s).
622 for (Cnt
= 0; Cnt
< P30_MAX_BUFFER_SIZE_IN_WORDS
; Cnt
++) {
623 if (~DataBuffer
[Cnt
] != 0 ) {
624 // Some data found, write the buffer.
625 Status
= NorFlashWriteBuffer (Instance
, WordAddress
, P30_MAX_BUFFER_SIZE_IN_BYTES
,
627 if (EFI_ERROR(Status
)) {
635 // Finally, finish off any remaining words that are less than the maximum size of the buffer
636 RemainingWords
= BlockSizeInWords
% P30_MAX_BUFFER_SIZE_IN_WORDS
;
638 if(RemainingWords
!= 0) {
639 Status
= NorFlashWriteBuffer (Instance
, WordAddress
, (RemainingWords
* 4), DataBuffer
);
640 if (EFI_ERROR(Status
)) {
646 // For now, use the single word programming algorithm
647 // It is unlikely that the NOR Flash will exist in an address which falls within a 32 word boundary range,
648 // i.e. which ends in the range 0x......01 - 0x......7F.
649 for(WordIndex
=0; WordIndex
<BlockSizeInWords
; WordIndex
++, DataBuffer
++, WordAddress
= WordAddress
+ 4) {
650 Status
= NorFlashWriteSingleWord (Instance
, WordAddress
, *DataBuffer
);
651 if (EFI_ERROR(Status
)) {
658 if (!EfiAtRuntime ()) {
659 // Interruptions can resume.
660 gBS
->RestoreTPL (OriginalTPL
);
663 if (EFI_ERROR(Status
)) {
664 DEBUG((EFI_D_ERROR
, "NOR FLASH Programming [WriteSingleBlock] failed at address 0x%08x. Exit Status = \"%r\".\n", WordAddress
, Status
));
671 NorFlashWriteBlocks (
672 IN NOR_FLASH_INSTANCE
*Instance
,
674 IN UINTN BufferSizeInBytes
,
678 UINT32
*pWriteBuffer
;
679 EFI_STATUS Status
= EFI_SUCCESS
;
680 EFI_LBA CurrentBlock
;
681 UINT32 BlockSizeInWords
;
685 // The buffer must be valid
686 if (Buffer
== NULL
) {
687 return EFI_INVALID_PARAMETER
;
690 if(Instance
->Media
.ReadOnly
== TRUE
) {
691 return EFI_WRITE_PROTECTED
;
694 // We must have some bytes to read
695 DEBUG((DEBUG_BLKIO
, "NorFlashWriteBlocks: BufferSizeInBytes=0x%x\n", BufferSizeInBytes
));
696 if(BufferSizeInBytes
== 0) {
697 return EFI_BAD_BUFFER_SIZE
;
700 // The size of the buffer must be a multiple of the block size
701 DEBUG((DEBUG_BLKIO
, "NorFlashWriteBlocks: BlockSize in bytes =0x%x\n", Instance
->Media
.BlockSize
));
702 if ((BufferSizeInBytes
% Instance
->Media
.BlockSize
) != 0) {
703 return EFI_BAD_BUFFER_SIZE
;
706 // All blocks must be within the device
707 NumBlocks
= ((UINT32
)BufferSizeInBytes
) / Instance
->Media
.BlockSize
;
709 DEBUG((DEBUG_BLKIO
, "NorFlashWriteBlocks: NumBlocks=%d, LastBlock=%ld, Lba=%ld.\n", NumBlocks
, Instance
->Media
.LastBlock
, Lba
));
711 if ((Lba
+ NumBlocks
) > (Instance
->Media
.LastBlock
+ 1)) {
712 DEBUG((EFI_D_ERROR
, "NorFlashWriteBlocks: ERROR - Write will exceed last block.\n"));
713 return EFI_INVALID_PARAMETER
;
716 BlockSizeInWords
= Instance
->Media
.BlockSize
/ 4;
718 // Because the target *Buffer is a pointer to VOID, we must put all the data into a pointer
719 // to a proper data type, so use *ReadBuffer
720 pWriteBuffer
= (UINT32
*)Buffer
;
723 for (BlockCount
=0; BlockCount
< NumBlocks
; BlockCount
++, CurrentBlock
++, pWriteBuffer
= pWriteBuffer
+ BlockSizeInWords
) {
725 DEBUG((DEBUG_BLKIO
, "NorFlashWriteBlocks: Writing block #%d\n", (UINTN
)CurrentBlock
));
727 Status
= NorFlashWriteFullBlock (Instance
, CurrentBlock
, pWriteBuffer
, BlockSizeInWords
);
729 if (EFI_ERROR(Status
)) {
734 DEBUG((DEBUG_BLKIO
, "NorFlashWriteBlocks: Exit Status = \"%r\".\n", Status
));
738 #define BOTH_ALIGNED(a, b, align) ((((UINTN)(a) | (UINTN)(b)) & ((align) - 1)) == 0)
741 Copy Length bytes from Source to Destination, using aligned accesses only.
742 Note that this implementation uses memcpy() semantics rather then memmove()
743 semantics, i.e., SourceBuffer and DestinationBuffer should not overlap.
745 @param DestinationBuffer The target of the copy request.
746 @param SourceBuffer The place to copy from.
747 @param Length The number of bytes to copy.
755 OUT VOID
*DestinationBuffer
,
756 IN CONST VOID
*SourceBuffer
,
761 CONST UINT8
*Source8
;
762 UINT32
*Destination32
;
763 CONST UINT32
*Source32
;
764 UINT64
*Destination64
;
765 CONST UINT64
*Source64
;
767 if (BOTH_ALIGNED(DestinationBuffer
, SourceBuffer
, 8) && Length
>= 8) {
768 Destination64
= DestinationBuffer
;
769 Source64
= SourceBuffer
;
770 while (Length
>= 8) {
771 *Destination64
++ = *Source64
++;
775 Destination8
= (UINT8
*)Destination64
;
776 Source8
= (CONST UINT8
*)Source64
;
777 } else if (BOTH_ALIGNED(DestinationBuffer
, SourceBuffer
, 4) && Length
>= 4) {
778 Destination32
= DestinationBuffer
;
779 Source32
= SourceBuffer
;
780 while (Length
>= 4) {
781 *Destination32
++ = *Source32
++;
785 Destination8
= (UINT8
*)Destination32
;
786 Source8
= (CONST UINT8
*)Source32
;
788 Destination8
= DestinationBuffer
;
789 Source8
= SourceBuffer
;
791 while (Length
-- != 0) {
792 *Destination8
++ = *Source8
++;
794 return DestinationBuffer
;
799 IN NOR_FLASH_INSTANCE
*Instance
,
801 IN UINTN BufferSizeInBytes
,
808 DEBUG((DEBUG_BLKIO
, "NorFlashReadBlocks: BufferSize=0x%xB BlockSize=0x%xB LastBlock=%ld, Lba=%ld.\n",
809 BufferSizeInBytes
, Instance
->Media
.BlockSize
, Instance
->Media
.LastBlock
, Lba
));
811 // The buffer must be valid
812 if (Buffer
== NULL
) {
813 return EFI_INVALID_PARAMETER
;
816 // Return if we have not any byte to read
817 if (BufferSizeInBytes
== 0) {
821 // The size of the buffer must be a multiple of the block size
822 if ((BufferSizeInBytes
% Instance
->Media
.BlockSize
) != 0) {
823 return EFI_BAD_BUFFER_SIZE
;
826 // All blocks must be within the device
827 NumBlocks
= ((UINT32
)BufferSizeInBytes
) / Instance
->Media
.BlockSize
;
829 if ((Lba
+ NumBlocks
) > (Instance
->Media
.LastBlock
+ 1)) {
830 DEBUG((EFI_D_ERROR
, "NorFlashReadBlocks: ERROR - Read will exceed last block\n"));
831 return EFI_INVALID_PARAMETER
;
834 // Get the address to start reading from
835 StartAddress
= GET_NOR_BLOCK_ADDRESS (Instance
->RegionBaseAddress
,
837 Instance
->Media
.BlockSize
840 // Put the device into Read Array mode
841 SEND_NOR_COMMAND (Instance
->DeviceBaseAddress
, 0, P30_CMD_READ_ARRAY
);
844 AlignedCopyMem (Buffer
, (VOID
*)StartAddress
, BufferSizeInBytes
);
851 IN NOR_FLASH_INSTANCE
*Instance
,
854 IN UINTN BufferSizeInBytes
,
860 // The buffer must be valid
861 if (Buffer
== NULL
) {
862 return EFI_INVALID_PARAMETER
;
865 // Return if we have not any byte to read
866 if (BufferSizeInBytes
== 0) {
870 if (((Lba
* Instance
->Media
.BlockSize
) + Offset
+ BufferSizeInBytes
) > Instance
->Size
) {
871 DEBUG ((EFI_D_ERROR
, "NorFlashRead: ERROR - Read will exceed device size.\n"));
872 return EFI_INVALID_PARAMETER
;
875 // Get the address to start reading from
876 StartAddress
= GET_NOR_BLOCK_ADDRESS (Instance
->RegionBaseAddress
,
878 Instance
->Media
.BlockSize
881 // Put the device into Read Array mode
882 SEND_NOR_COMMAND (Instance
->DeviceBaseAddress
, 0, P30_CMD_READ_ARRAY
);
885 AlignedCopyMem (Buffer
, (VOID
*)(StartAddress
+ Offset
), BufferSizeInBytes
);
891 Write a full or portion of a block. It must not span block boundaries; that is,
892 Offset + *NumBytes <= Instance->Media.BlockSize.
895 NorFlashWriteSingleBlock (
896 IN NOR_FLASH_INSTANCE
*Instance
,
899 IN OUT UINTN
*NumBytes
,
903 EFI_STATUS TempStatus
;
914 UINTN PrevBlockAddress
;
916 PrevBlockAddress
= 0;
918 DEBUG ((DEBUG_BLKIO
, "NorFlashWriteSingleBlock(Parameters: Lba=%ld, Offset=0x%x, *NumBytes=0x%x, Buffer @ 0x%08x)\n", Lba
, Offset
, *NumBytes
, Buffer
));
920 // Detect WriteDisabled state
921 if (Instance
->Media
.ReadOnly
== TRUE
) {
922 DEBUG ((EFI_D_ERROR
, "NorFlashWriteSingleBlock: ERROR - Can not write: Device is in WriteDisabled state.\n"));
923 // It is in WriteDisabled state, return an error right away
924 return EFI_ACCESS_DENIED
;
927 // Cache the block size to avoid de-referencing pointers all the time
928 BlockSize
= Instance
->Media
.BlockSize
;
930 // The write must not span block boundaries.
931 // We need to check each variable individually because adding two large values together overflows.
932 if ( ( Offset
>= BlockSize
) ||
933 ( *NumBytes
> BlockSize
) ||
934 ( (Offset
+ *NumBytes
) > BlockSize
) ) {
935 DEBUG ((EFI_D_ERROR
, "NorFlashWriteSingleBlock: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", Offset
, *NumBytes
, BlockSize
));
936 return EFI_BAD_BUFFER_SIZE
;
939 // We must have some bytes to write
940 if (*NumBytes
== 0) {
941 DEBUG ((EFI_D_ERROR
, "NorFlashWriteSingleBlock: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", Offset
, *NumBytes
, BlockSize
));
942 return EFI_BAD_BUFFER_SIZE
;
945 // Pick 128bytes as a good start for word operations as opposed to erasing the
946 // block and writing the data regardless if an erase is really needed.
947 // It looks like most individual NV variable writes are smaller than 128bytes.
948 if (*NumBytes
<= 128) {
949 // Check to see if we need to erase before programming the data into NOR.
950 // If the destination bits are only changing from 1s to 0s we can just write.
951 // After a block is erased all bits in the block is set to 1.
952 // If any byte requires us to erase we just give up and rewrite all of it.
954 BytesToWrite
= *NumBytes
;
957 while (BytesToWrite
> 0) {
958 // Read full word from NOR, splice as required. A word is the smallest
959 // unit we can write.
960 TempStatus
= NorFlashRead (Instance
, Lba
, CurOffset
& ~(0x3), sizeof(Tmp
), &Tmp
);
961 if (EFI_ERROR (TempStatus
)) {
962 return EFI_DEVICE_ERROR
;
965 // Physical address of word in NOR to write.
966 WordAddr
= (CurOffset
& ~(0x3)) + GET_NOR_BLOCK_ADDRESS (Instance
->RegionBaseAddress
,
968 // The word of data that is to be written.
969 TmpBuf
= *((UINT32
*)(Buffer
+ (*NumBytes
- BytesToWrite
)));
971 // First do word aligned chunks.
972 if ((CurOffset
& 0x3) == 0) {
973 if (BytesToWrite
>= 4) {
974 // Is the destination still in 'erased' state?
976 // Check to see if we are only changing bits to zero.
977 if ((Tmp
^ TmpBuf
) & TmpBuf
) {
982 // Write this word to NOR
983 WordToWrite
= TmpBuf
;
984 CurOffset
+= sizeof(TmpBuf
);
985 BytesToWrite
-= sizeof(TmpBuf
);
987 // BytesToWrite < 4. Do small writes and left-overs
988 Mask
= ~((~0) << (BytesToWrite
* 8));
989 // Mask out the bytes we want.
991 // Is the destination still in 'erased' state?
992 if ((Tmp
& Mask
) != Mask
) {
993 // Check to see if we are only changing bits to zero.
994 if ((Tmp
^ TmpBuf
) & TmpBuf
) {
999 // Merge old and new data. Write merged word to NOR
1000 WordToWrite
= (Tmp
& ~Mask
) | TmpBuf
;
1001 CurOffset
+= BytesToWrite
;
1005 // Do multiple words, but starting unaligned.
1006 if (BytesToWrite
> (4 - (CurOffset
& 0x3))) {
1007 Mask
= ((~0) << ((CurOffset
& 0x3) * 8));
1008 // Mask out the bytes we want.
1010 // Is the destination still in 'erased' state?
1011 if ((Tmp
& Mask
) != Mask
) {
1012 // Check to see if we are only changing bits to zero.
1013 if ((Tmp
^ TmpBuf
) & TmpBuf
) {
1018 // Merge old and new data. Write merged word to NOR
1019 WordToWrite
= (Tmp
& ~Mask
) | TmpBuf
;
1020 BytesToWrite
-= (4 - (CurOffset
& 0x3));
1021 CurOffset
+= (4 - (CurOffset
& 0x3));
1023 // Unaligned and fits in one word.
1024 Mask
= (~((~0) << (BytesToWrite
* 8))) << ((CurOffset
& 0x3) * 8);
1025 // Mask out the bytes we want.
1026 TmpBuf
= (TmpBuf
<< ((CurOffset
& 0x3) * 8)) & Mask
;
1027 // Is the destination still in 'erased' state?
1028 if ((Tmp
& Mask
) != Mask
) {
1029 // Check to see if we are only changing bits to zero.
1030 if ((Tmp
^ TmpBuf
) & TmpBuf
) {
1035 // Merge old and new data. Write merged word to NOR
1036 WordToWrite
= (Tmp
& ~Mask
) | TmpBuf
;
1037 CurOffset
+= BytesToWrite
;
1043 // Write the word to NOR.
1046 BlockAddress
= GET_NOR_BLOCK_ADDRESS (Instance
->RegionBaseAddress
, Lba
, BlockSize
);
1047 if (BlockAddress
!= PrevBlockAddress
) {
1048 TempStatus
= NorFlashUnlockSingleBlockIfNecessary (Instance
, BlockAddress
);
1049 if (EFI_ERROR (TempStatus
)) {
1050 return EFI_DEVICE_ERROR
;
1052 PrevBlockAddress
= BlockAddress
;
1054 TempStatus
= NorFlashWriteSingleWord (Instance
, WordAddr
, WordToWrite
);
1055 if (EFI_ERROR (TempStatus
)) {
1056 return EFI_DEVICE_ERROR
;
1059 // Exit if we got here and could write all the data. Otherwise do the
1060 // Erase-Write cycle.
1066 // Check we did get some memory. Buffer is BlockSize.
1067 if (Instance
->ShadowBuffer
== NULL
) {
1068 DEBUG ((EFI_D_ERROR
, "FvbWrite: ERROR - Buffer not ready\n"));
1069 return EFI_DEVICE_ERROR
;
1072 // Read NOR Flash data into shadow buffer
1073 TempStatus
= NorFlashReadBlocks (Instance
, Lba
, BlockSize
, Instance
->ShadowBuffer
);
1074 if (EFI_ERROR (TempStatus
)) {
1075 // Return one of the pre-approved error statuses
1076 return EFI_DEVICE_ERROR
;
1079 // Put the data at the appropriate location inside the buffer area
1080 CopyMem ((VOID
*)((UINTN
)Instance
->ShadowBuffer
+ Offset
), Buffer
, *NumBytes
);
1082 // Write the modified buffer back to the NorFlash
1083 TempStatus
= NorFlashWriteBlocks (Instance
, Lba
, BlockSize
, Instance
->ShadowBuffer
);
1084 if (EFI_ERROR (TempStatus
)) {
1085 // Return one of the pre-approved error statuses
1086 return EFI_DEVICE_ERROR
;
1093 Although DiskIoDxe will automatically install the DiskIO protocol whenever
1094 we install the BlockIO protocol, its implementation is sub-optimal as it reads
1095 and writes entire blocks using the BlockIO protocol. In fact we can access
1096 NOR flash with a finer granularity than that, so we can improve performance
1097 by directly producing the DiskIO protocol.
1101 Read BufferSize bytes from Offset into Buffer.
1103 @param This Protocol instance pointer.
1104 @param MediaId Id of the media, changes every time the media is replaced.
1105 @param Offset The starting byte offset to read from
1106 @param BufferSize Size of Buffer
1107 @param Buffer Buffer containing read data
1109 @retval EFI_SUCCESS The data was read correctly from the device.
1110 @retval EFI_DEVICE_ERROR The device reported an error while performing the read.
1111 @retval EFI_NO_MEDIA There is no media in the device.
1112 @retval EFI_MEDIA_CHANGED The MediaId does not match the current device.
1113 @retval EFI_INVALID_PARAMETER The read request contains device addresses that are not
1114 valid for the device.
1119 NorFlashDiskIoReadDisk (
1120 IN EFI_DISK_IO_PROTOCOL
*This
,
1122 IN UINT64 DiskOffset
,
1123 IN UINTN BufferSize
,
1127 NOR_FLASH_INSTANCE
*Instance
;
1132 Instance
= INSTANCE_FROM_DISKIO_THIS(This
);
1134 if (MediaId
!= Instance
->Media
.MediaId
) {
1135 return EFI_MEDIA_CHANGED
;
1138 BlockSize
= Instance
->Media
.BlockSize
;
1139 Lba
= (EFI_LBA
) DivU64x32Remainder (DiskOffset
, BlockSize
, &BlockOffset
);
1141 return NorFlashRead (Instance
, Lba
, BlockOffset
, BufferSize
, Buffer
);
1145 Writes a specified number of bytes to a device.
1147 @param This Indicates a pointer to the calling context.
1148 @param MediaId ID of the medium to be written.
1149 @param Offset The starting byte offset on the logical block I/O device to write.
1150 @param BufferSize The size in bytes of Buffer. The number of bytes to write to the device.
1151 @param Buffer A pointer to the buffer containing the data to be written.
1153 @retval EFI_SUCCESS The data was written correctly to the device.
1154 @retval EFI_WRITE_PROTECTED The device can not be written to.
1155 @retval EFI_DEVICE_ERROR The device reported an error while performing the write.
1156 @retval EFI_NO_MEDIA There is no media in the device.
1157 @retval EFI_MEDIA_CHANGED The MediaId does not match the current device.
1158 @retval EFI_INVALID_PARAMETER The write request contains device addresses that are not
1159 valid for the device.
1164 NorFlashDiskIoWriteDisk (
1165 IN EFI_DISK_IO_PROTOCOL
*This
,
1167 IN UINT64 DiskOffset
,
1168 IN UINTN BufferSize
,
1172 NOR_FLASH_INSTANCE
*Instance
;
1176 UINTN RemainingBytes
;
1180 Instance
= INSTANCE_FROM_DISKIO_THIS(This
);
1182 if (MediaId
!= Instance
->Media
.MediaId
) {
1183 return EFI_MEDIA_CHANGED
;
1186 BlockSize
= Instance
->Media
.BlockSize
;
1187 Lba
= (EFI_LBA
) DivU64x32Remainder (DiskOffset
, BlockSize
, &BlockOffset
);
1189 RemainingBytes
= BufferSize
;
1191 // Write either all the remaining bytes, or the number of bytes that bring
1192 // us up to a block boundary, whichever is less.
1193 // (DiskOffset | (BlockSize - 1)) + 1) rounds DiskOffset up to the next
1194 // block boundary (even if it is already on one).
1195 WriteSize
= MIN (RemainingBytes
, ((DiskOffset
| (BlockSize
- 1)) + 1) - DiskOffset
);
1198 if (WriteSize
== BlockSize
) {
1199 // Write a full block
1200 Status
= NorFlashWriteFullBlock (Instance
, Lba
, Buffer
, BlockSize
/ sizeof (UINT32
));
1202 // Write a partial block
1203 Status
= NorFlashWriteSingleBlock (Instance
, Lba
, BlockOffset
, &WriteSize
, Buffer
);
1205 if (EFI_ERROR (Status
)) {
1208 // Now continue writing either all the remaining bytes or single blocks.
1209 RemainingBytes
-= WriteSize
;
1210 Buffer
= (UINT8
*) Buffer
+ WriteSize
;
1213 WriteSize
= MIN (RemainingBytes
, BlockSize
);
1214 } while (RemainingBytes
);
1221 IN NOR_FLASH_INSTANCE
*Instance
1224 // As there is no specific RESET to perform, ensure that the devices is in the default Read Array mode
1225 SEND_NOR_COMMAND (Instance
->DeviceBaseAddress
, 0, P30_CMD_READ_ARRAY
);
1230 Fixup internal data so that EFI can be call in virtual mode.
1231 Call the passed in Child Notify event and convert any pointers in
1232 lib to virtual mode.
1234 @param[in] Event The Event that is being processed
1235 @param[in] Context Event Context
1239 NorFlashVirtualNotifyEvent (
1246 for (Index
= 0; Index
< mNorFlashDeviceCount
; Index
++) {
1247 EfiConvertPointer (0x0, (VOID
**)&mNorFlashInstances
[Index
]->DeviceBaseAddress
);
1248 EfiConvertPointer (0x0, (VOID
**)&mNorFlashInstances
[Index
]->RegionBaseAddress
);
1250 // Convert BlockIo protocol
1251 EfiConvertPointer (0x0, (VOID
**)&mNorFlashInstances
[Index
]->BlockIoProtocol
.FlushBlocks
);
1252 EfiConvertPointer (0x0, (VOID
**)&mNorFlashInstances
[Index
]->BlockIoProtocol
.ReadBlocks
);
1253 EfiConvertPointer (0x0, (VOID
**)&mNorFlashInstances
[Index
]->BlockIoProtocol
.Reset
);
1254 EfiConvertPointer (0x0, (VOID
**)&mNorFlashInstances
[Index
]->BlockIoProtocol
.WriteBlocks
);
1257 EfiConvertPointer (0x0, (VOID
**)&mNorFlashInstances
[Index
]->FvbProtocol
.EraseBlocks
);
1258 EfiConvertPointer (0x0, (VOID
**)&mNorFlashInstances
[Index
]->FvbProtocol
.GetAttributes
);
1259 EfiConvertPointer (0x0, (VOID
**)&mNorFlashInstances
[Index
]->FvbProtocol
.GetBlockSize
);
1260 EfiConvertPointer (0x0, (VOID
**)&mNorFlashInstances
[Index
]->FvbProtocol
.GetPhysicalAddress
);
1261 EfiConvertPointer (0x0, (VOID
**)&mNorFlashInstances
[Index
]->FvbProtocol
.Read
);
1262 EfiConvertPointer (0x0, (VOID
**)&mNorFlashInstances
[Index
]->FvbProtocol
.SetAttributes
);
1263 EfiConvertPointer (0x0, (VOID
**)&mNorFlashInstances
[Index
]->FvbProtocol
.Write
);
1265 if (mNorFlashInstances
[Index
]->ShadowBuffer
!= NULL
) {
1266 EfiConvertPointer (0x0, (VOID
**)&mNorFlashInstances
[Index
]->ShadowBuffer
);
1275 NorFlashInitialise (
1276 IN EFI_HANDLE ImageHandle
,
1277 IN EFI_SYSTEM_TABLE
*SystemTable
1282 NOR_FLASH_DESCRIPTION
* NorFlashDevices
;
1283 BOOLEAN ContainVariableStorage
;
1285 Status
= NorFlashPlatformInitialization ();
1286 if (EFI_ERROR(Status
)) {
1287 DEBUG((EFI_D_ERROR
,"NorFlashInitialise: Fail to initialize Nor Flash devices\n"));
1291 Status
= NorFlashPlatformGetDevices (&NorFlashDevices
, &mNorFlashDeviceCount
);
1292 if (EFI_ERROR(Status
)) {
1293 DEBUG((EFI_D_ERROR
,"NorFlashInitialise: Fail to get Nor Flash devices\n"));
1297 mNorFlashInstances
= AllocateRuntimePool (sizeof(NOR_FLASH_INSTANCE
*) * mNorFlashDeviceCount
);
1299 for (Index
= 0; Index
< mNorFlashDeviceCount
; Index
++) {
1300 // Check if this NOR Flash device contain the variable storage region
1301 ContainVariableStorage
=
1302 (NorFlashDevices
[Index
].RegionBaseAddress
<= PcdGet32 (PcdFlashNvStorageVariableBase
)) &&
1303 (PcdGet32 (PcdFlashNvStorageVariableBase
) + PcdGet32 (PcdFlashNvStorageVariableSize
) <= NorFlashDevices
[Index
].RegionBaseAddress
+ NorFlashDevices
[Index
].Size
);
1305 Status
= NorFlashCreateInstance (
1306 NorFlashDevices
[Index
].DeviceBaseAddress
,
1307 NorFlashDevices
[Index
].RegionBaseAddress
,
1308 NorFlashDevices
[Index
].Size
,
1310 NorFlashDevices
[Index
].BlockSize
,
1311 ContainVariableStorage
,
1312 &mNorFlashInstances
[Index
]
1314 if (EFI_ERROR(Status
)) {
1315 DEBUG((EFI_D_ERROR
,"NorFlashInitialise: Fail to create instance for NorFlash[%d]\n",Index
));
1320 // Register for the virtual address change event
1322 Status
= gBS
->CreateEventEx (
1325 NorFlashVirtualNotifyEvent
,
1327 &gEfiEventVirtualAddressChangeGuid
,
1328 &mNorFlashVirtualAddrChangeEvent
1330 ASSERT_EFI_ERROR (Status
);