#\r
LcdPlatformLib|Include/Library/LcdPlatformLib.h\r
\r
- ## @libraryclass Provides a Nor flash interface.\r
- #\r
- NorFlashPlatformLib|Include/Library/NorFlashPlatformLib.h\r
-\r
## @libraryclass Provides an interface to the clock of a PL011 device.\r
#\r
PL011UartClockLib|Include/Library/PL011UartClockLib.h\r
[PcdsFeatureFlag.common]\r
gArmPlatformTokenSpaceGuid.PcdSendSgiToBringUpSecondaryCores|FALSE|BOOLEAN|0x00000004\r
\r
- gArmPlatformTokenSpaceGuid.PcdNorFlashCheckBlockLocked|FALSE|BOOLEAN|0x0000003C\r
-\r
# Disable the GOP controller on ExitBootServices(). By default the value is FALSE,\r
# we assume the OS will handle the FrameBuffer from the UEFI GOP information.\r
gArmPlatformTokenSpaceGuid.PcdGopDisableOnExitBootServices|FALSE|BOOLEAN|0x0000003D\r
LzmaDecompressLib|MdeModulePkg/Library/LzmaCustomDecompressLib/LzmaCustomDecompressLib.inf\r
MemoryAllocationLib|MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf\r
MemoryInitPeiLib|ArmPlatformPkg/MemoryInitPei/MemoryInitPeiLib.inf\r
- NorFlashPlatformLib|ArmPlatformPkg/Library/NorFlashPlatformNullLib/NorFlashPlatformNullLib.inf\r
PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf\r
PeCoffExtraActionLib|MdePkg/Library/BasePeCoffExtraActionLibNull/BasePeCoffExtraActionLibNull.inf\r
PeCoffLib|MdePkg/Library/BasePeCoffLib/BasePeCoffLib.inf\r
\r
[Components.common]\r
ArmPlatformPkg/Drivers/LcdGraphicsOutputDxe/LcdGraphicsOutputDxe.inf\r
- ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashDxe.inf\r
ArmPlatformPkg/Drivers/PL061GpioDxe/PL061GpioDxe.inf\r
ArmPlatformPkg/Drivers/SP805WatchdogDxe/SP805WatchdogDxe.inf\r
\r
ArmPlatformPkg/Library/HdLcd/HdLcd.inf\r
ArmPlatformPkg/Library/LcdHwNullLib/LcdHwNullLib.inf\r
ArmPlatformPkg/Library/LcdPlatformNullLib/LcdPlatformNullLib.inf\r
- ArmPlatformPkg/Library/NorFlashPlatformNullLib/NorFlashPlatformNullLib.inf\r
ArmPlatformPkg/Library/PL011SerialPortLib/PL011SerialPortLib.inf\r
ArmPlatformPkg/Library/PL011UartClockLib/PL011UartClockLib.inf\r
ArmPlatformPkg/Library/PL011UartLib/PL011UartLib.inf\r
ArmPlatformPkg/PrePi/PeiUniCore.inf\r
\r
ArmPlatformPkg/Library/ArmMaliDp/ArmMaliDp.inf\r
-\r
-[Components.AARCH64]\r
- ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashStandaloneMm.inf\r
+++ /dev/null
-/** @file NorFlash.c\r
-\r
- Copyright (c) 2011 - 2020, Arm Limited. All rights reserved.<BR>\r
- Copyright (c) 2020, Linaro, Ltd. All rights reserved.<BR>\r
-\r
- SPDX-License-Identifier: BSD-2-Clause-Patent\r
-\r
-**/\r
-\r
-#include <Library/BaseMemoryLib.h>\r
-\r
-#include "NorFlash.h"\r
-\r
-//\r
-// Global variable declarations\r
-//\r
-extern NOR_FLASH_INSTANCE **mNorFlashInstances;\r
-extern UINT32 mNorFlashDeviceCount;\r
-\r
-UINT32\r
-NorFlashReadStatusRegister (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN SR_Address\r
- )\r
-{\r
- // Prepare to read the status register\r
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_STATUS_REGISTER);\r
- return MmioRead32 (Instance->DeviceBaseAddress);\r
-}\r
-\r
-STATIC\r
-BOOLEAN\r
-NorFlashBlockIsLocked (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN BlockAddress\r
- )\r
-{\r
- UINT32 LockStatus;\r
-\r
- // Send command for reading device id\r
- SEND_NOR_COMMAND (BlockAddress, 2, P30_CMD_READ_DEVICE_ID);\r
-\r
- // Read block lock status\r
- LockStatus = MmioRead32 (CREATE_NOR_ADDRESS (BlockAddress, 2));\r
-\r
- // Decode block lock status\r
- LockStatus = FOLD_32BIT_INTO_16BIT (LockStatus);\r
-\r
- if ((LockStatus & 0x2) != 0) {\r
- DEBUG ((DEBUG_ERROR, "NorFlashBlockIsLocked: WARNING: Block LOCKED DOWN\n"));\r
- }\r
-\r
- return ((LockStatus & 0x1) != 0);\r
-}\r
-\r
-STATIC\r
-EFI_STATUS\r
-NorFlashUnlockSingleBlock (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN BlockAddress\r
- )\r
-{\r
- UINT32 LockStatus;\r
-\r
- // Raise the Task Priority Level to TPL_NOTIFY to serialise all its operations\r
- // and to protect shared data structures.\r
-\r
- if (FeaturePcdGet (PcdNorFlashCheckBlockLocked) == TRUE) {\r
- do {\r
- // Request a lock setup\r
- SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_LOCK_BLOCK_SETUP);\r
-\r
- // Request an unlock\r
- SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_UNLOCK_BLOCK);\r
-\r
- // Send command for reading device id\r
- SEND_NOR_COMMAND (BlockAddress, 2, P30_CMD_READ_DEVICE_ID);\r
-\r
- // Read block lock status\r
- LockStatus = MmioRead32 (CREATE_NOR_ADDRESS (BlockAddress, 2));\r
-\r
- // Decode block lock status\r
- LockStatus = FOLD_32BIT_INTO_16BIT (LockStatus);\r
- } while ((LockStatus & 0x1) == 1);\r
- } else {\r
- // Request a lock setup\r
- SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_LOCK_BLOCK_SETUP);\r
-\r
- // Request an unlock\r
- SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_UNLOCK_BLOCK);\r
-\r
- // Wait until the status register gives us the all clear\r
- do {\r
- LockStatus = NorFlashReadStatusRegister (Instance, BlockAddress);\r
- } while ((LockStatus & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);\r
- }\r
-\r
- // Put device back into Read Array mode\r
- SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_READ_ARRAY);\r
-\r
- DEBUG ((DEBUG_BLKIO, "UnlockSingleBlock: BlockAddress=0x%08x\n", BlockAddress));\r
-\r
- return EFI_SUCCESS;\r
-}\r
-\r
-EFI_STATUS\r
-NorFlashUnlockSingleBlockIfNecessary (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN BlockAddress\r
- )\r
-{\r
- EFI_STATUS Status;\r
-\r
- Status = EFI_SUCCESS;\r
-\r
- if (NorFlashBlockIsLocked (Instance, BlockAddress)) {\r
- Status = NorFlashUnlockSingleBlock (Instance, BlockAddress);\r
- }\r
-\r
- return Status;\r
-}\r
-\r
-/**\r
- * The following function presumes that the block has already been unlocked.\r
- **/\r
-EFI_STATUS\r
-NorFlashEraseSingleBlock (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN BlockAddress\r
- )\r
-{\r
- EFI_STATUS Status;\r
- UINT32 StatusRegister;\r
-\r
- Status = EFI_SUCCESS;\r
-\r
- // Request a block erase and then confirm it\r
- SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_BLOCK_ERASE_SETUP);\r
- SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_BLOCK_ERASE_CONFIRM);\r
-\r
- // Wait until the status register gives us the all clear\r
- do {\r
- StatusRegister = NorFlashReadStatusRegister (Instance, BlockAddress);\r
- } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);\r
-\r
- if (StatusRegister & P30_SR_BIT_VPP) {\r
- DEBUG ((DEBUG_ERROR, "EraseSingleBlock(BlockAddress=0x%08x: VPP Range Error\n", BlockAddress));\r
- Status = EFI_DEVICE_ERROR;\r
- }\r
-\r
- if ((StatusRegister & (P30_SR_BIT_ERASE | P30_SR_BIT_PROGRAM)) == (P30_SR_BIT_ERASE | P30_SR_BIT_PROGRAM)) {\r
- DEBUG ((DEBUG_ERROR, "EraseSingleBlock(BlockAddress=0x%08x: Command Sequence Error\n", BlockAddress));\r
- Status = EFI_DEVICE_ERROR;\r
- }\r
-\r
- if (StatusRegister & P30_SR_BIT_ERASE) {\r
- DEBUG ((DEBUG_ERROR, "EraseSingleBlock(BlockAddress=0x%08x: Block Erase Error StatusRegister:0x%X\n", BlockAddress, StatusRegister));\r
- Status = EFI_DEVICE_ERROR;\r
- }\r
-\r
- if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) {\r
- // The debug level message has been reduced because a device lock might happen. In this case we just retry it ...\r
- DEBUG ((DEBUG_INFO, "EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error\n", BlockAddress));\r
- Status = EFI_WRITE_PROTECTED;\r
- }\r
-\r
- if (EFI_ERROR (Status)) {\r
- // Clear the Status Register\r
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER);\r
- }\r
-\r
- // Put device back into Read Array mode\r
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);\r
-\r
- return Status;\r
-}\r
-\r
-EFI_STATUS\r
-NorFlashWriteSingleWord (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN WordAddress,\r
- IN UINT32 WriteData\r
- )\r
-{\r
- EFI_STATUS Status;\r
- UINT32 StatusRegister;\r
-\r
- Status = EFI_SUCCESS;\r
-\r
- // Request a write single word command\r
- SEND_NOR_COMMAND (WordAddress, 0, P30_CMD_WORD_PROGRAM_SETUP);\r
-\r
- // Store the word into NOR Flash;\r
- MmioWrite32 (WordAddress, WriteData);\r
-\r
- // Wait for the write to complete and then check for any errors; i.e. check the Status Register\r
- do {\r
- // Prepare to read the status register\r
- StatusRegister = NorFlashReadStatusRegister (Instance, WordAddress);\r
- // The chip is busy while the WRITE bit is not asserted\r
- } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);\r
-\r
- // Perform a full status check:\r
- // Mask the relevant bits of Status Register.\r
- // Everything should be zero, if not, we have a problem\r
-\r
- if (StatusRegister & P30_SR_BIT_VPP) {\r
- DEBUG ((DEBUG_ERROR, "NorFlashWriteSingleWord(WordAddress:0x%X): VPP Range Error\n", WordAddress));\r
- Status = EFI_DEVICE_ERROR;\r
- }\r
-\r
- if (StatusRegister & P30_SR_BIT_PROGRAM) {\r
- DEBUG ((DEBUG_ERROR, "NorFlashWriteSingleWord(WordAddress:0x%X): Program Error\n", WordAddress));\r
- Status = EFI_DEVICE_ERROR;\r
- }\r
-\r
- if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) {\r
- DEBUG ((DEBUG_ERROR, "NorFlashWriteSingleWord(WordAddress:0x%X): Device Protect Error\n", WordAddress));\r
- Status = EFI_DEVICE_ERROR;\r
- }\r
-\r
- if (!EFI_ERROR (Status)) {\r
- // Clear the Status Register\r
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER);\r
- }\r
-\r
- // Put device back into Read Array mode\r
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);\r
-\r
- return Status;\r
-}\r
-\r
-/*\r
- * Writes data to the NOR Flash using the Buffered Programming method.\r
- *\r
- * The maximum size of the on-chip buffer is 32-words, because of hardware restrictions.\r
- * Therefore this function will only handle buffers up to 32 words or 128 bytes.\r
- * To deal with larger buffers, call this function again.\r
- *\r
- * This function presumes that both the TargetAddress and the TargetAddress+BufferSize\r
- * exist entirely within the NOR Flash. Therefore these conditions will not be checked here.\r
- *\r
- * In buffered programming, if the target address not at the beginning of a 32-bit word boundary,\r
- * then programming time is doubled and power consumption is increased.\r
- * Therefore, it is a requirement to align buffer writes to 32-bit word boundaries.\r
- * i.e. the last 4 bits of the target start address must be zero: 0x......00\r
- */\r
-EFI_STATUS\r
-NorFlashWriteBuffer (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN TargetAddress,\r
- IN UINTN BufferSizeInBytes,\r
- IN UINT32 *Buffer\r
- )\r
-{\r
- EFI_STATUS Status;\r
- UINTN BufferSizeInWords;\r
- UINTN Count;\r
- volatile UINT32 *Data;\r
- UINTN WaitForBuffer;\r
- BOOLEAN BufferAvailable;\r
- UINT32 StatusRegister;\r
-\r
- WaitForBuffer = MAX_BUFFERED_PROG_ITERATIONS;\r
- BufferAvailable = FALSE;\r
-\r
- // Check that the target address does not cross a 32-word boundary.\r
- if ((TargetAddress & BOUNDARY_OF_32_WORDS) != 0) {\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- // Check there are some data to program\r
- if (BufferSizeInBytes == 0) {\r
- return EFI_BUFFER_TOO_SMALL;\r
- }\r
-\r
- // Check that the buffer size does not exceed the maximum hardware buffer size on chip.\r
- if (BufferSizeInBytes > P30_MAX_BUFFER_SIZE_IN_BYTES) {\r
- return EFI_BAD_BUFFER_SIZE;\r
- }\r
-\r
- // Check that the buffer size is a multiple of 32-bit words\r
- if ((BufferSizeInBytes % 4) != 0) {\r
- return EFI_BAD_BUFFER_SIZE;\r
- }\r
-\r
- // Pre-programming conditions checked, now start the algorithm.\r
-\r
- // Prepare the data destination address\r
- Data = (UINT32 *)TargetAddress;\r
-\r
- // Check the availability of the buffer\r
- do {\r
- // Issue the Buffered Program Setup command\r
- SEND_NOR_COMMAND (TargetAddress, 0, P30_CMD_BUFFERED_PROGRAM_SETUP);\r
-\r
- // Read back the status register bit#7 from the same address\r
- if (((*Data) & P30_SR_BIT_WRITE) == P30_SR_BIT_WRITE) {\r
- BufferAvailable = TRUE;\r
- }\r
-\r
- // Update the loop counter\r
- WaitForBuffer--;\r
- } while ((WaitForBuffer > 0) && (BufferAvailable == FALSE));\r
-\r
- // The buffer was not available for writing\r
- if (WaitForBuffer == 0) {\r
- Status = EFI_DEVICE_ERROR;\r
- goto EXIT;\r
- }\r
-\r
- // From now on we work in 32-bit words\r
- BufferSizeInWords = BufferSizeInBytes / (UINTN)4;\r
-\r
- // Write the word count, which is (buffer_size_in_words - 1),\r
- // because word count 0 means one word.\r
- SEND_NOR_COMMAND (TargetAddress, 0, (BufferSizeInWords - 1));\r
-\r
- // Write the data to the NOR Flash, advancing each address by 4 bytes\r
- for (Count = 0; Count < BufferSizeInWords; Count++, Data++, Buffer++) {\r
- MmioWrite32 ((UINTN)Data, *Buffer);\r
- }\r
-\r
- // Issue the Buffered Program Confirm command, to start the programming operation\r
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_BUFFERED_PROGRAM_CONFIRM);\r
-\r
- // Wait for the write to complete and then check for any errors; i.e. check the Status Register\r
- do {\r
- StatusRegister = NorFlashReadStatusRegister (Instance, TargetAddress);\r
- // The chip is busy while the WRITE bit is not asserted\r
- } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);\r
-\r
- // Perform a full status check:\r
- // Mask the relevant bits of Status Register.\r
- // Everything should be zero, if not, we have a problem\r
-\r
- Status = EFI_SUCCESS;\r
-\r
- if (StatusRegister & P30_SR_BIT_VPP) {\r
- DEBUG ((DEBUG_ERROR, "NorFlashWriteBuffer(TargetAddress:0x%X): VPP Range Error\n", TargetAddress));\r
- Status = EFI_DEVICE_ERROR;\r
- }\r
-\r
- if (StatusRegister & P30_SR_BIT_PROGRAM) {\r
- DEBUG ((DEBUG_ERROR, "NorFlashWriteBuffer(TargetAddress:0x%X): Program Error\n", TargetAddress));\r
- Status = EFI_DEVICE_ERROR;\r
- }\r
-\r
- if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) {\r
- DEBUG ((DEBUG_ERROR, "NorFlashWriteBuffer(TargetAddress:0x%X): Device Protect Error\n", TargetAddress));\r
- Status = EFI_DEVICE_ERROR;\r
- }\r
-\r
- if (!EFI_ERROR (Status)) {\r
- // Clear the Status Register\r
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER);\r
- }\r
-\r
-EXIT:\r
- // Put device back into Read Array mode\r
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);\r
-\r
- return Status;\r
-}\r
-\r
-EFI_STATUS\r
-NorFlashWriteBlocks (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN EFI_LBA Lba,\r
- IN UINTN BufferSizeInBytes,\r
- IN VOID *Buffer\r
- )\r
-{\r
- UINT32 *pWriteBuffer;\r
- EFI_STATUS Status;\r
- EFI_LBA CurrentBlock;\r
- UINT32 BlockSizeInWords;\r
- UINT32 NumBlocks;\r
- UINT32 BlockCount;\r
-\r
- Status = EFI_SUCCESS;\r
-\r
- // The buffer must be valid\r
- if (Buffer == NULL) {\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- if (Instance->Media.ReadOnly == TRUE) {\r
- return EFI_WRITE_PROTECTED;\r
- }\r
-\r
- // We must have some bytes to read\r
- DEBUG ((DEBUG_BLKIO, "NorFlashWriteBlocks: BufferSizeInBytes=0x%x\n", BufferSizeInBytes));\r
- if (BufferSizeInBytes == 0) {\r
- return EFI_BAD_BUFFER_SIZE;\r
- }\r
-\r
- // The size of the buffer must be a multiple of the block size\r
- DEBUG ((DEBUG_BLKIO, "NorFlashWriteBlocks: BlockSize in bytes =0x%x\n", Instance->Media.BlockSize));\r
- if ((BufferSizeInBytes % Instance->Media.BlockSize) != 0) {\r
- return EFI_BAD_BUFFER_SIZE;\r
- }\r
-\r
- // All blocks must be within the device\r
- NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->Media.BlockSize;\r
-\r
- DEBUG ((DEBUG_BLKIO, "NorFlashWriteBlocks: NumBlocks=%d, LastBlock=%ld, Lba=%ld.\n", NumBlocks, Instance->Media.LastBlock, Lba));\r
-\r
- if ((Lba + NumBlocks) > (Instance->Media.LastBlock + 1)) {\r
- DEBUG ((DEBUG_ERROR, "NorFlashWriteBlocks: ERROR - Write will exceed last block.\n"));\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- BlockSizeInWords = Instance->Media.BlockSize / 4;\r
-\r
- // Because the target *Buffer is a pointer to VOID, we must put all the data into a pointer\r
- // to a proper data type, so use *ReadBuffer\r
- pWriteBuffer = (UINT32 *)Buffer;\r
-\r
- CurrentBlock = Lba;\r
- for (BlockCount = 0; BlockCount < NumBlocks; BlockCount++, CurrentBlock++, pWriteBuffer = pWriteBuffer + BlockSizeInWords) {\r
- DEBUG ((DEBUG_BLKIO, "NorFlashWriteBlocks: Writing block #%d\n", (UINTN)CurrentBlock));\r
-\r
- Status = NorFlashWriteFullBlock (Instance, CurrentBlock, pWriteBuffer, BlockSizeInWords);\r
-\r
- if (EFI_ERROR (Status)) {\r
- break;\r
- }\r
- }\r
-\r
- DEBUG ((DEBUG_BLKIO, "NorFlashWriteBlocks: Exit Status = \"%r\".\n", Status));\r
- return Status;\r
-}\r
-\r
-#define BOTH_ALIGNED(a, b, align) ((((UINTN)(a) | (UINTN)(b)) & ((align) - 1)) == 0)\r
-\r
-/**\r
- Copy Length bytes from Source to Destination, using aligned accesses only.\r
- Note that this implementation uses memcpy() semantics rather then memmove()\r
- semantics, i.e., SourceBuffer and DestinationBuffer should not overlap.\r
-\r
- @param DestinationBuffer The target of the copy request.\r
- @param SourceBuffer The place to copy from.\r
- @param Length The number of bytes to copy.\r
-\r
- @return Destination\r
-\r
-**/\r
-STATIC\r
-VOID *\r
-AlignedCopyMem (\r
- OUT VOID *DestinationBuffer,\r
- IN CONST VOID *SourceBuffer,\r
- IN UINTN Length\r
- )\r
-{\r
- UINT8 *Destination8;\r
- CONST UINT8 *Source8;\r
- UINT32 *Destination32;\r
- CONST UINT32 *Source32;\r
- UINT64 *Destination64;\r
- CONST UINT64 *Source64;\r
-\r
- if (BOTH_ALIGNED (DestinationBuffer, SourceBuffer, 8) && (Length >= 8)) {\r
- Destination64 = DestinationBuffer;\r
- Source64 = SourceBuffer;\r
- while (Length >= 8) {\r
- *Destination64++ = *Source64++;\r
- Length -= 8;\r
- }\r
-\r
- Destination8 = (UINT8 *)Destination64;\r
- Source8 = (CONST UINT8 *)Source64;\r
- } else if (BOTH_ALIGNED (DestinationBuffer, SourceBuffer, 4) && (Length >= 4)) {\r
- Destination32 = DestinationBuffer;\r
- Source32 = SourceBuffer;\r
- while (Length >= 4) {\r
- *Destination32++ = *Source32++;\r
- Length -= 4;\r
- }\r
-\r
- Destination8 = (UINT8 *)Destination32;\r
- Source8 = (CONST UINT8 *)Source32;\r
- } else {\r
- Destination8 = DestinationBuffer;\r
- Source8 = SourceBuffer;\r
- }\r
-\r
- while (Length-- != 0) {\r
- *Destination8++ = *Source8++;\r
- }\r
-\r
- return DestinationBuffer;\r
-}\r
-\r
-EFI_STATUS\r
-NorFlashReadBlocks (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN EFI_LBA Lba,\r
- IN UINTN BufferSizeInBytes,\r
- OUT VOID *Buffer\r
- )\r
-{\r
- UINT32 NumBlocks;\r
- UINTN StartAddress;\r
-\r
- DEBUG ((\r
- DEBUG_BLKIO,\r
- "NorFlashReadBlocks: BufferSize=0x%xB BlockSize=0x%xB LastBlock=%ld, Lba=%ld.\n",\r
- BufferSizeInBytes,\r
- Instance->Media.BlockSize,\r
- Instance->Media.LastBlock,\r
- Lba\r
- ));\r
-\r
- // The buffer must be valid\r
- if (Buffer == NULL) {\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- // Return if we have not any byte to read\r
- if (BufferSizeInBytes == 0) {\r
- return EFI_SUCCESS;\r
- }\r
-\r
- // The size of the buffer must be a multiple of the block size\r
- if ((BufferSizeInBytes % Instance->Media.BlockSize) != 0) {\r
- return EFI_BAD_BUFFER_SIZE;\r
- }\r
-\r
- // All blocks must be within the device\r
- NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->Media.BlockSize;\r
-\r
- if ((Lba + NumBlocks) > (Instance->Media.LastBlock + 1)) {\r
- DEBUG ((DEBUG_ERROR, "NorFlashReadBlocks: ERROR - Read will exceed last block\n"));\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- // Get the address to start reading from\r
- StartAddress = GET_NOR_BLOCK_ADDRESS (\r
- Instance->RegionBaseAddress,\r
- Lba,\r
- Instance->Media.BlockSize\r
- );\r
-\r
- // Put the device into Read Array mode\r
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);\r
-\r
- // Readout the data\r
- AlignedCopyMem (Buffer, (VOID *)StartAddress, BufferSizeInBytes);\r
-\r
- return EFI_SUCCESS;\r
-}\r
-\r
-EFI_STATUS\r
-NorFlashRead (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN EFI_LBA Lba,\r
- IN UINTN Offset,\r
- IN UINTN BufferSizeInBytes,\r
- OUT VOID *Buffer\r
- )\r
-{\r
- UINTN StartAddress;\r
-\r
- // The buffer must be valid\r
- if (Buffer == NULL) {\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- // Return if we have not any byte to read\r
- if (BufferSizeInBytes == 0) {\r
- return EFI_SUCCESS;\r
- }\r
-\r
- if (((Lba * Instance->Media.BlockSize) + Offset + BufferSizeInBytes) > Instance->Size) {\r
- DEBUG ((DEBUG_ERROR, "NorFlashRead: ERROR - Read will exceed device size.\n"));\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- // Get the address to start reading from\r
- StartAddress = GET_NOR_BLOCK_ADDRESS (\r
- Instance->RegionBaseAddress,\r
- Lba,\r
- Instance->Media.BlockSize\r
- );\r
-\r
- // Put the device into Read Array mode\r
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);\r
-\r
- // Readout the data\r
- AlignedCopyMem (Buffer, (VOID *)(StartAddress + Offset), BufferSizeInBytes);\r
-\r
- return EFI_SUCCESS;\r
-}\r
-\r
-/*\r
- Write a full or portion of a block. It must not span block boundaries; that is,\r
- Offset + *NumBytes <= Instance->Media.BlockSize.\r
-*/\r
-EFI_STATUS\r
-NorFlashWriteSingleBlock (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN EFI_LBA Lba,\r
- IN UINTN Offset,\r
- IN OUT UINTN *NumBytes,\r
- IN UINT8 *Buffer\r
- )\r
-{\r
- EFI_STATUS TempStatus;\r
- UINT32 Tmp;\r
- UINT32 TmpBuf;\r
- UINT32 WordToWrite;\r
- UINT32 Mask;\r
- BOOLEAN DoErase;\r
- UINTN BytesToWrite;\r
- UINTN CurOffset;\r
- UINTN WordAddr;\r
- UINTN BlockSize;\r
- UINTN BlockAddress;\r
- UINTN PrevBlockAddress;\r
-\r
- PrevBlockAddress = 0;\r
-\r
- DEBUG ((DEBUG_BLKIO, "NorFlashWriteSingleBlock(Parameters: Lba=%ld, Offset=0x%x, *NumBytes=0x%x, Buffer @ 0x%08x)\n", Lba, Offset, *NumBytes, Buffer));\r
-\r
- // Detect WriteDisabled state\r
- if (Instance->Media.ReadOnly == TRUE) {\r
- DEBUG ((DEBUG_ERROR, "NorFlashWriteSingleBlock: ERROR - Can not write: Device is in WriteDisabled state.\n"));\r
- // It is in WriteDisabled state, return an error right away\r
- return EFI_ACCESS_DENIED;\r
- }\r
-\r
- // Cache the block size to avoid de-referencing pointers all the time\r
- BlockSize = Instance->Media.BlockSize;\r
-\r
- // The write must not span block boundaries.\r
- // We need to check each variable individually because adding two large values together overflows.\r
- if ((Offset >= BlockSize) ||\r
- (*NumBytes > BlockSize) ||\r
- ((Offset + *NumBytes) > BlockSize))\r
- {\r
- DEBUG ((DEBUG_ERROR, "NorFlashWriteSingleBlock: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", Offset, *NumBytes, BlockSize));\r
- return EFI_BAD_BUFFER_SIZE;\r
- }\r
-\r
- // We must have some bytes to write\r
- if (*NumBytes == 0) {\r
- DEBUG ((DEBUG_ERROR, "NorFlashWriteSingleBlock: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", Offset, *NumBytes, BlockSize));\r
- return EFI_BAD_BUFFER_SIZE;\r
- }\r
-\r
- // Pick 128bytes as a good start for word operations as opposed to erasing the\r
- // block and writing the data regardless if an erase is really needed.\r
- // It looks like most individual NV variable writes are smaller than 128bytes.\r
- if (*NumBytes <= 128) {\r
- // Check to see if we need to erase before programming the data into NOR.\r
- // If the destination bits are only changing from 1s to 0s we can just write.\r
- // After a block is erased all bits in the block is set to 1.\r
- // If any byte requires us to erase we just give up and rewrite all of it.\r
- DoErase = FALSE;\r
- BytesToWrite = *NumBytes;\r
- CurOffset = Offset;\r
-\r
- while (BytesToWrite > 0) {\r
- // Read full word from NOR, splice as required. A word is the smallest\r
- // unit we can write.\r
- TempStatus = NorFlashRead (Instance, Lba, CurOffset & ~(0x3), sizeof (Tmp), &Tmp);\r
- if (EFI_ERROR (TempStatus)) {\r
- return EFI_DEVICE_ERROR;\r
- }\r
-\r
- // Physical address of word in NOR to write.\r
- WordAddr = (CurOffset & ~(0x3)) + GET_NOR_BLOCK_ADDRESS (\r
- Instance->RegionBaseAddress,\r
- Lba,\r
- BlockSize\r
- );\r
- // The word of data that is to be written.\r
- TmpBuf = *((UINT32 *)(Buffer + (*NumBytes - BytesToWrite)));\r
-\r
- // First do word aligned chunks.\r
- if ((CurOffset & 0x3) == 0) {\r
- if (BytesToWrite >= 4) {\r
- // Is the destination still in 'erased' state?\r
- if (~Tmp != 0) {\r
- // Check to see if we are only changing bits to zero.\r
- if ((Tmp ^ TmpBuf) & TmpBuf) {\r
- DoErase = TRUE;\r
- break;\r
- }\r
- }\r
-\r
- // Write this word to NOR\r
- WordToWrite = TmpBuf;\r
- CurOffset += sizeof (TmpBuf);\r
- BytesToWrite -= sizeof (TmpBuf);\r
- } else {\r
- // BytesToWrite < 4. Do small writes and left-overs\r
- Mask = ~((~0) << (BytesToWrite * 8));\r
- // Mask out the bytes we want.\r
- TmpBuf &= Mask;\r
- // Is the destination still in 'erased' state?\r
- if ((Tmp & Mask) != Mask) {\r
- // Check to see if we are only changing bits to zero.\r
- if ((Tmp ^ TmpBuf) & TmpBuf) {\r
- DoErase = TRUE;\r
- break;\r
- }\r
- }\r
-\r
- // Merge old and new data. Write merged word to NOR\r
- WordToWrite = (Tmp & ~Mask) | TmpBuf;\r
- CurOffset += BytesToWrite;\r
- BytesToWrite = 0;\r
- }\r
- } else {\r
- // Do multiple words, but starting unaligned.\r
- if (BytesToWrite > (4 - (CurOffset & 0x3))) {\r
- Mask = ((~0) << ((CurOffset & 0x3) * 8));\r
- // Mask out the bytes we want.\r
- TmpBuf &= Mask;\r
- // Is the destination still in 'erased' state?\r
- if ((Tmp & Mask) != Mask) {\r
- // Check to see if we are only changing bits to zero.\r
- if ((Tmp ^ TmpBuf) & TmpBuf) {\r
- DoErase = TRUE;\r
- break;\r
- }\r
- }\r
-\r
- // Merge old and new data. Write merged word to NOR\r
- WordToWrite = (Tmp & ~Mask) | TmpBuf;\r
- BytesToWrite -= (4 - (CurOffset & 0x3));\r
- CurOffset += (4 - (CurOffset & 0x3));\r
- } else {\r
- // Unaligned and fits in one word.\r
- Mask = (~((~0) << (BytesToWrite * 8))) << ((CurOffset & 0x3) * 8);\r
- // Mask out the bytes we want.\r
- TmpBuf = (TmpBuf << ((CurOffset & 0x3) * 8)) & Mask;\r
- // Is the destination still in 'erased' state?\r
- if ((Tmp & Mask) != Mask) {\r
- // Check to see if we are only changing bits to zero.\r
- if ((Tmp ^ TmpBuf) & TmpBuf) {\r
- DoErase = TRUE;\r
- break;\r
- }\r
- }\r
-\r
- // Merge old and new data. Write merged word to NOR\r
- WordToWrite = (Tmp & ~Mask) | TmpBuf;\r
- CurOffset += BytesToWrite;\r
- BytesToWrite = 0;\r
- }\r
- }\r
-\r
- //\r
- // Write the word to NOR.\r
- //\r
-\r
- BlockAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, Lba, BlockSize);\r
- if (BlockAddress != PrevBlockAddress) {\r
- TempStatus = NorFlashUnlockSingleBlockIfNecessary (Instance, BlockAddress);\r
- if (EFI_ERROR (TempStatus)) {\r
- return EFI_DEVICE_ERROR;\r
- }\r
-\r
- PrevBlockAddress = BlockAddress;\r
- }\r
-\r
- TempStatus = NorFlashWriteSingleWord (Instance, WordAddr, WordToWrite);\r
- if (EFI_ERROR (TempStatus)) {\r
- return EFI_DEVICE_ERROR;\r
- }\r
- }\r
-\r
- // Exit if we got here and could write all the data. Otherwise do the\r
- // Erase-Write cycle.\r
- if (!DoErase) {\r
- return EFI_SUCCESS;\r
- }\r
- }\r
-\r
- // Check we did get some memory. Buffer is BlockSize.\r
- if (Instance->ShadowBuffer == NULL) {\r
- DEBUG ((DEBUG_ERROR, "FvbWrite: ERROR - Buffer not ready\n"));\r
- return EFI_DEVICE_ERROR;\r
- }\r
-\r
- // Read NOR Flash data into shadow buffer\r
- TempStatus = NorFlashReadBlocks (Instance, Lba, BlockSize, Instance->ShadowBuffer);\r
- if (EFI_ERROR (TempStatus)) {\r
- // Return one of the pre-approved error statuses\r
- return EFI_DEVICE_ERROR;\r
- }\r
-\r
- // Put the data at the appropriate location inside the buffer area\r
- CopyMem ((VOID *)((UINTN)Instance->ShadowBuffer + Offset), Buffer, *NumBytes);\r
-\r
- // Write the modified buffer back to the NorFlash\r
- TempStatus = NorFlashWriteBlocks (Instance, Lba, BlockSize, Instance->ShadowBuffer);\r
- if (EFI_ERROR (TempStatus)) {\r
- // Return one of the pre-approved error statuses\r
- return EFI_DEVICE_ERROR;\r
- }\r
-\r
- return EFI_SUCCESS;\r
-}\r
-\r
-/*\r
- Although DiskIoDxe will automatically install the DiskIO protocol whenever\r
- we install the BlockIO protocol, its implementation is sub-optimal as it reads\r
- and writes entire blocks using the BlockIO protocol. In fact we can access\r
- NOR flash with a finer granularity than that, so we can improve performance\r
- by directly producing the DiskIO protocol.\r
-*/\r
-\r
-/**\r
- Read BufferSize bytes from Offset into Buffer.\r
-\r
- @param This Protocol instance pointer.\r
- @param MediaId Id of the media, changes every time the media is replaced.\r
- @param Offset The starting byte offset to read from\r
- @param BufferSize Size of Buffer\r
- @param Buffer Buffer containing read data\r
-\r
- @retval EFI_SUCCESS The data was read correctly from the device.\r
- @retval EFI_DEVICE_ERROR The device reported an error while performing the read.\r
- @retval EFI_NO_MEDIA There is no media in the device.\r
- @retval EFI_MEDIA_CHANGED The MediaId does not match the current device.\r
- @retval EFI_INVALID_PARAMETER The read request contains device addresses that are not\r
- valid for the device.\r
-\r
-**/\r
-EFI_STATUS\r
-EFIAPI\r
-NorFlashDiskIoReadDisk (\r
- IN EFI_DISK_IO_PROTOCOL *This,\r
- IN UINT32 MediaId,\r
- IN UINT64 DiskOffset,\r
- IN UINTN BufferSize,\r
- OUT VOID *Buffer\r
- )\r
-{\r
- NOR_FLASH_INSTANCE *Instance;\r
- UINT32 BlockSize;\r
- UINT32 BlockOffset;\r
- EFI_LBA Lba;\r
-\r
- Instance = INSTANCE_FROM_DISKIO_THIS (This);\r
-\r
- if (MediaId != Instance->Media.MediaId) {\r
- return EFI_MEDIA_CHANGED;\r
- }\r
-\r
- BlockSize = Instance->Media.BlockSize;\r
- Lba = (EFI_LBA)DivU64x32Remainder (DiskOffset, BlockSize, &BlockOffset);\r
-\r
- return NorFlashRead (Instance, Lba, BlockOffset, BufferSize, Buffer);\r
-}\r
-\r
-/**\r
- Writes a specified number of bytes to a device.\r
-\r
- @param This Indicates a pointer to the calling context.\r
- @param MediaId ID of the medium to be written.\r
- @param Offset The starting byte offset on the logical block I/O device to write.\r
- @param BufferSize The size in bytes of Buffer. The number of bytes to write to the device.\r
- @param Buffer A pointer to the buffer containing the data to be written.\r
-\r
- @retval EFI_SUCCESS The data was written correctly to the device.\r
- @retval EFI_WRITE_PROTECTED The device can not be written to.\r
- @retval EFI_DEVICE_ERROR The device reported an error while performing the write.\r
- @retval EFI_NO_MEDIA There is no media in the device.\r
- @retval EFI_MEDIA_CHANGED The MediaId does not match the current device.\r
- @retval EFI_INVALID_PARAMETER The write request contains device addresses that are not\r
- valid for the device.\r
-\r
-**/\r
-EFI_STATUS\r
-EFIAPI\r
-NorFlashDiskIoWriteDisk (\r
- IN EFI_DISK_IO_PROTOCOL *This,\r
- IN UINT32 MediaId,\r
- IN UINT64 DiskOffset,\r
- IN UINTN BufferSize,\r
- IN VOID *Buffer\r
- )\r
-{\r
- NOR_FLASH_INSTANCE *Instance;\r
- UINT32 BlockSize;\r
- UINT32 BlockOffset;\r
- EFI_LBA Lba;\r
- UINTN RemainingBytes;\r
- UINTN WriteSize;\r
- EFI_STATUS Status;\r
-\r
- Instance = INSTANCE_FROM_DISKIO_THIS (This);\r
-\r
- if (MediaId != Instance->Media.MediaId) {\r
- return EFI_MEDIA_CHANGED;\r
- }\r
-\r
- BlockSize = Instance->Media.BlockSize;\r
- Lba = (EFI_LBA)DivU64x32Remainder (DiskOffset, BlockSize, &BlockOffset);\r
-\r
- RemainingBytes = BufferSize;\r
-\r
- // Write either all the remaining bytes, or the number of bytes that bring\r
- // us up to a block boundary, whichever is less.\r
- // (DiskOffset | (BlockSize - 1)) + 1) rounds DiskOffset up to the next\r
- // block boundary (even if it is already on one).\r
- WriteSize = MIN (RemainingBytes, ((DiskOffset | (BlockSize - 1)) + 1) - DiskOffset);\r
-\r
- do {\r
- if (WriteSize == BlockSize) {\r
- // Write a full block\r
- Status = NorFlashWriteFullBlock (Instance, Lba, Buffer, BlockSize / sizeof (UINT32));\r
- } else {\r
- // Write a partial block\r
- Status = NorFlashWriteSingleBlock (Instance, Lba, BlockOffset, &WriteSize, Buffer);\r
- }\r
-\r
- if (EFI_ERROR (Status)) {\r
- return Status;\r
- }\r
-\r
- // Now continue writing either all the remaining bytes or single blocks.\r
- RemainingBytes -= WriteSize;\r
- Buffer = (UINT8 *)Buffer + WriteSize;\r
- Lba++;\r
- BlockOffset = 0;\r
- WriteSize = MIN (RemainingBytes, BlockSize);\r
- } while (RemainingBytes);\r
-\r
- return Status;\r
-}\r
-\r
-EFI_STATUS\r
-NorFlashReset (\r
- IN NOR_FLASH_INSTANCE *Instance\r
- )\r
-{\r
- // As there is no specific RESET to perform, ensure that the devices is in the default Read Array mode\r
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);\r
- return EFI_SUCCESS;\r
-}\r
-\r
-/**\r
- Fixup internal data so that EFI can be call in virtual mode.\r
- Call the passed in Child Notify event and convert any pointers in\r
- lib to virtual mode.\r
-\r
- @param[in] Event The Event that is being processed\r
- @param[in] Context Event Context\r
-**/\r
-VOID\r
-EFIAPI\r
-NorFlashVirtualNotifyEvent (\r
- IN EFI_EVENT Event,\r
- IN VOID *Context\r
- )\r
-{\r
- UINTN Index;\r
-\r
- for (Index = 0; Index < mNorFlashDeviceCount; Index++) {\r
- EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->DeviceBaseAddress);\r
- EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->RegionBaseAddress);\r
-\r
- // Convert BlockIo protocol\r
- EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->BlockIoProtocol.FlushBlocks);\r
- EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->BlockIoProtocol.ReadBlocks);\r
- EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->BlockIoProtocol.Reset);\r
- EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->BlockIoProtocol.WriteBlocks);\r
-\r
- // Convert Fvb\r
- EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->FvbProtocol.EraseBlocks);\r
- EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->FvbProtocol.GetAttributes);\r
- EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->FvbProtocol.GetBlockSize);\r
- EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->FvbProtocol.GetPhysicalAddress);\r
- EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->FvbProtocol.Read);\r
- EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->FvbProtocol.SetAttributes);\r
- EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->FvbProtocol.Write);\r
-\r
- if (mNorFlashInstances[Index]->ShadowBuffer != NULL) {\r
- EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->ShadowBuffer);\r
- }\r
- }\r
-\r
- return;\r
-}\r
+++ /dev/null
-/** @file NorFlash.h\r
-\r
- Copyright (c) 2011 - 2014, ARM Ltd. All rights reserved.<BR>\r
-\r
- SPDX-License-Identifier: BSD-2-Clause-Patent\r
-\r
-**/\r
-\r
-#ifndef __NOR_FLASH_H__\r
-#define __NOR_FLASH_H__\r
-\r
-#include <Base.h>\r
-#include <PiDxe.h>\r
-\r
-#include <Guid/EventGroup.h>\r
-\r
-#include <Protocol/BlockIo.h>\r
-#include <Protocol/DiskIo.h>\r
-#include <Protocol/FirmwareVolumeBlock.h>\r
-\r
-#include <Library/DebugLib.h>\r
-#include <Library/IoLib.h>\r
-#include <Library/NorFlashPlatformLib.h>\r
-#include <Library/UefiLib.h>\r
-#include <Library/UefiRuntimeLib.h>\r
-\r
-#define NOR_FLASH_ERASE_RETRY 10\r
-\r
-// Device access macros\r
-// These are necessary because we use 2 x 16bit parts to make up 32bit data\r
-\r
-#define HIGH_16_BITS 0xFFFF0000\r
-#define LOW_16_BITS 0x0000FFFF\r
-#define LOW_8_BITS 0x000000FF\r
-\r
-#define FOLD_32BIT_INTO_16BIT(value) ( ( value >> 16 ) | ( value & LOW_16_BITS ) )\r
-\r
-#define GET_LOW_BYTE(value) ( value & LOW_8_BITS )\r
-#define GET_HIGH_BYTE(value) ( GET_LOW_BYTE( value >> 16 ) )\r
-\r
-// Each command must be sent simultaneously to both chips,\r
-// i.e. at the lower 16 bits AND at the higher 16 bits\r
-#define CREATE_NOR_ADDRESS(BaseAddr, OffsetAddr) ((BaseAddr) + ((OffsetAddr) << 2))\r
-#define CREATE_DUAL_CMD(Cmd) ( ( Cmd << 16) | ( Cmd & LOW_16_BITS) )\r
-#define SEND_NOR_COMMAND(BaseAddr, Offset, Cmd) MmioWrite32 (CREATE_NOR_ADDRESS(BaseAddr,Offset), CREATE_DUAL_CMD(Cmd))\r
-#define GET_NOR_BLOCK_ADDRESS(BaseAddr, Lba, LbaSize) ( BaseAddr + (UINTN)((Lba) * LbaSize) )\r
-\r
-// Status Register Bits\r
-#define P30_SR_BIT_WRITE (BIT7 << 16 | BIT7)\r
-#define P30_SR_BIT_ERASE_SUSPEND (BIT6 << 16 | BIT6)\r
-#define P30_SR_BIT_ERASE (BIT5 << 16 | BIT5)\r
-#define P30_SR_BIT_PROGRAM (BIT4 << 16 | BIT4)\r
-#define P30_SR_BIT_VPP (BIT3 << 16 | BIT3)\r
-#define P30_SR_BIT_PROGRAM_SUSPEND (BIT2 << 16 | BIT2)\r
-#define P30_SR_BIT_BLOCK_LOCKED (BIT1 << 16 | BIT1)\r
-#define P30_SR_BIT_BEFP (BIT0 << 16 | BIT0)\r
-\r
-// Device Commands for Intel StrataFlash(R) Embedded Memory (P30) Family\r
-\r
-// On chip buffer size for buffered programming operations\r
-// There are 2 chips, each chip can buffer up to 32 (16-bit)words, and each word is 2 bytes.\r
-// Therefore the total size of the buffer is 2 x 32 x 2 = 128 bytes\r
-#define P30_MAX_BUFFER_SIZE_IN_BYTES ((UINTN)128)\r
-#define P30_MAX_BUFFER_SIZE_IN_WORDS (P30_MAX_BUFFER_SIZE_IN_BYTES/((UINTN)4))\r
-#define MAX_BUFFERED_PROG_ITERATIONS 10000000\r
-#define BOUNDARY_OF_32_WORDS 0x7F\r
-\r
-// CFI Addresses\r
-#define P30_CFI_ADDR_QUERY_UNIQUE_QRY 0x10\r
-#define P30_CFI_ADDR_VENDOR_ID 0x13\r
-\r
-// CFI Data\r
-#define CFI_QRY 0x00595251\r
-\r
-// READ Commands\r
-#define P30_CMD_READ_DEVICE_ID 0x0090\r
-#define P30_CMD_READ_STATUS_REGISTER 0x0070\r
-#define P30_CMD_CLEAR_STATUS_REGISTER 0x0050\r
-#define P30_CMD_READ_ARRAY 0x00FF\r
-#define P30_CMD_READ_CFI_QUERY 0x0098\r
-\r
-// WRITE Commands\r
-#define P30_CMD_WORD_PROGRAM_SETUP 0x0040\r
-#define P30_CMD_ALTERNATE_WORD_PROGRAM_SETUP 0x0010\r
-#define P30_CMD_BUFFERED_PROGRAM_SETUP 0x00E8\r
-#define P30_CMD_BUFFERED_PROGRAM_CONFIRM 0x00D0\r
-#define P30_CMD_BEFP_SETUP 0x0080\r
-#define P30_CMD_BEFP_CONFIRM 0x00D0\r
-\r
-// ERASE Commands\r
-#define P30_CMD_BLOCK_ERASE_SETUP 0x0020\r
-#define P30_CMD_BLOCK_ERASE_CONFIRM 0x00D0\r
-\r
-// SUSPEND Commands\r
-#define P30_CMD_PROGRAM_OR_ERASE_SUSPEND 0x00B0\r
-#define P30_CMD_SUSPEND_RESUME 0x00D0\r
-\r
-// BLOCK LOCKING / UNLOCKING Commands\r
-#define P30_CMD_LOCK_BLOCK_SETUP 0x0060\r
-#define P30_CMD_LOCK_BLOCK 0x0001\r
-#define P30_CMD_UNLOCK_BLOCK 0x00D0\r
-#define P30_CMD_LOCK_DOWN_BLOCK 0x002F\r
-\r
-// PROTECTION Commands\r
-#define P30_CMD_PROGRAM_PROTECTION_REGISTER_SETUP 0x00C0\r
-\r
-// CONFIGURATION Commands\r
-#define P30_CMD_READ_CONFIGURATION_REGISTER_SETUP 0x0060\r
-#define P30_CMD_READ_CONFIGURATION_REGISTER 0x0003\r
-\r
-#define NOR_FLASH_SIGNATURE SIGNATURE_32('n', 'o', 'r', '0')\r
-#define INSTANCE_FROM_FVB_THIS(a) CR(a, NOR_FLASH_INSTANCE, FvbProtocol, NOR_FLASH_SIGNATURE)\r
-#define INSTANCE_FROM_BLKIO_THIS(a) CR(a, NOR_FLASH_INSTANCE, BlockIoProtocol, NOR_FLASH_SIGNATURE)\r
-#define INSTANCE_FROM_DISKIO_THIS(a) CR(a, NOR_FLASH_INSTANCE, DiskIoProtocol, NOR_FLASH_SIGNATURE)\r
-\r
-typedef struct _NOR_FLASH_INSTANCE NOR_FLASH_INSTANCE;\r
-\r
-#pragma pack (1)\r
-typedef struct {\r
- VENDOR_DEVICE_PATH Vendor;\r
- UINT8 Index;\r
- EFI_DEVICE_PATH_PROTOCOL End;\r
-} NOR_FLASH_DEVICE_PATH;\r
-#pragma pack ()\r
-\r
-struct _NOR_FLASH_INSTANCE {\r
- UINT32 Signature;\r
- EFI_HANDLE Handle;\r
-\r
- UINTN DeviceBaseAddress;\r
- UINTN RegionBaseAddress;\r
- UINTN Size;\r
- EFI_LBA StartLba;\r
-\r
- EFI_BLOCK_IO_PROTOCOL BlockIoProtocol;\r
- EFI_BLOCK_IO_MEDIA Media;\r
- EFI_DISK_IO_PROTOCOL DiskIoProtocol;\r
-\r
- EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL FvbProtocol;\r
- VOID *ShadowBuffer;\r
-\r
- NOR_FLASH_DEVICE_PATH DevicePath;\r
-};\r
-\r
-EFI_STATUS\r
-NorFlashReadCfiData (\r
- IN UINTN DeviceBaseAddress,\r
- IN UINTN CFI_Offset,\r
- IN UINT32 NumberOfBytes,\r
- OUT UINT32 *Data\r
- );\r
-\r
-EFI_STATUS\r
-NorFlashWriteBuffer (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN TargetAddress,\r
- IN UINTN BufferSizeInBytes,\r
- IN UINT32 *Buffer\r
- );\r
-\r
-//\r
-// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.Reset\r
-//\r
-EFI_STATUS\r
-EFIAPI\r
-NorFlashBlockIoReset (\r
- IN EFI_BLOCK_IO_PROTOCOL *This,\r
- IN BOOLEAN ExtendedVerification\r
- );\r
-\r
-//\r
-// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.ReadBlocks\r
-//\r
-EFI_STATUS\r
-EFIAPI\r
-NorFlashBlockIoReadBlocks (\r
- IN EFI_BLOCK_IO_PROTOCOL *This,\r
- IN UINT32 MediaId,\r
- IN EFI_LBA Lba,\r
- IN UINTN BufferSizeInBytes,\r
- OUT VOID *Buffer\r
- );\r
-\r
-//\r
-// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.WriteBlocks\r
-//\r
-EFI_STATUS\r
-EFIAPI\r
-NorFlashBlockIoWriteBlocks (\r
- IN EFI_BLOCK_IO_PROTOCOL *This,\r
- IN UINT32 MediaId,\r
- IN EFI_LBA Lba,\r
- IN UINTN BufferSizeInBytes,\r
- IN VOID *Buffer\r
- );\r
-\r
-//\r
-// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.FlushBlocks\r
-//\r
-EFI_STATUS\r
-EFIAPI\r
-NorFlashBlockIoFlushBlocks (\r
- IN EFI_BLOCK_IO_PROTOCOL *This\r
- );\r
-\r
-//\r
-// DiskIO Protocol function EFI_DISK_IO_PROTOCOL.ReadDisk\r
-//\r
-EFI_STATUS\r
-EFIAPI\r
-NorFlashDiskIoReadDisk (\r
- IN EFI_DISK_IO_PROTOCOL *This,\r
- IN UINT32 MediaId,\r
- IN UINT64 Offset,\r
- IN UINTN BufferSize,\r
- OUT VOID *Buffer\r
- );\r
-\r
-//\r
-// DiskIO Protocol function EFI_DISK_IO_PROTOCOL.WriteDisk\r
-//\r
-EFI_STATUS\r
-EFIAPI\r
-NorFlashDiskIoWriteDisk (\r
- IN EFI_DISK_IO_PROTOCOL *This,\r
- IN UINT32 MediaId,\r
- IN UINT64 Offset,\r
- IN UINTN BufferSize,\r
- IN VOID *Buffer\r
- );\r
-\r
-//\r
-// NorFlashFvbDxe.c\r
-//\r
-\r
-EFI_STATUS\r
-EFIAPI\r
-FvbGetAttributes (\r
- IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,\r
- OUT EFI_FVB_ATTRIBUTES_2 *Attributes\r
- );\r
-\r
-EFI_STATUS\r
-EFIAPI\r
-FvbSetAttributes (\r
- IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,\r
- IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes\r
- );\r
-\r
-EFI_STATUS\r
-EFIAPI\r
-FvbGetPhysicalAddress (\r
- IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,\r
- OUT EFI_PHYSICAL_ADDRESS *Address\r
- );\r
-\r
-EFI_STATUS\r
-EFIAPI\r
-FvbGetBlockSize (\r
- IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,\r
- IN EFI_LBA Lba,\r
- OUT UINTN *BlockSize,\r
- OUT UINTN *NumberOfBlocks\r
- );\r
-\r
-EFI_STATUS\r
-EFIAPI\r
-FvbRead (\r
- IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,\r
- IN EFI_LBA Lba,\r
- IN UINTN Offset,\r
- IN OUT UINTN *NumBytes,\r
- IN OUT UINT8 *Buffer\r
- );\r
-\r
-EFI_STATUS\r
-EFIAPI\r
-FvbWrite (\r
- IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,\r
- IN EFI_LBA Lba,\r
- IN UINTN Offset,\r
- IN OUT UINTN *NumBytes,\r
- IN UINT8 *Buffer\r
- );\r
-\r
-EFI_STATUS\r
-EFIAPI\r
-FvbEraseBlocks (\r
- IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,\r
- ...\r
- );\r
-\r
-EFI_STATUS\r
-ValidateFvHeader (\r
- IN NOR_FLASH_INSTANCE *Instance\r
- );\r
-\r
-EFI_STATUS\r
-InitializeFvAndVariableStoreHeaders (\r
- IN NOR_FLASH_INSTANCE *Instance\r
- );\r
-\r
-VOID\r
-EFIAPI\r
-FvbVirtualNotifyEvent (\r
- IN EFI_EVENT Event,\r
- IN VOID *Context\r
- );\r
-\r
-//\r
-// NorFlashDxe.c\r
-//\r
-\r
-EFI_STATUS\r
-NorFlashWriteFullBlock (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN EFI_LBA Lba,\r
- IN UINT32 *DataBuffer,\r
- IN UINT32 BlockSizeInWords\r
- );\r
-\r
-EFI_STATUS\r
-NorFlashUnlockAndEraseSingleBlock (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN BlockAddress\r
- );\r
-\r
-EFI_STATUS\r
-NorFlashCreateInstance (\r
- IN UINTN NorFlashDeviceBase,\r
- IN UINTN NorFlashRegionBase,\r
- IN UINTN NorFlashSize,\r
- IN UINT32 Index,\r
- IN UINT32 BlockSize,\r
- IN BOOLEAN SupportFvb,\r
- OUT NOR_FLASH_INSTANCE **NorFlashInstance\r
- );\r
-\r
-EFI_STATUS\r
-EFIAPI\r
-NorFlashFvbInitialize (\r
- IN NOR_FLASH_INSTANCE *Instance\r
- );\r
-\r
-//\r
-// NorFlash.c\r
-//\r
-EFI_STATUS\r
-NorFlashWriteSingleBlock (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN EFI_LBA Lba,\r
- IN UINTN Offset,\r
- IN OUT UINTN *NumBytes,\r
- IN UINT8 *Buffer\r
- );\r
-\r
-EFI_STATUS\r
-NorFlashWriteBlocks (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN EFI_LBA Lba,\r
- IN UINTN BufferSizeInBytes,\r
- IN VOID *Buffer\r
- );\r
-\r
-EFI_STATUS\r
-NorFlashReadBlocks (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN EFI_LBA Lba,\r
- IN UINTN BufferSizeInBytes,\r
- OUT VOID *Buffer\r
- );\r
-\r
-EFI_STATUS\r
-NorFlashRead (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN EFI_LBA Lba,\r
- IN UINTN Offset,\r
- IN UINTN BufferSizeInBytes,\r
- OUT VOID *Buffer\r
- );\r
-\r
-EFI_STATUS\r
-NorFlashWrite (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN EFI_LBA Lba,\r
- IN UINTN Offset,\r
- IN OUT UINTN *NumBytes,\r
- IN UINT8 *Buffer\r
- );\r
-\r
-EFI_STATUS\r
-NorFlashReset (\r
- IN NOR_FLASH_INSTANCE *Instance\r
- );\r
-\r
-EFI_STATUS\r
-NorFlashEraseSingleBlock (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN BlockAddress\r
- );\r
-\r
-EFI_STATUS\r
-NorFlashUnlockSingleBlockIfNecessary (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN BlockAddress\r
- );\r
-\r
-EFI_STATUS\r
-NorFlashWriteSingleWord (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN WordAddress,\r
- IN UINT32 WriteData\r
- );\r
-\r
-VOID\r
-EFIAPI\r
-NorFlashVirtualNotifyEvent (\r
- IN EFI_EVENT Event,\r
- IN VOID *Context\r
- );\r
-\r
-#endif /* __NOR_FLASH_H__ */\r
+++ /dev/null
-/** @file NorFlashBlockIoDxe.c\r
-\r
- Copyright (c) 2011-2013, ARM Ltd. All rights reserved.<BR>\r
-\r
- SPDX-License-Identifier: BSD-2-Clause-Patent\r
-\r
-**/\r
-\r
-#include <Library/BaseMemoryLib.h>\r
-#include <Library/UefiBootServicesTableLib.h>\r
-\r
-#include "NorFlash.h"\r
-\r
-//\r
-// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.Reset\r
-//\r
-EFI_STATUS\r
-EFIAPI\r
-NorFlashBlockIoReset (\r
- IN EFI_BLOCK_IO_PROTOCOL *This,\r
- IN BOOLEAN ExtendedVerification\r
- )\r
-{\r
- NOR_FLASH_INSTANCE *Instance;\r
-\r
- Instance = INSTANCE_FROM_BLKIO_THIS (This);\r
-\r
- DEBUG ((DEBUG_BLKIO, "NorFlashBlockIoReset(MediaId=0x%x)\n", This->Media->MediaId));\r
-\r
- return NorFlashReset (Instance);\r
-}\r
-\r
-//\r
-// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.ReadBlocks\r
-//\r
-EFI_STATUS\r
-EFIAPI\r
-NorFlashBlockIoReadBlocks (\r
- IN EFI_BLOCK_IO_PROTOCOL *This,\r
- IN UINT32 MediaId,\r
- IN EFI_LBA Lba,\r
- IN UINTN BufferSizeInBytes,\r
- OUT VOID *Buffer\r
- )\r
-{\r
- NOR_FLASH_INSTANCE *Instance;\r
- EFI_STATUS Status;\r
- EFI_BLOCK_IO_MEDIA *Media;\r
-\r
- if (This == NULL) {\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- Instance = INSTANCE_FROM_BLKIO_THIS (This);\r
- Media = This->Media;\r
-\r
- DEBUG ((DEBUG_BLKIO, "NorFlashBlockIoReadBlocks(MediaId=0x%x, Lba=%ld, BufferSize=0x%x bytes (%d kB), BufferPtr @ 0x%08x)\n", MediaId, Lba, BufferSizeInBytes, BufferSizeInBytes, Buffer));\r
-\r
- if (!Media) {\r
- Status = EFI_INVALID_PARAMETER;\r
- } else if (!Media->MediaPresent) {\r
- Status = EFI_NO_MEDIA;\r
- } else if (Media->MediaId != MediaId) {\r
- Status = EFI_MEDIA_CHANGED;\r
- } else if ((Media->IoAlign > 2) && (((UINTN)Buffer & (Media->IoAlign - 1)) != 0)) {\r
- Status = EFI_INVALID_PARAMETER;\r
- } else {\r
- Status = NorFlashReadBlocks (Instance, Lba, BufferSizeInBytes, Buffer);\r
- }\r
-\r
- return Status;\r
-}\r
-\r
-//\r
-// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.WriteBlocks\r
-//\r
-EFI_STATUS\r
-EFIAPI\r
-NorFlashBlockIoWriteBlocks (\r
- IN EFI_BLOCK_IO_PROTOCOL *This,\r
- IN UINT32 MediaId,\r
- IN EFI_LBA Lba,\r
- IN UINTN BufferSizeInBytes,\r
- IN VOID *Buffer\r
- )\r
-{\r
- NOR_FLASH_INSTANCE *Instance;\r
- EFI_STATUS Status;\r
-\r
- Instance = INSTANCE_FROM_BLKIO_THIS (This);\r
-\r
- DEBUG ((DEBUG_BLKIO, "NorFlashBlockIoWriteBlocks(MediaId=0x%x, Lba=%ld, BufferSize=0x%x bytes, BufferPtr @ 0x%08x)\n", MediaId, Lba, BufferSizeInBytes, Buffer));\r
-\r
- if ( !This->Media->MediaPresent ) {\r
- Status = EFI_NO_MEDIA;\r
- } else if ( This->Media->MediaId != MediaId ) {\r
- Status = EFI_MEDIA_CHANGED;\r
- } else if ( This->Media->ReadOnly ) {\r
- Status = EFI_WRITE_PROTECTED;\r
- } else {\r
- Status = NorFlashWriteBlocks (Instance, Lba, BufferSizeInBytes, Buffer);\r
- }\r
-\r
- return Status;\r
-}\r
-\r
-//\r
-// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.FlushBlocks\r
-//\r
-EFI_STATUS\r
-EFIAPI\r
-NorFlashBlockIoFlushBlocks (\r
- IN EFI_BLOCK_IO_PROTOCOL *This\r
- )\r
-{\r
- // No Flush required for the NOR Flash driver\r
- // because cache operations are not permitted.\r
-\r
- DEBUG ((DEBUG_BLKIO, "NorFlashBlockIoFlushBlocks: Function NOT IMPLEMENTED (not required).\n"));\r
-\r
- // Nothing to do so just return without error\r
- return EFI_SUCCESS;\r
-}\r
+++ /dev/null
-/** @file NorFlashDxe.c\r
-\r
- Copyright (c) 2011 - 2021, Arm Limited. All rights reserved.<BR>\r
-\r
- SPDX-License-Identifier: BSD-2-Clause-Patent\r
-\r
-**/\r
-\r
-#include <Library/UefiLib.h>\r
-#include <Library/BaseMemoryLib.h>\r
-#include <Library/MemoryAllocationLib.h>\r
-#include <Library/UefiBootServicesTableLib.h>\r
-#include <Library/PcdLib.h>\r
-#include <Library/HobLib.h>\r
-#include <Library/DxeServicesTableLib.h>\r
-\r
-#include "NorFlash.h"\r
-\r
-STATIC EFI_EVENT mNorFlashVirtualAddrChangeEvent;\r
-\r
-//\r
-// Global variable declarations\r
-//\r
-NOR_FLASH_INSTANCE **mNorFlashInstances;\r
-UINT32 mNorFlashDeviceCount;\r
-UINTN mFlashNvStorageVariableBase;\r
-EFI_EVENT mFvbVirtualAddrChangeEvent;\r
-\r
-NOR_FLASH_INSTANCE mNorFlashInstanceTemplate = {\r
- NOR_FLASH_SIGNATURE, // Signature\r
- NULL, // Handle ... NEED TO BE FILLED\r
-\r
- 0, // DeviceBaseAddress ... NEED TO BE FILLED\r
- 0, // RegionBaseAddress ... NEED TO BE FILLED\r
- 0, // Size ... NEED TO BE FILLED\r
- 0, // StartLba\r
-\r
- {\r
- EFI_BLOCK_IO_PROTOCOL_REVISION2, // Revision\r
- NULL, // Media ... NEED TO BE FILLED\r
- NorFlashBlockIoReset, // Reset;\r
- NorFlashBlockIoReadBlocks, // ReadBlocks\r
- NorFlashBlockIoWriteBlocks, // WriteBlocks\r
- NorFlashBlockIoFlushBlocks // FlushBlocks\r
- }, // BlockIoProtocol\r
-\r
- {\r
- 0, // MediaId ... NEED TO BE FILLED\r
- FALSE, // RemovableMedia\r
- TRUE, // MediaPresent\r
- FALSE, // LogicalPartition\r
- FALSE, // ReadOnly\r
- FALSE, // WriteCaching;\r
- 0, // BlockSize ... NEED TO BE FILLED\r
- 4, // IoAlign\r
- 0, // LastBlock ... NEED TO BE FILLED\r
- 0, // LowestAlignedLba\r
- 1, // LogicalBlocksPerPhysicalBlock\r
- }, // Media;\r
-\r
- {\r
- EFI_DISK_IO_PROTOCOL_REVISION, // Revision\r
- NorFlashDiskIoReadDisk, // ReadDisk\r
- NorFlashDiskIoWriteDisk // WriteDisk\r
- },\r
-\r
- {\r
- FvbGetAttributes, // GetAttributes\r
- FvbSetAttributes, // SetAttributes\r
- FvbGetPhysicalAddress, // GetPhysicalAddress\r
- FvbGetBlockSize, // GetBlockSize\r
- FvbRead, // Read\r
- FvbWrite, // Write\r
- FvbEraseBlocks, // EraseBlocks\r
- NULL, // ParentHandle\r
- }, // FvbProtoccol;\r
- NULL, // ShadowBuffer\r
- {\r
- {\r
- {\r
- HARDWARE_DEVICE_PATH,\r
- HW_VENDOR_DP,\r
- {\r
- (UINT8)(OFFSET_OF (NOR_FLASH_DEVICE_PATH, End)),\r
- (UINT8)(OFFSET_OF (NOR_FLASH_DEVICE_PATH, End) >> 8)\r
- }\r
- },\r
- { 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }\r
- }, // GUID ... NEED TO BE FILLED\r
- },\r
- 0, // Index\r
- {\r
- END_DEVICE_PATH_TYPE,\r
- END_ENTIRE_DEVICE_PATH_SUBTYPE,\r
- { sizeof (EFI_DEVICE_PATH_PROTOCOL), 0 }\r
- }\r
- } // DevicePath\r
-};\r
-\r
-EFI_STATUS\r
-NorFlashCreateInstance (\r
- IN UINTN NorFlashDeviceBase,\r
- IN UINTN NorFlashRegionBase,\r
- IN UINTN NorFlashSize,\r
- IN UINT32 Index,\r
- IN UINT32 BlockSize,\r
- IN BOOLEAN SupportFvb,\r
- OUT NOR_FLASH_INSTANCE **NorFlashInstance\r
- )\r
-{\r
- EFI_STATUS Status;\r
- NOR_FLASH_INSTANCE *Instance;\r
-\r
- ASSERT (NorFlashInstance != NULL);\r
-\r
- Instance = AllocateRuntimeCopyPool (sizeof (NOR_FLASH_INSTANCE), &mNorFlashInstanceTemplate);\r
- if (Instance == NULL) {\r
- return EFI_OUT_OF_RESOURCES;\r
- }\r
-\r
- Instance->DeviceBaseAddress = NorFlashDeviceBase;\r
- Instance->RegionBaseAddress = NorFlashRegionBase;\r
- Instance->Size = NorFlashSize;\r
-\r
- Instance->BlockIoProtocol.Media = &Instance->Media;\r
- Instance->Media.MediaId = Index;\r
- Instance->Media.BlockSize = BlockSize;\r
- Instance->Media.LastBlock = (NorFlashSize / BlockSize)-1;\r
-\r
- CopyGuid (&Instance->DevicePath.Vendor.Guid, &gEfiCallerIdGuid);\r
- Instance->DevicePath.Index = (UINT8)Index;\r
-\r
- Instance->ShadowBuffer = AllocateRuntimePool (BlockSize);\r
- if (Instance->ShadowBuffer == NULL) {\r
- return EFI_OUT_OF_RESOURCES;\r
- }\r
-\r
- if (SupportFvb) {\r
- NorFlashFvbInitialize (Instance);\r
-\r
- Status = gBS->InstallMultipleProtocolInterfaces (\r
- &Instance->Handle,\r
- &gEfiDevicePathProtocolGuid,\r
- &Instance->DevicePath,\r
- &gEfiBlockIoProtocolGuid,\r
- &Instance->BlockIoProtocol,\r
- &gEfiFirmwareVolumeBlockProtocolGuid,\r
- &Instance->FvbProtocol,\r
- NULL\r
- );\r
- if (EFI_ERROR (Status)) {\r
- FreePool (Instance);\r
- return Status;\r
- }\r
- } else {\r
- Status = gBS->InstallMultipleProtocolInterfaces (\r
- &Instance->Handle,\r
- &gEfiDevicePathProtocolGuid,\r
- &Instance->DevicePath,\r
- &gEfiBlockIoProtocolGuid,\r
- &Instance->BlockIoProtocol,\r
- &gEfiDiskIoProtocolGuid,\r
- &Instance->DiskIoProtocol,\r
- NULL\r
- );\r
- if (EFI_ERROR (Status)) {\r
- FreePool (Instance);\r
- return Status;\r
- }\r
- }\r
-\r
- *NorFlashInstance = Instance;\r
- return Status;\r
-}\r
-\r
-/**\r
- * This function unlock and erase an entire NOR Flash block.\r
- **/\r
-EFI_STATUS\r
-NorFlashUnlockAndEraseSingleBlock (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN BlockAddress\r
- )\r
-{\r
- EFI_STATUS Status;\r
- UINTN Index;\r
- EFI_TPL OriginalTPL;\r
-\r
- if (!EfiAtRuntime ()) {\r
- // Raise TPL to TPL_HIGH to stop anyone from interrupting us.\r
- OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);\r
- } else {\r
- // This initialization is only to prevent the compiler to complain about the\r
- // use of uninitialized variables\r
- OriginalTPL = TPL_HIGH_LEVEL;\r
- }\r
-\r
- Index = 0;\r
- // The block erase might fail a first time (SW bug ?). Retry it ...\r
- do {\r
- // Unlock the block if we have to\r
- Status = NorFlashUnlockSingleBlockIfNecessary (Instance, BlockAddress);\r
- if (EFI_ERROR (Status)) {\r
- break;\r
- }\r
-\r
- Status = NorFlashEraseSingleBlock (Instance, BlockAddress);\r
- Index++;\r
- } while ((Index < NOR_FLASH_ERASE_RETRY) && (Status == EFI_WRITE_PROTECTED));\r
-\r
- if (Index == NOR_FLASH_ERASE_RETRY) {\r
- DEBUG ((DEBUG_ERROR, "EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error (try to erase %d times)\n", BlockAddress, Index));\r
- }\r
-\r
- if (!EfiAtRuntime ()) {\r
- // Interruptions can resume.\r
- gBS->RestoreTPL (OriginalTPL);\r
- }\r
-\r
- return Status;\r
-}\r
-\r
-EFI_STATUS\r
-NorFlashWriteFullBlock (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN EFI_LBA Lba,\r
- IN UINT32 *DataBuffer,\r
- IN UINT32 BlockSizeInWords\r
- )\r
-{\r
- EFI_STATUS Status;\r
- UINTN WordAddress;\r
- UINT32 WordIndex;\r
- UINTN BufferIndex;\r
- UINTN BlockAddress;\r
- UINTN BuffersInBlock;\r
- UINTN RemainingWords;\r
- EFI_TPL OriginalTPL;\r
- UINTN Cnt;\r
-\r
- Status = EFI_SUCCESS;\r
-\r
- // Get the physical address of the block\r
- BlockAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, Lba, BlockSizeInWords * 4);\r
-\r
- // Start writing from the first address at the start of the block\r
- WordAddress = BlockAddress;\r
-\r
- if (!EfiAtRuntime ()) {\r
- // Raise TPL to TPL_HIGH to stop anyone from interrupting us.\r
- OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);\r
- } else {\r
- // This initialization is only to prevent the compiler to complain about the\r
- // use of uninitialized variables\r
- OriginalTPL = TPL_HIGH_LEVEL;\r
- }\r
-\r
- Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress);\r
- if (EFI_ERROR (Status)) {\r
- DEBUG ((DEBUG_ERROR, "WriteSingleBlock: ERROR - Failed to Unlock and Erase the single block at 0x%X\n", BlockAddress));\r
- goto EXIT;\r
- }\r
-\r
- // To speed up the programming operation, NOR Flash is programmed using the Buffered Programming method.\r
-\r
- // Check that the address starts at a 32-word boundary, i.e. last 7 bits must be zero\r
- if ((WordAddress & BOUNDARY_OF_32_WORDS) == 0x00) {\r
- // First, break the entire block into buffer-sized chunks.\r
- BuffersInBlock = (UINTN)(BlockSizeInWords * 4) / P30_MAX_BUFFER_SIZE_IN_BYTES;\r
-\r
- // Then feed each buffer chunk to the NOR Flash\r
- // If a buffer does not contain any data, don't write it.\r
- for (BufferIndex = 0;\r
- BufferIndex < BuffersInBlock;\r
- BufferIndex++, WordAddress += P30_MAX_BUFFER_SIZE_IN_BYTES, DataBuffer += P30_MAX_BUFFER_SIZE_IN_WORDS\r
- )\r
- {\r
- // Check the buffer to see if it contains any data (not set all 1s).\r
- for (Cnt = 0; Cnt < P30_MAX_BUFFER_SIZE_IN_WORDS; Cnt++) {\r
- if (~DataBuffer[Cnt] != 0 ) {\r
- // Some data found, write the buffer.\r
- Status = NorFlashWriteBuffer (\r
- Instance,\r
- WordAddress,\r
- P30_MAX_BUFFER_SIZE_IN_BYTES,\r
- DataBuffer\r
- );\r
- if (EFI_ERROR (Status)) {\r
- goto EXIT;\r
- }\r
-\r
- break;\r
- }\r
- }\r
- }\r
-\r
- // Finally, finish off any remaining words that are less than the maximum size of the buffer\r
- RemainingWords = BlockSizeInWords % P30_MAX_BUFFER_SIZE_IN_WORDS;\r
-\r
- if (RemainingWords != 0) {\r
- Status = NorFlashWriteBuffer (Instance, WordAddress, (RemainingWords * 4), DataBuffer);\r
- if (EFI_ERROR (Status)) {\r
- goto EXIT;\r
- }\r
- }\r
- } else {\r
- // For now, use the single word programming algorithm\r
- // It is unlikely that the NOR Flash will exist in an address which falls within a 32 word boundary range,\r
- // i.e. which ends in the range 0x......01 - 0x......7F.\r
- for (WordIndex = 0; WordIndex < BlockSizeInWords; WordIndex++, DataBuffer++, WordAddress = WordAddress + 4) {\r
- Status = NorFlashWriteSingleWord (Instance, WordAddress, *DataBuffer);\r
- if (EFI_ERROR (Status)) {\r
- goto EXIT;\r
- }\r
- }\r
- }\r
-\r
-EXIT:\r
- if (!EfiAtRuntime ()) {\r
- // Interruptions can resume.\r
- gBS->RestoreTPL (OriginalTPL);\r
- }\r
-\r
- if (EFI_ERROR (Status)) {\r
- DEBUG ((DEBUG_ERROR, "NOR FLASH Programming [WriteSingleBlock] failed at address 0x%08x. Exit Status = \"%r\".\n", WordAddress, Status));\r
- }\r
-\r
- return Status;\r
-}\r
-\r
-EFI_STATUS\r
-EFIAPI\r
-NorFlashInitialise (\r
- IN EFI_HANDLE ImageHandle,\r
- IN EFI_SYSTEM_TABLE *SystemTable\r
- )\r
-{\r
- EFI_STATUS Status;\r
- UINT32 Index;\r
- NOR_FLASH_DESCRIPTION *NorFlashDevices;\r
- BOOLEAN ContainVariableStorage;\r
-\r
- Status = NorFlashPlatformInitialization ();\r
- if (EFI_ERROR (Status)) {\r
- DEBUG ((DEBUG_ERROR, "NorFlashInitialise: Fail to initialize Nor Flash devices\n"));\r
- return Status;\r
- }\r
-\r
- Status = NorFlashPlatformGetDevices (&NorFlashDevices, &mNorFlashDeviceCount);\r
- if (EFI_ERROR (Status)) {\r
- DEBUG ((DEBUG_ERROR, "NorFlashInitialise: Fail to get Nor Flash devices\n"));\r
- return Status;\r
- }\r
-\r
- mNorFlashInstances = AllocateRuntimePool (sizeof (NOR_FLASH_INSTANCE *) * mNorFlashDeviceCount);\r
-\r
- for (Index = 0; Index < mNorFlashDeviceCount; Index++) {\r
- // Check if this NOR Flash device contain the variable storage region\r
-\r
- if (PcdGet64 (PcdFlashNvStorageVariableBase64) != 0) {\r
- ContainVariableStorage =\r
- (NorFlashDevices[Index].RegionBaseAddress <= PcdGet64 (PcdFlashNvStorageVariableBase64)) &&\r
- (PcdGet64 (PcdFlashNvStorageVariableBase64) + PcdGet32 (PcdFlashNvStorageVariableSize) <=\r
- NorFlashDevices[Index].RegionBaseAddress + NorFlashDevices[Index].Size);\r
- } else {\r
- ContainVariableStorage =\r
- (NorFlashDevices[Index].RegionBaseAddress <= PcdGet32 (PcdFlashNvStorageVariableBase)) &&\r
- (PcdGet32 (PcdFlashNvStorageVariableBase) + PcdGet32 (PcdFlashNvStorageVariableSize) <=\r
- NorFlashDevices[Index].RegionBaseAddress + NorFlashDevices[Index].Size);\r
- }\r
-\r
- Status = NorFlashCreateInstance (\r
- NorFlashDevices[Index].DeviceBaseAddress,\r
- NorFlashDevices[Index].RegionBaseAddress,\r
- NorFlashDevices[Index].Size,\r
- Index,\r
- NorFlashDevices[Index].BlockSize,\r
- ContainVariableStorage,\r
- &mNorFlashInstances[Index]\r
- );\r
- if (EFI_ERROR (Status)) {\r
- DEBUG ((DEBUG_ERROR, "NorFlashInitialise: Fail to create instance for NorFlash[%d]\n", Index));\r
- }\r
- }\r
-\r
- //\r
- // Register for the virtual address change event\r
- //\r
- Status = gBS->CreateEventEx (\r
- EVT_NOTIFY_SIGNAL,\r
- TPL_NOTIFY,\r
- NorFlashVirtualNotifyEvent,\r
- NULL,\r
- &gEfiEventVirtualAddressChangeGuid,\r
- &mNorFlashVirtualAddrChangeEvent\r
- );\r
- ASSERT_EFI_ERROR (Status);\r
-\r
- return Status;\r
-}\r
-\r
-EFI_STATUS\r
-EFIAPI\r
-NorFlashFvbInitialize (\r
- IN NOR_FLASH_INSTANCE *Instance\r
- )\r
-{\r
- EFI_STATUS Status;\r
- UINT32 FvbNumLba;\r
- EFI_BOOT_MODE BootMode;\r
- UINTN RuntimeMmioRegionSize;\r
-\r
- DEBUG ((DEBUG_BLKIO, "NorFlashFvbInitialize\n"));\r
- ASSERT ((Instance != NULL));\r
-\r
- //\r
- // Declare the Non-Volatile storage as EFI_MEMORY_RUNTIME\r
- //\r
-\r
- // Note: all the NOR Flash region needs to be reserved into the UEFI Runtime memory;\r
- // even if we only use the small block region at the top of the NOR Flash.\r
- // The reason is when the NOR Flash memory is set into program mode, the command\r
- // is written as the base of the flash region (ie: Instance->DeviceBaseAddress)\r
- RuntimeMmioRegionSize = (Instance->RegionBaseAddress - Instance->DeviceBaseAddress) + Instance->Size;\r
-\r
- Status = gDS->AddMemorySpace (\r
- EfiGcdMemoryTypeMemoryMappedIo,\r
- Instance->DeviceBaseAddress,\r
- RuntimeMmioRegionSize,\r
- EFI_MEMORY_UC | EFI_MEMORY_RUNTIME\r
- );\r
- ASSERT_EFI_ERROR (Status);\r
-\r
- Status = gDS->SetMemorySpaceAttributes (\r
- Instance->DeviceBaseAddress,\r
- RuntimeMmioRegionSize,\r
- EFI_MEMORY_UC | EFI_MEMORY_RUNTIME\r
- );\r
- ASSERT_EFI_ERROR (Status);\r
-\r
- mFlashNvStorageVariableBase = (PcdGet64 (PcdFlashNvStorageVariableBase64) != 0) ?\r
- PcdGet64 (PcdFlashNvStorageVariableBase64) : PcdGet32 (PcdFlashNvStorageVariableBase);\r
-\r
- // Set the index of the first LBA for the FVB\r
- Instance->StartLba = (mFlashNvStorageVariableBase - Instance->RegionBaseAddress) / Instance->Media.BlockSize;\r
-\r
- BootMode = GetBootModeHob ();\r
- if (BootMode == BOOT_WITH_DEFAULT_SETTINGS) {\r
- Status = EFI_INVALID_PARAMETER;\r
- } else {\r
- // Determine if there is a valid header at the beginning of the NorFlash\r
- Status = ValidateFvHeader (Instance);\r
- }\r
-\r
- // Install the Default FVB header if required\r
- if (EFI_ERROR (Status)) {\r
- // There is no valid header, so time to install one.\r
- DEBUG ((DEBUG_INFO, "%a: The FVB Header is not valid.\n", __FUNCTION__));\r
- DEBUG ((\r
- DEBUG_INFO,\r
- "%a: Installing a correct one for this volume.\n",\r
- __FUNCTION__\r
- ));\r
-\r
- // Erase all the NorFlash that is reserved for variable storage\r
- FvbNumLba = (PcdGet32 (PcdFlashNvStorageVariableSize) + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) + PcdGet32 (PcdFlashNvStorageFtwSpareSize)) / Instance->Media.BlockSize;\r
-\r
- Status = FvbEraseBlocks (&Instance->FvbProtocol, (EFI_LBA)0, FvbNumLba, EFI_LBA_LIST_TERMINATOR);\r
- if (EFI_ERROR (Status)) {\r
- return Status;\r
- }\r
-\r
- // Install all appropriate headers\r
- Status = InitializeFvAndVariableStoreHeaders (Instance);\r
- if (EFI_ERROR (Status)) {\r
- return Status;\r
- }\r
- }\r
-\r
- //\r
- // The driver implementing the variable read service can now be dispatched;\r
- // the varstore headers are in place.\r
- //\r
- Status = gBS->InstallProtocolInterface (\r
- &gImageHandle,\r
- &gEdkiiNvVarStoreFormattedGuid,\r
- EFI_NATIVE_INTERFACE,\r
- NULL\r
- );\r
- ASSERT_EFI_ERROR (Status);\r
-\r
- //\r
- // Register for the virtual address change event\r
- //\r
- Status = gBS->CreateEventEx (\r
- EVT_NOTIFY_SIGNAL,\r
- TPL_NOTIFY,\r
- FvbVirtualNotifyEvent,\r
- NULL,\r
- &gEfiEventVirtualAddressChangeGuid,\r
- &mFvbVirtualAddrChangeEvent\r
- );\r
- ASSERT_EFI_ERROR (Status);\r
-\r
- return Status;\r
-}\r
+++ /dev/null
-#/** @file\r
-#\r
-# Component description file for NorFlashDxe module\r
-#\r
-# Copyright (c) 2011 - 2021, Arm Limited. All rights reserved.<BR>\r
-#\r
-# SPDX-License-Identifier: BSD-2-Clause-Patent\r
-#\r
-#**/\r
-\r
-[Defines]\r
- INF_VERSION = 0x00010005\r
- BASE_NAME = ArmVeNorFlashDxe\r
- FILE_GUID = 93E34C7E-B50E-11DF-9223-2443DFD72085\r
- MODULE_TYPE = DXE_RUNTIME_DRIVER\r
- VERSION_STRING = 1.0\r
- ENTRY_POINT = NorFlashInitialise\r
-\r
-[Sources.common]\r
- NorFlash.c\r
- NorFlash.h\r
- NorFlashDxe.c\r
- NorFlashFvb.c\r
- NorFlashBlockIoDxe.c\r
-\r
-[Packages]\r
- MdePkg/MdePkg.dec\r
- MdeModulePkg/MdeModulePkg.dec\r
- ArmPlatformPkg/ArmPlatformPkg.dec\r
- EmbeddedPkg/EmbeddedPkg.dec\r
-\r
-[LibraryClasses]\r
- IoLib\r
- BaseLib\r
- DebugLib\r
- HobLib\r
- NorFlashPlatformLib\r
- UefiLib\r
- UefiDriverEntryPoint\r
- UefiBootServicesTableLib\r
- UefiRuntimeLib\r
- DxeServicesTableLib\r
-\r
-[Guids]\r
- gEfiSystemNvDataFvGuid\r
- gEfiVariableGuid\r
- gEfiAuthenticatedVariableGuid\r
- gEfiEventVirtualAddressChangeGuid\r
- gEdkiiNvVarStoreFormattedGuid ## PRODUCES ## PROTOCOL\r
-\r
-[Protocols]\r
- gEfiBlockIoProtocolGuid\r
- gEfiDevicePathProtocolGuid\r
- gEfiFirmwareVolumeBlockProtocolGuid\r
- gEfiDiskIoProtocolGuid\r
-\r
-[Pcd.common]\r
- gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase64\r
- gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase\r
- gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableSize\r
- gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingBase64\r
- gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingBase\r
- gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingSize\r
- gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareBase64\r
- gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareBase\r
- gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareSize\r
-\r
- gArmPlatformTokenSpaceGuid.PcdNorFlashCheckBlockLocked\r
-\r
-[Depex]\r
- gEfiCpuArchProtocolGuid\r
+++ /dev/null
-/*++ @file NorFlashFvbDxe.c\r
-\r
- Copyright (c) 2011 - 2021, Arm Limited. All rights reserved.<BR>\r
-\r
- SPDX-License-Identifier: BSD-2-Clause-Patent\r
-\r
- --*/\r
-\r
-#include <PiDxe.h>\r
-\r
-#include <Library/PcdLib.h>\r
-#include <Library/BaseLib.h>\r
-#include <Library/UefiLib.h>\r
-#include <Library/BaseMemoryLib.h>\r
-#include <Library/MemoryAllocationLib.h>\r
-\r
-#include <Guid/VariableFormat.h>\r
-#include <Guid/SystemNvDataGuid.h>\r
-#include <Guid/NvVarStoreFormatted.h>\r
-\r
-#include "NorFlash.h"\r
-\r
-extern UINTN mFlashNvStorageVariableBase;\r
-///\r
-/// The Firmware Volume Block Protocol is the low-level interface\r
-/// to a firmware volume. File-level access to a firmware volume\r
-/// should not be done using the Firmware Volume Block Protocol.\r
-/// Normal access to a firmware volume must use the Firmware\r
-/// Volume Protocol. Typically, only the file system driver that\r
-/// produces the Firmware Volume Protocol will bind to the\r
-/// Firmware Volume Block Protocol.\r
-///\r
-\r
-/**\r
- Initialises the FV Header and Variable Store Header\r
- to support variable operations.\r
-\r
- @param[in] Ptr - Location to initialise the headers\r
-\r
-**/\r
-EFI_STATUS\r
-InitializeFvAndVariableStoreHeaders (\r
- IN NOR_FLASH_INSTANCE *Instance\r
- )\r
-{\r
- EFI_STATUS Status;\r
- VOID *Headers;\r
- UINTN HeadersLength;\r
- EFI_FIRMWARE_VOLUME_HEADER *FirmwareVolumeHeader;\r
- VARIABLE_STORE_HEADER *VariableStoreHeader;\r
- UINT32 NvStorageFtwSpareSize;\r
- UINT32 NvStorageFtwWorkingSize;\r
- UINT32 NvStorageVariableSize;\r
- UINT64 NvStorageFtwSpareBase;\r
- UINT64 NvStorageFtwWorkingBase;\r
- UINT64 NvStorageVariableBase;\r
-\r
- HeadersLength = sizeof (EFI_FIRMWARE_VOLUME_HEADER) + sizeof (EFI_FV_BLOCK_MAP_ENTRY) + sizeof (VARIABLE_STORE_HEADER);\r
- Headers = AllocateZeroPool (HeadersLength);\r
-\r
- NvStorageFtwWorkingSize = PcdGet32 (PcdFlashNvStorageFtwWorkingSize);\r
- NvStorageFtwSpareSize = PcdGet32 (PcdFlashNvStorageFtwSpareSize);\r
- NvStorageVariableSize = PcdGet32 (PcdFlashNvStorageVariableSize);\r
-\r
- NvStorageFtwSpareBase = (PcdGet64 (PcdFlashNvStorageFtwSpareBase64) != 0) ?\r
- PcdGet64 (PcdFlashNvStorageFtwSpareBase64) : PcdGet32 (PcdFlashNvStorageFtwSpareBase);\r
- NvStorageFtwWorkingBase = (PcdGet64 (PcdFlashNvStorageFtwWorkingBase64) != 0) ?\r
- PcdGet64 (PcdFlashNvStorageFtwWorkingBase64) : PcdGet32 (PcdFlashNvStorageFtwWorkingBase);\r
- NvStorageVariableBase = (PcdGet64 (PcdFlashNvStorageVariableBase64) != 0) ?\r
- PcdGet64 (PcdFlashNvStorageVariableBase64) : PcdGet32 (PcdFlashNvStorageVariableBase);\r
-\r
- // FirmwareVolumeHeader->FvLength is declared to have the Variable area AND the FTW working area AND the FTW Spare contiguous.\r
- if ((NvStorageVariableBase + NvStorageVariableSize) != NvStorageFtwWorkingBase) {\r
- DEBUG ((\r
- DEBUG_ERROR,\r
- "%a: NvStorageFtwWorkingBase is not contiguous with NvStorageVariableBase region\n",\r
- __FUNCTION__\r
- ));\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- if ((NvStorageFtwWorkingBase + NvStorageFtwWorkingSize) != NvStorageFtwSpareBase) {\r
- DEBUG ((\r
- DEBUG_ERROR,\r
- "%a: NvStorageFtwSpareBase is not contiguous with NvStorageFtwWorkingBase region\n",\r
- __FUNCTION__\r
- ));\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- // Check if the size of the area is at least one block size\r
- if ((NvStorageVariableSize <= 0) || (NvStorageVariableSize / Instance->Media.BlockSize <= 0)) {\r
- DEBUG ((\r
- DEBUG_ERROR,\r
- "%a: NvStorageVariableSize is 0x%x, should be atleast one block size\n",\r
- __FUNCTION__,\r
- NvStorageVariableSize\r
- ));\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- if ((NvStorageFtwWorkingSize <= 0) || (NvStorageFtwWorkingSize / Instance->Media.BlockSize <= 0)) {\r
- DEBUG ((\r
- DEBUG_ERROR,\r
- "%a: NvStorageFtwWorkingSize is 0x%x, should be atleast one block size\n",\r
- __FUNCTION__,\r
- NvStorageFtwWorkingSize\r
- ));\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- if ((NvStorageFtwSpareSize <= 0) || (NvStorageFtwSpareSize / Instance->Media.BlockSize <= 0)) {\r
- DEBUG ((\r
- DEBUG_ERROR,\r
- "%a: NvStorageFtwSpareSize is 0x%x, should be atleast one block size\n",\r
- __FUNCTION__,\r
- NvStorageFtwSpareSize\r
- ));\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- // Ensure the Variable area Base Addresses are aligned on a block size boundaries\r
- if ((NvStorageVariableBase % Instance->Media.BlockSize != 0) ||\r
- (NvStorageFtwWorkingBase % Instance->Media.BlockSize != 0) ||\r
- (NvStorageFtwSpareBase % Instance->Media.BlockSize != 0))\r
- {\r
- DEBUG ((DEBUG_ERROR, "%a: NvStorage Base addresses must be aligned to block size boundaries", __FUNCTION__));\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- //\r
- // EFI_FIRMWARE_VOLUME_HEADER\r
- //\r
- FirmwareVolumeHeader = (EFI_FIRMWARE_VOLUME_HEADER *)Headers;\r
- CopyGuid (&FirmwareVolumeHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid);\r
- FirmwareVolumeHeader->FvLength =\r
- PcdGet32 (PcdFlashNvStorageVariableSize) +\r
- PcdGet32 (PcdFlashNvStorageFtwWorkingSize) +\r
- PcdGet32 (PcdFlashNvStorageFtwSpareSize);\r
- FirmwareVolumeHeader->Signature = EFI_FVH_SIGNATURE;\r
- FirmwareVolumeHeader->Attributes = (EFI_FVB_ATTRIBUTES_2)(\r
- EFI_FVB2_READ_ENABLED_CAP | // Reads may be enabled\r
- EFI_FVB2_READ_STATUS | // Reads are currently enabled\r
- EFI_FVB2_STICKY_WRITE | // A block erase is required to flip bits into EFI_FVB2_ERASE_POLARITY\r
- EFI_FVB2_MEMORY_MAPPED | // It is memory mapped\r
- EFI_FVB2_ERASE_POLARITY | // After erasure all bits take this value (i.e. '1')\r
- EFI_FVB2_WRITE_STATUS | // Writes are currently enabled\r
- EFI_FVB2_WRITE_ENABLED_CAP // Writes may be enabled\r
- );\r
- FirmwareVolumeHeader->HeaderLength = sizeof (EFI_FIRMWARE_VOLUME_HEADER) + sizeof (EFI_FV_BLOCK_MAP_ENTRY);\r
- FirmwareVolumeHeader->Revision = EFI_FVH_REVISION;\r
- FirmwareVolumeHeader->BlockMap[0].NumBlocks = Instance->Media.LastBlock + 1;\r
- FirmwareVolumeHeader->BlockMap[0].Length = Instance->Media.BlockSize;\r
- FirmwareVolumeHeader->BlockMap[1].NumBlocks = 0;\r
- FirmwareVolumeHeader->BlockMap[1].Length = 0;\r
- FirmwareVolumeHeader->Checksum = CalculateCheckSum16 ((UINT16 *)FirmwareVolumeHeader, FirmwareVolumeHeader->HeaderLength);\r
-\r
- //\r
- // VARIABLE_STORE_HEADER\r
- //\r
- VariableStoreHeader = (VARIABLE_STORE_HEADER *)((UINTN)Headers + FirmwareVolumeHeader->HeaderLength);\r
- CopyGuid (&VariableStoreHeader->Signature, &gEfiAuthenticatedVariableGuid);\r
- VariableStoreHeader->Size = PcdGet32 (PcdFlashNvStorageVariableSize) - FirmwareVolumeHeader->HeaderLength;\r
- VariableStoreHeader->Format = VARIABLE_STORE_FORMATTED;\r
- VariableStoreHeader->State = VARIABLE_STORE_HEALTHY;\r
-\r
- // Install the combined super-header in the NorFlash\r
- Status = FvbWrite (&Instance->FvbProtocol, 0, 0, &HeadersLength, Headers);\r
-\r
- FreePool (Headers);\r
- return Status;\r
-}\r
-\r
-/**\r
- Check the integrity of firmware volume header.\r
-\r
- @param[in] FwVolHeader - A pointer to a firmware volume header\r
-\r
- @retval EFI_SUCCESS - The firmware volume is consistent\r
- @retval EFI_NOT_FOUND - The firmware volume has been corrupted.\r
-\r
-**/\r
-EFI_STATUS\r
-ValidateFvHeader (\r
- IN NOR_FLASH_INSTANCE *Instance\r
- )\r
-{\r
- UINT16 Checksum;\r
- EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;\r
- VARIABLE_STORE_HEADER *VariableStoreHeader;\r
- UINTN VariableStoreLength;\r
- UINTN FvLength;\r
-\r
- FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *)Instance->RegionBaseAddress;\r
-\r
- FvLength = PcdGet32 (PcdFlashNvStorageVariableSize) + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) +\r
- PcdGet32 (PcdFlashNvStorageFtwSpareSize);\r
-\r
- //\r
- // Verify the header revision, header signature, length\r
- // Length of FvBlock cannot be 2**64-1\r
- // HeaderLength cannot be an odd number\r
- //\r
- if ( (FwVolHeader->Revision != EFI_FVH_REVISION)\r
- || (FwVolHeader->Signature != EFI_FVH_SIGNATURE)\r
- || (FwVolHeader->FvLength != FvLength)\r
- )\r
- {\r
- DEBUG ((\r
- DEBUG_INFO,\r
- "%a: No Firmware Volume header present\n",\r
- __FUNCTION__\r
- ));\r
- return EFI_NOT_FOUND;\r
- }\r
-\r
- // Check the Firmware Volume Guid\r
- if ( CompareGuid (&FwVolHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid) == FALSE ) {\r
- DEBUG ((\r
- DEBUG_INFO,\r
- "%a: Firmware Volume Guid non-compatible\n",\r
- __FUNCTION__\r
- ));\r
- return EFI_NOT_FOUND;\r
- }\r
-\r
- // Verify the header checksum\r
- Checksum = CalculateSum16 ((UINT16 *)FwVolHeader, FwVolHeader->HeaderLength);\r
- if (Checksum != 0) {\r
- DEBUG ((\r
- DEBUG_INFO,\r
- "%a: FV checksum is invalid (Checksum:0x%X)\n",\r
- __FUNCTION__,\r
- Checksum\r
- ));\r
- return EFI_NOT_FOUND;\r
- }\r
-\r
- VariableStoreHeader = (VARIABLE_STORE_HEADER *)((UINTN)FwVolHeader + FwVolHeader->HeaderLength);\r
-\r
- // Check the Variable Store Guid\r
- if (!CompareGuid (&VariableStoreHeader->Signature, &gEfiVariableGuid) &&\r
- !CompareGuid (&VariableStoreHeader->Signature, &gEfiAuthenticatedVariableGuid))\r
- {\r
- DEBUG ((\r
- DEBUG_INFO,\r
- "%a: Variable Store Guid non-compatible\n",\r
- __FUNCTION__\r
- ));\r
- return EFI_NOT_FOUND;\r
- }\r
-\r
- VariableStoreLength = PcdGet32 (PcdFlashNvStorageVariableSize) - FwVolHeader->HeaderLength;\r
- if (VariableStoreHeader->Size != VariableStoreLength) {\r
- DEBUG ((\r
- DEBUG_INFO,\r
- "%a: Variable Store Length does not match\n",\r
- __FUNCTION__\r
- ));\r
- return EFI_NOT_FOUND;\r
- }\r
-\r
- return EFI_SUCCESS;\r
-}\r
-\r
-/**\r
- The GetAttributes() function retrieves the attributes and\r
- current settings of the block.\r
-\r
- @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.\r
-\r
- @param Attributes Pointer to EFI_FVB_ATTRIBUTES_2 in which the attributes and\r
- current settings are returned.\r
- Type EFI_FVB_ATTRIBUTES_2 is defined in EFI_FIRMWARE_VOLUME_HEADER.\r
-\r
- @retval EFI_SUCCESS The firmware volume attributes were returned.\r
-\r
- **/\r
-EFI_STATUS\r
-EFIAPI\r
-FvbGetAttributes (\r
- IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,\r
- OUT EFI_FVB_ATTRIBUTES_2 *Attributes\r
- )\r
-{\r
- EFI_FVB_ATTRIBUTES_2 FlashFvbAttributes;\r
- NOR_FLASH_INSTANCE *Instance;\r
-\r
- Instance = INSTANCE_FROM_FVB_THIS (This);\r
-\r
- FlashFvbAttributes = (EFI_FVB_ATTRIBUTES_2)(\r
-\r
- EFI_FVB2_READ_ENABLED_CAP | // Reads may be enabled\r
- EFI_FVB2_READ_STATUS | // Reads are currently enabled\r
- EFI_FVB2_STICKY_WRITE | // A block erase is required to flip bits into EFI_FVB2_ERASE_POLARITY\r
- EFI_FVB2_MEMORY_MAPPED | // It is memory mapped\r
- EFI_FVB2_ERASE_POLARITY // After erasure all bits take this value (i.e. '1')\r
-\r
- );\r
-\r
- // Check if it is write protected\r
- if (Instance->Media.ReadOnly != TRUE) {\r
- FlashFvbAttributes = FlashFvbAttributes |\r
- EFI_FVB2_WRITE_STATUS | // Writes are currently enabled\r
- EFI_FVB2_WRITE_ENABLED_CAP; // Writes may be enabled\r
- }\r
-\r
- *Attributes = FlashFvbAttributes;\r
-\r
- DEBUG ((DEBUG_BLKIO, "FvbGetAttributes(0x%X)\n", *Attributes));\r
-\r
- return EFI_SUCCESS;\r
-}\r
-\r
-/**\r
- The SetAttributes() function sets configurable firmware volume attributes\r
- and returns the new settings of the firmware volume.\r
-\r
-\r
- @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.\r
-\r
- @param Attributes On input, Attributes is a pointer to EFI_FVB_ATTRIBUTES_2\r
- that contains the desired firmware volume settings.\r
- On successful return, it contains the new settings of\r
- the firmware volume.\r
- Type EFI_FVB_ATTRIBUTES_2 is defined in EFI_FIRMWARE_VOLUME_HEADER.\r
-\r
- @retval EFI_SUCCESS The firmware volume attributes were returned.\r
-\r
- @retval EFI_INVALID_PARAMETER The attributes requested are in conflict with the capabilities\r
- as declared in the firmware volume header.\r
-\r
- **/\r
-EFI_STATUS\r
-EFIAPI\r
-FvbSetAttributes (\r
- IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,\r
- IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes\r
- )\r
-{\r
- DEBUG ((DEBUG_BLKIO, "FvbSetAttributes(0x%X) is not supported\n", *Attributes));\r
- return EFI_UNSUPPORTED;\r
-}\r
-\r
-/**\r
- The GetPhysicalAddress() function retrieves the base address of\r
- a memory-mapped firmware volume. This function should be called\r
- only for memory-mapped firmware volumes.\r
-\r
- @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.\r
-\r
- @param Address Pointer to a caller-allocated\r
- EFI_PHYSICAL_ADDRESS that, on successful\r
- return from GetPhysicalAddress(), contains the\r
- base address of the firmware volume.\r
-\r
- @retval EFI_SUCCESS The firmware volume base address was returned.\r
-\r
- @retval EFI_NOT_SUPPORTED The firmware volume is not memory mapped.\r
-\r
- **/\r
-EFI_STATUS\r
-EFIAPI\r
-FvbGetPhysicalAddress (\r
- IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,\r
- OUT EFI_PHYSICAL_ADDRESS *Address\r
- )\r
-{\r
- NOR_FLASH_INSTANCE *Instance;\r
-\r
- Instance = INSTANCE_FROM_FVB_THIS (This);\r
-\r
- DEBUG ((DEBUG_BLKIO, "FvbGetPhysicalAddress(BaseAddress=0x%08x)\n", Instance->RegionBaseAddress));\r
-\r
- ASSERT (Address != NULL);\r
-\r
- *Address = mFlashNvStorageVariableBase;\r
- return EFI_SUCCESS;\r
-}\r
-\r
-/**\r
- The GetBlockSize() function retrieves the size of the requested\r
- block. It also returns the number of additional blocks with\r
- the identical size. The GetBlockSize() function is used to\r
- retrieve the block map (see EFI_FIRMWARE_VOLUME_HEADER).\r
-\r
-\r
- @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.\r
-\r
- @param Lba Indicates the block for which to return the size.\r
-\r
- @param BlockSize Pointer to a caller-allocated UINTN in which\r
- the size of the block is returned.\r
-\r
- @param NumberOfBlocks Pointer to a caller-allocated UINTN in\r
- which the number of consecutive blocks,\r
- starting with Lba, is returned. All\r
- blocks in this range have a size of\r
- BlockSize.\r
-\r
-\r
- @retval EFI_SUCCESS The firmware volume base address was returned.\r
-\r
- @retval EFI_INVALID_PARAMETER The requested LBA is out of range.\r
-\r
- **/\r
-EFI_STATUS\r
-EFIAPI\r
-FvbGetBlockSize (\r
- IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,\r
- IN EFI_LBA Lba,\r
- OUT UINTN *BlockSize,\r
- OUT UINTN *NumberOfBlocks\r
- )\r
-{\r
- EFI_STATUS Status;\r
- NOR_FLASH_INSTANCE *Instance;\r
-\r
- Instance = INSTANCE_FROM_FVB_THIS (This);\r
-\r
- DEBUG ((DEBUG_BLKIO, "FvbGetBlockSize(Lba=%ld, BlockSize=0x%x, LastBlock=%ld)\n", Lba, Instance->Media.BlockSize, Instance->Media.LastBlock));\r
-\r
- if (Lba > Instance->Media.LastBlock) {\r
- DEBUG ((DEBUG_ERROR, "FvbGetBlockSize: ERROR - Parameter LBA %ld is beyond the last Lba (%ld).\n", Lba, Instance->Media.LastBlock));\r
- Status = EFI_INVALID_PARAMETER;\r
- } else {\r
- // This is easy because in this platform each NorFlash device has equal sized blocks.\r
- *BlockSize = (UINTN)Instance->Media.BlockSize;\r
- *NumberOfBlocks = (UINTN)(Instance->Media.LastBlock - Lba + 1);\r
-\r
- DEBUG ((DEBUG_BLKIO, "FvbGetBlockSize: *BlockSize=0x%x, *NumberOfBlocks=0x%x.\n", *BlockSize, *NumberOfBlocks));\r
-\r
- Status = EFI_SUCCESS;\r
- }\r
-\r
- return Status;\r
-}\r
-\r
-/**\r
- Reads the specified number of bytes into a buffer from the specified block.\r
-\r
- The Read() function reads the requested number of bytes from the\r
- requested block and stores them in the provided buffer.\r
- Implementations should be mindful that the firmware volume\r
- might be in the ReadDisabled state. If it is in this state,\r
- the Read() function must return the status code\r
- EFI_ACCESS_DENIED without modifying the contents of the\r
- buffer. The Read() function must also prevent spanning block\r
- boundaries. If a read is requested that would span a block\r
- boundary, the read must read up to the boundary but not\r
- beyond. The output parameter NumBytes must be set to correctly\r
- indicate the number of bytes actually read. The caller must be\r
- aware that a read may be partially completed.\r
-\r
- @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.\r
-\r
- @param Lba The starting logical block index from which to read.\r
-\r
- @param Offset Offset into the block at which to begin reading.\r
-\r
- @param NumBytes Pointer to a UINTN.\r
- At entry, *NumBytes contains the total size of the buffer.\r
- At exit, *NumBytes contains the total number of bytes read.\r
-\r
- @param Buffer Pointer to a caller-allocated buffer that will be used\r
- to hold the data that is read.\r
-\r
- @retval EFI_SUCCESS The firmware volume was read successfully, and contents are\r
- in Buffer.\r
-\r
- @retval EFI_BAD_BUFFER_SIZE Read attempted across an LBA boundary.\r
- On output, NumBytes contains the total number of bytes\r
- returned in Buffer.\r
-\r
- @retval EFI_ACCESS_DENIED The firmware volume is in the ReadDisabled state.\r
-\r
- @retval EFI_DEVICE_ERROR The block device is not functioning correctly and could not be read.\r
-\r
- **/\r
-EFI_STATUS\r
-EFIAPI\r
-FvbRead (\r
- IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,\r
- IN EFI_LBA Lba,\r
- IN UINTN Offset,\r
- IN OUT UINTN *NumBytes,\r
- IN OUT UINT8 *Buffer\r
- )\r
-{\r
- EFI_STATUS TempStatus;\r
- UINTN BlockSize;\r
- NOR_FLASH_INSTANCE *Instance;\r
-\r
- Instance = INSTANCE_FROM_FVB_THIS (This);\r
-\r
- DEBUG ((DEBUG_BLKIO, "FvbRead(Parameters: Lba=%ld, Offset=0x%x, *NumBytes=0x%x, Buffer @ 0x%08x)\n", Instance->StartLba + Lba, Offset, *NumBytes, Buffer));\r
-\r
- TempStatus = EFI_SUCCESS;\r
-\r
- // Cache the block size to avoid de-referencing pointers all the time\r
- BlockSize = Instance->Media.BlockSize;\r
-\r
- DEBUG ((DEBUG_BLKIO, "FvbRead: Check if (Offset=0x%x + NumBytes=0x%x) <= BlockSize=0x%x\n", Offset, *NumBytes, BlockSize));\r
-\r
- // The read must not span block boundaries.\r
- // We need to check each variable individually because adding two large values together overflows.\r
- if ((Offset >= BlockSize) ||\r
- (*NumBytes > BlockSize) ||\r
- ((Offset + *NumBytes) > BlockSize))\r
- {\r
- DEBUG ((DEBUG_ERROR, "FvbRead: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", Offset, *NumBytes, BlockSize));\r
- return EFI_BAD_BUFFER_SIZE;\r
- }\r
-\r
- // We must have some bytes to read\r
- if (*NumBytes == 0) {\r
- return EFI_BAD_BUFFER_SIZE;\r
- }\r
-\r
- // Decide if we are doing full block reads or not.\r
- if (*NumBytes % BlockSize != 0) {\r
- TempStatus = NorFlashRead (Instance, Instance->StartLba + Lba, Offset, *NumBytes, Buffer);\r
- if (EFI_ERROR (TempStatus)) {\r
- return EFI_DEVICE_ERROR;\r
- }\r
- } else {\r
- // Read NOR Flash data into shadow buffer\r
- TempStatus = NorFlashReadBlocks (Instance, Instance->StartLba + Lba, BlockSize, Buffer);\r
- if (EFI_ERROR (TempStatus)) {\r
- // Return one of the pre-approved error statuses\r
- return EFI_DEVICE_ERROR;\r
- }\r
- }\r
-\r
- return EFI_SUCCESS;\r
-}\r
-\r
-/**\r
- Writes the specified number of bytes from the input buffer to the block.\r
-\r
- The Write() function writes the specified number of bytes from\r
- the provided buffer to the specified block and offset. If the\r
- firmware volume is sticky write, the caller must ensure that\r
- all the bits of the specified range to write are in the\r
- EFI_FVB_ERASE_POLARITY state before calling the Write()\r
- function, or else the result will be unpredictable. This\r
- unpredictability arises because, for a sticky-write firmware\r
- volume, a write may negate a bit in the EFI_FVB_ERASE_POLARITY\r
- state but cannot flip it back again. Before calling the\r
- Write() function, it is recommended for the caller to first call\r
- the EraseBlocks() function to erase the specified block to\r
- write. A block erase cycle will transition bits from the\r
- (NOT)EFI_FVB_ERASE_POLARITY state back to the\r
- EFI_FVB_ERASE_POLARITY state. Implementations should be\r
- mindful that the firmware volume might be in the WriteDisabled\r
- state. If it is in this state, the Write() function must\r
- return the status code EFI_ACCESS_DENIED without modifying the\r
- contents of the firmware volume. The Write() function must\r
- also prevent spanning block boundaries. If a write is\r
- requested that spans a block boundary, the write must store up\r
- to the boundary but not beyond. The output parameter NumBytes\r
- must be set to correctly indicate the number of bytes actually\r
- written. The caller must be aware that a write may be\r
- partially completed. All writes, partial or otherwise, must be\r
- fully flushed to the hardware before the Write() service\r
- returns.\r
-\r
- @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.\r
-\r
- @param Lba The starting logical block index to write to.\r
-\r
- @param Offset Offset into the block at which to begin writing.\r
-\r
- @param NumBytes The pointer to a UINTN.\r
- At entry, *NumBytes contains the total size of the buffer.\r
- At exit, *NumBytes contains the total number of bytes actually written.\r
-\r
- @param Buffer The pointer to a caller-allocated buffer that contains the source for the write.\r
-\r
- @retval EFI_SUCCESS The firmware volume was written successfully.\r
-\r
- @retval EFI_BAD_BUFFER_SIZE The write was attempted across an LBA boundary.\r
- On output, NumBytes contains the total number of bytes\r
- actually written.\r
-\r
- @retval EFI_ACCESS_DENIED The firmware volume is in the WriteDisabled state.\r
-\r
- @retval EFI_DEVICE_ERROR The block device is malfunctioning and could not be written.\r
-\r
-\r
- **/\r
-EFI_STATUS\r
-EFIAPI\r
-FvbWrite (\r
- IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,\r
- IN EFI_LBA Lba,\r
- IN UINTN Offset,\r
- IN OUT UINTN *NumBytes,\r
- IN UINT8 *Buffer\r
- )\r
-{\r
- NOR_FLASH_INSTANCE *Instance;\r
-\r
- Instance = INSTANCE_FROM_FVB_THIS (This);\r
-\r
- return NorFlashWriteSingleBlock (Instance, Instance->StartLba + Lba, Offset, NumBytes, Buffer);\r
-}\r
-\r
-/**\r
- Erases and initialises a firmware volume block.\r
-\r
- The EraseBlocks() function erases one or more blocks as denoted\r
- by the variable argument list. The entire parameter list of\r
- blocks must be verified before erasing any blocks. If a block is\r
- requested that does not exist within the associated firmware\r
- volume (it has a larger index than the last block of the\r
- firmware volume), the EraseBlocks() function must return the\r
- status code EFI_INVALID_PARAMETER without modifying the contents\r
- of the firmware volume. Implementations should be mindful that\r
- the firmware volume might be in the WriteDisabled state. If it\r
- is in this state, the EraseBlocks() function must return the\r
- status code EFI_ACCESS_DENIED without modifying the contents of\r
- the firmware volume. All calls to EraseBlocks() must be fully\r
- flushed to the hardware before the EraseBlocks() service\r
- returns.\r
-\r
- @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL\r
- instance.\r
-\r
- @param ... The variable argument list is a list of tuples.\r
- Each tuple describes a range of LBAs to erase\r
- and consists of the following:\r
- - An EFI_LBA that indicates the starting LBA\r
- - A UINTN that indicates the number of blocks to erase.\r
-\r
- The list is terminated with an EFI_LBA_LIST_TERMINATOR.\r
- For example, the following indicates that two ranges of blocks\r
- (5-7 and 10-11) are to be erased:\r
- EraseBlocks (This, 5, 3, 10, 2, EFI_LBA_LIST_TERMINATOR);\r
-\r
- @retval EFI_SUCCESS The erase request successfully completed.\r
-\r
- @retval EFI_ACCESS_DENIED The firmware volume is in the WriteDisabled state.\r
-\r
- @retval EFI_DEVICE_ERROR The block device is not functioning correctly and could not be written.\r
- The firmware device may have been partially erased.\r
-\r
- @retval EFI_INVALID_PARAMETER One or more of the LBAs listed in the variable argument list do\r
- not exist in the firmware volume.\r
-\r
- **/\r
-EFI_STATUS\r
-EFIAPI\r
-FvbEraseBlocks (\r
- IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,\r
- ...\r
- )\r
-{\r
- EFI_STATUS Status;\r
- VA_LIST Args;\r
- UINTN BlockAddress; // Physical address of Lba to erase\r
- EFI_LBA StartingLba; // Lba from which we start erasing\r
- UINTN NumOfLba; // Number of Lba blocks to erase\r
- NOR_FLASH_INSTANCE *Instance;\r
-\r
- Instance = INSTANCE_FROM_FVB_THIS (This);\r
-\r
- DEBUG ((DEBUG_BLKIO, "FvbEraseBlocks()\n"));\r
-\r
- Status = EFI_SUCCESS;\r
-\r
- // Detect WriteDisabled state\r
- if (Instance->Media.ReadOnly == TRUE) {\r
- // Firmware volume is in WriteDisabled state\r
- DEBUG ((DEBUG_ERROR, "FvbEraseBlocks: ERROR - Device is in WriteDisabled state.\n"));\r
- return EFI_ACCESS_DENIED;\r
- }\r
-\r
- // Before erasing, check the entire list of parameters to ensure all specified blocks are valid\r
-\r
- VA_START (Args, This);\r
- do {\r
- // Get the Lba from which we start erasing\r
- StartingLba = VA_ARG (Args, EFI_LBA);\r
-\r
- // Have we reached the end of the list?\r
- if (StartingLba == EFI_LBA_LIST_TERMINATOR) {\r
- // Exit the while loop\r
- break;\r
- }\r
-\r
- // How many Lba blocks are we requested to erase?\r
- NumOfLba = VA_ARG (Args, UINTN);\r
-\r
- // All blocks must be within range\r
- DEBUG ((\r
- DEBUG_BLKIO,\r
- "FvbEraseBlocks: Check if: ( StartingLba=%ld + NumOfLba=%Lu - 1 ) > LastBlock=%ld.\n",\r
- Instance->StartLba + StartingLba,\r
- (UINT64)NumOfLba,\r
- Instance->Media.LastBlock\r
- ));\r
- if ((NumOfLba == 0) || ((Instance->StartLba + StartingLba + NumOfLba - 1) > Instance->Media.LastBlock)) {\r
- VA_END (Args);\r
- DEBUG ((DEBUG_ERROR, "FvbEraseBlocks: ERROR - Lba range goes past the last Lba.\n"));\r
- Status = EFI_INVALID_PARAMETER;\r
- goto EXIT;\r
- }\r
- } while (TRUE);\r
-\r
- VA_END (Args);\r
-\r
- //\r
- // To get here, all must be ok, so start erasing\r
- //\r
- VA_START (Args, This);\r
- do {\r
- // Get the Lba from which we start erasing\r
- StartingLba = VA_ARG (Args, EFI_LBA);\r
-\r
- // Have we reached the end of the list?\r
- if (StartingLba == EFI_LBA_LIST_TERMINATOR) {\r
- // Exit the while loop\r
- break;\r
- }\r
-\r
- // How many Lba blocks are we requested to erase?\r
- NumOfLba = VA_ARG (Args, UINTN);\r
-\r
- // Go through each one and erase it\r
- while (NumOfLba > 0) {\r
- // Get the physical address of Lba to erase\r
- BlockAddress = GET_NOR_BLOCK_ADDRESS (\r
- Instance->RegionBaseAddress,\r
- Instance->StartLba + StartingLba,\r
- Instance->Media.BlockSize\r
- );\r
-\r
- // Erase it\r
- DEBUG ((DEBUG_BLKIO, "FvbEraseBlocks: Erasing Lba=%ld @ 0x%08x.\n", Instance->StartLba + StartingLba, BlockAddress));\r
- Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress);\r
- if (EFI_ERROR (Status)) {\r
- VA_END (Args);\r
- Status = EFI_DEVICE_ERROR;\r
- goto EXIT;\r
- }\r
-\r
- // Move to the next Lba\r
- StartingLba++;\r
- NumOfLba--;\r
- }\r
- } while (TRUE);\r
-\r
- VA_END (Args);\r
-\r
-EXIT:\r
- return Status;\r
-}\r
-\r
-/**\r
- Fixup internal data so that EFI can be call in virtual mode.\r
- Call the passed in Child Notify event and convert any pointers in\r
- lib to virtual mode.\r
-\r
- @param[in] Event The Event that is being processed\r
- @param[in] Context Event Context\r
-**/\r
-VOID\r
-EFIAPI\r
-FvbVirtualNotifyEvent (\r
- IN EFI_EVENT Event,\r
- IN VOID *Context\r
- )\r
-{\r
- EfiConvertPointer (0x0, (VOID **)&mFlashNvStorageVariableBase);\r
- return;\r
-}\r
+++ /dev/null
-/** @file NorFlashStandaloneMm.c\r
-\r
- Copyright (c) 2011 - 2021, Arm Limited. All rights reserved.<BR>\r
- Copyright (c) 2020, Linaro, Ltd. All rights reserved.<BR>\r
-\r
- SPDX-License-Identifier: BSD-2-Clause-Patent\r
-\r
-**/\r
-\r
-#include <Library/BaseMemoryLib.h>\r
-#include <Library/MemoryAllocationLib.h>\r
-#include <Library/MmServicesTableLib.h>\r
-\r
-#include "NorFlash.h"\r
-\r
-//\r
-// Global variable declarations\r
-//\r
-NOR_FLASH_INSTANCE **mNorFlashInstances;\r
-UINT32 mNorFlashDeviceCount;\r
-UINTN mFlashNvStorageVariableBase;\r
-\r
-NOR_FLASH_INSTANCE mNorFlashInstanceTemplate = {\r
- NOR_FLASH_SIGNATURE, // Signature\r
- NULL, // Handle ... NEED TO BE FILLED\r
-\r
- 0, // DeviceBaseAddress ... NEED TO BE FILLED\r
- 0, // RegionBaseAddress ... NEED TO BE FILLED\r
- 0, // Size ... NEED TO BE FILLED\r
- 0, // StartLba\r
-\r
- {\r
- EFI_BLOCK_IO_PROTOCOL_REVISION2, // Revision\r
- NULL, // Media ... NEED TO BE FILLED\r
- NULL, // Reset;\r
- NULL, // ReadBlocks\r
- NULL, // WriteBlocks\r
- NULL // FlushBlocks\r
- }, // BlockIoProtocol\r
-\r
- {\r
- 0, // MediaId ... NEED TO BE FILLED\r
- FALSE, // RemovableMedia\r
- TRUE, // MediaPresent\r
- FALSE, // LogicalPartition\r
- FALSE, // ReadOnly\r
- FALSE, // WriteCaching;\r
- 0, // BlockSize ... NEED TO BE FILLED\r
- 4, // IoAlign\r
- 0, // LastBlock ... NEED TO BE FILLED\r
- 0, // LowestAlignedLba\r
- 1, // LogicalBlocksPerPhysicalBlock\r
- }, // Media;\r
-\r
- {\r
- EFI_DISK_IO_PROTOCOL_REVISION, // Revision\r
- NULL, // ReadDisk\r
- NULL // WriteDisk\r
- },\r
-\r
- {\r
- FvbGetAttributes, // GetAttributes\r
- FvbSetAttributes, // SetAttributes\r
- FvbGetPhysicalAddress, // GetPhysicalAddress\r
- FvbGetBlockSize, // GetBlockSize\r
- FvbRead, // Read\r
- FvbWrite, // Write\r
- FvbEraseBlocks, // EraseBlocks\r
- NULL, // ParentHandle\r
- }, // FvbProtoccol;\r
- NULL, // ShadowBuffer\r
- {\r
- {\r
- {\r
- HARDWARE_DEVICE_PATH,\r
- HW_VENDOR_DP,\r
- {\r
- (UINT8)(OFFSET_OF (NOR_FLASH_DEVICE_PATH, End)),\r
- (UINT8)(OFFSET_OF (NOR_FLASH_DEVICE_PATH, End) >> 8)\r
- }\r
- },\r
- { 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }\r
- }, // GUID ... NEED TO BE FILLED\r
- },\r
- 0, // Index\r
- {\r
- END_DEVICE_PATH_TYPE,\r
- END_ENTIRE_DEVICE_PATH_SUBTYPE,\r
- { sizeof (EFI_DEVICE_PATH_PROTOCOL), 0 }\r
- }\r
- } // DevicePath\r
-};\r
-\r
-EFI_STATUS\r
-NorFlashCreateInstance (\r
- IN UINTN NorFlashDeviceBase,\r
- IN UINTN NorFlashRegionBase,\r
- IN UINTN NorFlashSize,\r
- IN UINT32 Index,\r
- IN UINT32 BlockSize,\r
- IN BOOLEAN SupportFvb,\r
- OUT NOR_FLASH_INSTANCE **NorFlashInstance\r
- )\r
-{\r
- EFI_STATUS Status;\r
- NOR_FLASH_INSTANCE *Instance;\r
-\r
- ASSERT (NorFlashInstance != NULL);\r
-\r
- Instance = AllocateRuntimeCopyPool (sizeof (NOR_FLASH_INSTANCE), &mNorFlashInstanceTemplate);\r
- if (Instance == NULL) {\r
- return EFI_OUT_OF_RESOURCES;\r
- }\r
-\r
- Instance->DeviceBaseAddress = NorFlashDeviceBase;\r
- Instance->RegionBaseAddress = NorFlashRegionBase;\r
- Instance->Size = NorFlashSize;\r
-\r
- Instance->BlockIoProtocol.Media = &Instance->Media;\r
- Instance->Media.MediaId = Index;\r
- Instance->Media.BlockSize = BlockSize;\r
- Instance->Media.LastBlock = (NorFlashSize / BlockSize)-1;\r
-\r
- CopyGuid (&Instance->DevicePath.Vendor.Guid, &gEfiCallerIdGuid);\r
- Instance->DevicePath.Index = (UINT8)Index;\r
-\r
- Instance->ShadowBuffer = AllocateRuntimePool (BlockSize);\r
- if (Instance->ShadowBuffer == NULL) {\r
- return EFI_OUT_OF_RESOURCES;\r
- }\r
-\r
- if (SupportFvb) {\r
- NorFlashFvbInitialize (Instance);\r
-\r
- Status = gMmst->MmInstallProtocolInterface (\r
- &Instance->Handle,\r
- &gEfiSmmFirmwareVolumeBlockProtocolGuid,\r
- EFI_NATIVE_INTERFACE,\r
- &Instance->FvbProtocol\r
- );\r
- if (EFI_ERROR (Status)) {\r
- FreePool (Instance);\r
- return Status;\r
- }\r
- } else {\r
- DEBUG ((DEBUG_ERROR, "standalone MM NOR Flash driver only support FVB.\n"));\r
- FreePool (Instance);\r
- return EFI_UNSUPPORTED;\r
- }\r
-\r
- *NorFlashInstance = Instance;\r
- return Status;\r
-}\r
-\r
-/**\r
- * This function unlock and erase an entire NOR Flash block.\r
- **/\r
-EFI_STATUS\r
-NorFlashUnlockAndEraseSingleBlock (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN BlockAddress\r
- )\r
-{\r
- EFI_STATUS Status;\r
- UINTN Index;\r
-\r
- Index = 0;\r
- // The block erase might fail a first time (SW bug ?). Retry it ...\r
- do {\r
- // Unlock the block if we have to\r
- Status = NorFlashUnlockSingleBlockIfNecessary (Instance, BlockAddress);\r
- if (EFI_ERROR (Status)) {\r
- break;\r
- }\r
-\r
- Status = NorFlashEraseSingleBlock (Instance, BlockAddress);\r
- Index++;\r
- } while ((Index < NOR_FLASH_ERASE_RETRY) && (Status == EFI_WRITE_PROTECTED));\r
-\r
- if (Index == NOR_FLASH_ERASE_RETRY) {\r
- DEBUG ((DEBUG_ERROR, "EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error (try to erase %d times)\n", BlockAddress, Index));\r
- }\r
-\r
- return Status;\r
-}\r
-\r
-EFI_STATUS\r
-NorFlashWriteFullBlock (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN EFI_LBA Lba,\r
- IN UINT32 *DataBuffer,\r
- IN UINT32 BlockSizeInWords\r
- )\r
-{\r
- EFI_STATUS Status;\r
- UINTN WordAddress;\r
- UINT32 WordIndex;\r
- UINTN BufferIndex;\r
- UINTN BlockAddress;\r
- UINTN BuffersInBlock;\r
- UINTN RemainingWords;\r
- UINTN Cnt;\r
-\r
- Status = EFI_SUCCESS;\r
-\r
- // Get the physical address of the block\r
- BlockAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, Lba, BlockSizeInWords * 4);\r
-\r
- // Start writing from the first address at the start of the block\r
- WordAddress = BlockAddress;\r
-\r
- Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress);\r
- if (EFI_ERROR (Status)) {\r
- DEBUG ((DEBUG_ERROR, "WriteSingleBlock: ERROR - Failed to Unlock and Erase the single block at 0x%X\n", BlockAddress));\r
- goto EXIT;\r
- }\r
-\r
- // To speed up the programming operation, NOR Flash is programmed using the Buffered Programming method.\r
-\r
- // Check that the address starts at a 32-word boundary, i.e. last 7 bits must be zero\r
- if ((WordAddress & BOUNDARY_OF_32_WORDS) == 0x00) {\r
- // First, break the entire block into buffer-sized chunks.\r
- BuffersInBlock = (UINTN)(BlockSizeInWords * 4) / P30_MAX_BUFFER_SIZE_IN_BYTES;\r
-\r
- // Then feed each buffer chunk to the NOR Flash\r
- // If a buffer does not contain any data, don't write it.\r
- for (BufferIndex = 0;\r
- BufferIndex < BuffersInBlock;\r
- BufferIndex++, WordAddress += P30_MAX_BUFFER_SIZE_IN_BYTES, DataBuffer += P30_MAX_BUFFER_SIZE_IN_WORDS\r
- )\r
- {\r
- // Check the buffer to see if it contains any data (not set all 1s).\r
- for (Cnt = 0; Cnt < P30_MAX_BUFFER_SIZE_IN_WORDS; Cnt++) {\r
- if (~DataBuffer[Cnt] != 0 ) {\r
- // Some data found, write the buffer.\r
- Status = NorFlashWriteBuffer (\r
- Instance,\r
- WordAddress,\r
- P30_MAX_BUFFER_SIZE_IN_BYTES,\r
- DataBuffer\r
- );\r
- if (EFI_ERROR (Status)) {\r
- goto EXIT;\r
- }\r
-\r
- break;\r
- }\r
- }\r
- }\r
-\r
- // Finally, finish off any remaining words that are less than the maximum size of the buffer\r
- RemainingWords = BlockSizeInWords % P30_MAX_BUFFER_SIZE_IN_WORDS;\r
-\r
- if (RemainingWords != 0) {\r
- Status = NorFlashWriteBuffer (Instance, WordAddress, (RemainingWords * 4), DataBuffer);\r
- if (EFI_ERROR (Status)) {\r
- goto EXIT;\r
- }\r
- }\r
- } else {\r
- // For now, use the single word programming algorithm\r
- // It is unlikely that the NOR Flash will exist in an address which falls within a 32 word boundary range,\r
- // i.e. which ends in the range 0x......01 - 0x......7F.\r
- for (WordIndex = 0; WordIndex < BlockSizeInWords; WordIndex++, DataBuffer++, WordAddress = WordAddress + 4) {\r
- Status = NorFlashWriteSingleWord (Instance, WordAddress, *DataBuffer);\r
- if (EFI_ERROR (Status)) {\r
- goto EXIT;\r
- }\r
- }\r
- }\r
-\r
-EXIT:\r
- if (EFI_ERROR (Status)) {\r
- DEBUG ((DEBUG_ERROR, "NOR FLASH Programming [WriteSingleBlock] failed at address 0x%08x. Exit Status = \"%r\".\n", WordAddress, Status));\r
- }\r
-\r
- return Status;\r
-}\r
-\r
-EFI_STATUS\r
-EFIAPI\r
-NorFlashInitialise (\r
- IN EFI_HANDLE ImageHandle,\r
- IN EFI_MM_SYSTEM_TABLE *MmSystemTable\r
- )\r
-{\r
- EFI_STATUS Status;\r
- UINT32 Index;\r
- NOR_FLASH_DESCRIPTION *NorFlashDevices;\r
- BOOLEAN ContainVariableStorage;\r
-\r
- Status = NorFlashPlatformInitialization ();\r
- if (EFI_ERROR (Status)) {\r
- DEBUG ((DEBUG_ERROR, "NorFlashInitialise: Fail to initialize Nor Flash devices\n"));\r
- return Status;\r
- }\r
-\r
- Status = NorFlashPlatformGetDevices (&NorFlashDevices, &mNorFlashDeviceCount);\r
- if (EFI_ERROR (Status)) {\r
- DEBUG ((DEBUG_ERROR, "NorFlashInitialise: Fail to get Nor Flash devices\n"));\r
- return Status;\r
- }\r
-\r
- mNorFlashInstances = AllocatePool (sizeof (NOR_FLASH_INSTANCE *) * mNorFlashDeviceCount);\r
-\r
- for (Index = 0; Index < mNorFlashDeviceCount; Index++) {\r
- // Check if this NOR Flash device contain the variable storage region\r
-\r
- if (FixedPcdGet64 (PcdFlashNvStorageVariableBase64) != 0) {\r
- ContainVariableStorage =\r
- (NorFlashDevices[Index].RegionBaseAddress <= FixedPcdGet64 (PcdFlashNvStorageVariableBase64)) &&\r
- (FixedPcdGet64 (PcdFlashNvStorageVariableBase64) + FixedPcdGet32 (PcdFlashNvStorageVariableSize) <=\r
- NorFlashDevices[Index].RegionBaseAddress + NorFlashDevices[Index].Size);\r
- } else {\r
- ContainVariableStorage =\r
- (NorFlashDevices[Index].RegionBaseAddress <= FixedPcdGet32 (PcdFlashNvStorageVariableBase)) &&\r
- (FixedPcdGet32 (PcdFlashNvStorageVariableBase) + FixedPcdGet32 (PcdFlashNvStorageVariableSize) <=\r
- NorFlashDevices[Index].RegionBaseAddress + NorFlashDevices[Index].Size);\r
- }\r
-\r
- Status = NorFlashCreateInstance (\r
- NorFlashDevices[Index].DeviceBaseAddress,\r
- NorFlashDevices[Index].RegionBaseAddress,\r
- NorFlashDevices[Index].Size,\r
- Index,\r
- NorFlashDevices[Index].BlockSize,\r
- ContainVariableStorage,\r
- &mNorFlashInstances[Index]\r
- );\r
- if (EFI_ERROR (Status)) {\r
- DEBUG ((DEBUG_ERROR, "NorFlashInitialise: Fail to create instance for NorFlash[%d]\n", Index));\r
- }\r
- }\r
-\r
- return Status;\r
-}\r
-\r
-EFI_STATUS\r
-EFIAPI\r
-NorFlashFvbInitialize (\r
- IN NOR_FLASH_INSTANCE *Instance\r
- )\r
-{\r
- EFI_STATUS Status;\r
- UINT32 FvbNumLba;\r
-\r
- ASSERT ((Instance != NULL));\r
-\r
- mFlashNvStorageVariableBase = (FixedPcdGet64 (PcdFlashNvStorageVariableBase64) != 0) ?\r
- FixedPcdGet64 (PcdFlashNvStorageVariableBase64) : FixedPcdGet32 (PcdFlashNvStorageVariableBase);\r
- // Set the index of the first LBA for the FVB\r
- Instance->StartLba = (mFlashNvStorageVariableBase - Instance->RegionBaseAddress) / Instance->Media.BlockSize;\r
-\r
- // Determine if there is a valid header at the beginning of the NorFlash\r
- Status = ValidateFvHeader (Instance);\r
-\r
- // Install the Default FVB header if required\r
- if (EFI_ERROR (Status)) {\r
- // There is no valid header, so time to install one.\r
- DEBUG ((DEBUG_INFO, "%a: The FVB Header is not valid.\n", __FUNCTION__));\r
- DEBUG ((\r
- DEBUG_INFO,\r
- "%a: Installing a correct one for this volume.\n",\r
- __FUNCTION__\r
- ));\r
-\r
- // Erase all the NorFlash that is reserved for variable storage\r
- FvbNumLba = (PcdGet32 (PcdFlashNvStorageVariableSize) + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) + PcdGet32 (PcdFlashNvStorageFtwSpareSize)) / Instance->Media.BlockSize;\r
-\r
- Status = FvbEraseBlocks (&Instance->FvbProtocol, (EFI_LBA)0, FvbNumLba, EFI_LBA_LIST_TERMINATOR);\r
- if (EFI_ERROR (Status)) {\r
- return Status;\r
- }\r
-\r
- // Install all appropriate headers\r
- Status = InitializeFvAndVariableStoreHeaders (Instance);\r
- if (EFI_ERROR (Status)) {\r
- return Status;\r
- }\r
- }\r
-\r
- return Status;\r
-}\r
+++ /dev/null
-#/** @file\r
-#\r
-# Component description file for NorFlashStandaloneMm module\r
-#\r
-# Copyright (c) 2011 - 2021, Arm Limited. All rights reserved.<BR>\r
-# Copyright (c) 2020, Linaro, Ltd. All rights reserved.<BR>\r
-#\r
-# SPDX-License-Identifier: BSD-2-Clause-Patent\r
-#\r
-#**/\r
-\r
-[Defines]\r
- INF_VERSION = 0x00010005\r
- BASE_NAME = ArmVeNorFlashStandaloneMm\r
- FILE_GUID = e67d82ad-cd56-4071-9151-95ee44990bb0\r
- MODULE_TYPE = MM_STANDALONE\r
- VERSION_STRING = 1.0\r
- PI_SPECIFICATION_VERSION = 0x00010032\r
- ENTRY_POINT = NorFlashInitialise\r
-\r
-[Sources.common]\r
- NorFlash.h\r
- NorFlash.c\r
- NorFlashStandaloneMm.c\r
- NorFlashFvb.c\r
-\r
-[Packages]\r
- MdePkg/MdePkg.dec\r
- MdeModulePkg/MdeModulePkg.dec\r
- ArmPlatformPkg/ArmPlatformPkg.dec\r
- EmbeddedPkg/EmbeddedPkg.dec\r
-\r
-[LibraryClasses]\r
- BaseLib\r
- BaseMemoryLib\r
- DebugLib\r
- IoLib\r
- MemoryAllocationLib\r
- MmServicesTableLib\r
- NorFlashPlatformLib\r
- StandaloneMmDriverEntryPoint\r
-\r
-[Guids]\r
- gEfiSystemNvDataFvGuid\r
- gEfiVariableGuid\r
- gEfiAuthenticatedVariableGuid\r
-\r
-[Protocols]\r
- gEfiSmmFirmwareVolumeBlockProtocolGuid\r
-\r
-[FixedPcd]\r
- gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase64\r
- gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase\r
- gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableSize\r
- gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingBase64\r
- gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingBase\r
- gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingSize\r
- gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareBase64\r
- gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareBase\r
- gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareSize\r
-\r
-[FeaturePcd]\r
- gArmPlatformTokenSpaceGuid.PcdNorFlashCheckBlockLocked\r
-\r
-[Depex]\r
- TRUE\r
+++ /dev/null
-/** @file\r
-\r
- Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>\r
-\r
- SPDX-License-Identifier: BSD-2-Clause-Patent\r
-\r
- **/\r
-\r
-#ifndef _NORFLASHPLATFORMLIB_H_\r
-#define _NORFLASHPLATFORMLIB_H_\r
-\r
-typedef struct {\r
- UINTN DeviceBaseAddress; // Start address of the Device Base Address (DBA)\r
- UINTN RegionBaseAddress; // Start address of one single region\r
- UINTN Size;\r
- UINTN BlockSize;\r
-} NOR_FLASH_DESCRIPTION;\r
-\r
-EFI_STATUS\r
-NorFlashPlatformInitialization (\r
- VOID\r
- );\r
-\r
-EFI_STATUS\r
-NorFlashPlatformGetDevices (\r
- OUT NOR_FLASH_DESCRIPTION **NorFlashDescriptions,\r
- OUT UINT32 *Count\r
- );\r
-\r
-#endif /* _NORFLASHPLATFORMLIB_H_ */\r
+++ /dev/null
-/** @file\r
-\r
- Copyright (c) 2014, Linaro Ltd. All rights reserved.<BR>\r
-\r
- SPDX-License-Identifier: BSD-2-Clause-Patent\r
-\r
- **/\r
-\r
-#include <Library/NorFlashPlatformLib.h>\r
-\r
-EFI_STATUS\r
-NorFlashPlatformInitialization (\r
- VOID\r
- )\r
-{\r
- return EFI_SUCCESS;\r
-}\r
-\r
-EFI_STATUS\r
-NorFlashPlatformGetDevices (\r
- OUT NOR_FLASH_DESCRIPTION **NorFlashDescriptions,\r
- OUT UINT32 *Count\r
- )\r
-{\r
- *NorFlashDescriptions = NULL;\r
- *Count = 0;\r
- return EFI_SUCCESS;\r
-}\r
+++ /dev/null
-#/** @file\r
-#\r
-# Component description file for NorFlashPlatformNullLib module\r
-#\r
-# Copyright (c) 2017, Linaro Ltd. All rights reserved.<BR>\r
-#\r
-# SPDX-License-Identifier: BSD-2-Clause-Patent\r
-#\r
-#**/\r
-\r
-[Defines]\r
- INF_VERSION = 0x00010005\r
- BASE_NAME = NorFlashPlatformNullLib\r
- FILE_GUID = 29b733ad-d066-4df6-8a89-b9df1beb818a\r
- MODULE_TYPE = DXE_DRIVER\r
- VERSION_STRING = 1.0\r
- LIBRARY_CLASS = NorFlashPlatformLib\r
-\r
-[Sources.common]\r
- NorFlashPlatformNullLib.c\r
-\r
-[Packages]\r
- MdePkg/MdePkg.dec\r
- ArmPlatformPkg/ArmPlatformPkg.dec\r