--- /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
+/**\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
+\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
+\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
+\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
+\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
+ while (Length-- != 0) {\r
+ *Destination8++ = *Source8++;\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((DEBUG_BLKIO, "NorFlashReadBlocks: BufferSize=0x%xB BlockSize=0x%xB LastBlock=%ld, Lba=%ld.\n",\r
+ BufferSizeInBytes, Instance->Media.BlockSize, Instance->Media.LastBlock, Lba));\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 (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 (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
+ 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 (Instance->RegionBaseAddress,\r
+ Lba, BlockSize);\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
+ // 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
+ // 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
+ // 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
+ // 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
+ PrevBlockAddress = BlockAddress;\r
+ }\r
+ TempStatus = NorFlashWriteSingleWord (Instance, WordAddr, WordToWrite);\r
+ if (EFI_ERROR (TempStatus)) {\r
+ return EFI_DEVICE_ERROR;\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
+ if (EFI_ERROR (Status)) {\r
+ return Status;\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
+\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
+//\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
#include <Library/BaseMemoryLib.h>\r
#include <Library/UefiBootServicesTableLib.h>\r
\r
-#include "NorFlashDxe.h"\r
+#include "NorFlash.h"\r
\r
//\r
// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.Reset\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 "NorFlashDxe.h"\r
+#include "NorFlash.h"\r
\r
STATIC EFI_EVENT mNorFlashVirtualAddrChangeEvent;\r
\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
return Status;\r
}\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((EFI_D_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
-STATIC\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
-/**\r
- * The following function presumes that the block has already been unlocked.\r
- **/\r
-STATIC\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((EFI_D_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((EFI_D_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((EFI_D_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((EFI_D_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
/**\r
* This function unlock and erase an entire NOR Flash block.\r
**/\r
return Status;\r
}\r
\r
-\r
-STATIC\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
-\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((EFI_D_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((EFI_D_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((EFI_D_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
-\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
-\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((EFI_D_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((EFI_D_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((EFI_D_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
-STATIC\r
EFI_STATUS\r
NorFlashWriteFullBlock (\r
IN NOR_FLASH_INSTANCE *Instance,\r
return Status;\r
}\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((EFI_D_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
-\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
- while (Length-- != 0) {\r
- *Destination8++ = *Source8++;\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((DEBUG_BLKIO, "NorFlashReadBlocks: BufferSize=0x%xB BlockSize=0x%xB LastBlock=%ld, Lba=%ld.\n",\r
- BufferSizeInBytes, Instance->Media.BlockSize, Instance->Media.LastBlock, Lba));\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((EFI_D_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 (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 ((EFI_D_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 (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 ((EFI_D_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
- DEBUG ((EFI_D_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 ((EFI_D_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 (Instance->RegionBaseAddress,\r
- Lba, BlockSize);\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
- // 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
- // 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
- // 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
- // 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
- PrevBlockAddress = BlockAddress;\r
- }\r
- TempStatus = NorFlashWriteSingleWord (Instance, WordAddr, WordToWrite);\r
- if (EFI_ERROR (TempStatus)) {\r
- return EFI_DEVICE_ERROR;\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 ((EFI_D_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
- if (EFI_ERROR (Status)) {\r
- return Status;\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
-\r
EFI_STATUS\r
EFIAPI\r
NorFlashInitialise (\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, RuntimeMmioRegionSize,\r
+ EFI_MEMORY_UC | EFI_MEMORY_RUNTIME\r
+ );\r
+ ASSERT_EFI_ERROR (Status);\r
+\r
+ Status = gDS->SetMemorySpaceAttributes (\r
+ Instance->DeviceBaseAddress, RuntimeMmioRegionSize,\r
+ EFI_MEMORY_UC | EFI_MEMORY_RUNTIME);\r
+ ASSERT_EFI_ERROR (Status);\r
+\r
+ mFlashNvStorageVariableBase = PcdGet32 (PcdFlashNvStorageVariableBase);\r
+\r
+ // Set the index of the first LBA for the FVB\r
+ Instance->StartLba = (PcdGet32 (PcdFlashNvStorageVariableBase) - 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 ((DEBUG_INFO, "%a: Installing a correct one for this volume.\n",\r
+ __FUNCTION__));\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 NorFlashDxe.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_DXE_H__\r
-#define __NOR_FLASH_DXE_H__\r
-\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
-NorFlashFvbInitialize (\r
- IN NOR_FLASH_INSTANCE* Instance\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
-//\r
-// NorFlashDxe.c\r
-//\r
-\r
-EFI_STATUS\r
-NorFlashUnlockAndEraseSingleBlock (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN BlockAddress\r
- );\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
-#endif /* __NOR_FLASH_DXE_H__ */\r
ENTRY_POINT = NorFlashInitialise\r
\r
[Sources.common]\r
- NorFlashDxe.h\r
+ NorFlash.c\r
+ NorFlash.h\r
NorFlashDxe.c\r
- NorFlashFvbDxe.c\r
+ NorFlashFvb.c\r
NorFlashBlockIoDxe.c\r
\r
[Packages]\r
--- /dev/null
+/*++ @file NorFlashFvbDxe.c\r
+\r
+ Copyright (c) 2011 - 2020, ARM Ltd. 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
+\r
+ HeadersLength = sizeof(EFI_FIRMWARE_VOLUME_HEADER) + sizeof(EFI_FV_BLOCK_MAP_ENTRY) + sizeof(VARIABLE_STORE_HEADER);\r
+ Headers = AllocateZeroPool(HeadersLength);\r
+\r
+ // FirmwareVolumeHeader->FvLength is declared to have the Variable area AND the FTW working area AND the FTW Spare contiguous.\r
+ ASSERT(PcdGet32(PcdFlashNvStorageVariableBase) + PcdGet32(PcdFlashNvStorageVariableSize) == PcdGet32(PcdFlashNvStorageFtwWorkingBase));\r
+ ASSERT(PcdGet32(PcdFlashNvStorageFtwWorkingBase) + PcdGet32(PcdFlashNvStorageFtwWorkingSize) == PcdGet32(PcdFlashNvStorageFtwSpareBase));\r
+\r
+ // Check if the size of the area is at least one block size\r
+ ASSERT((PcdGet32(PcdFlashNvStorageVariableSize) > 0) && (PcdGet32(PcdFlashNvStorageVariableSize) / Instance->Media.BlockSize > 0));\r
+ ASSERT((PcdGet32(PcdFlashNvStorageFtwWorkingSize) > 0) && (PcdGet32(PcdFlashNvStorageFtwWorkingSize) / Instance->Media.BlockSize > 0));\r
+ ASSERT((PcdGet32(PcdFlashNvStorageFtwSpareSize) > 0) && (PcdGet32(PcdFlashNvStorageFtwSpareSize) / Instance->Media.BlockSize > 0));\r
+\r
+ // Ensure the Variable area Base Addresses are aligned on a block size boundaries\r
+ ASSERT(PcdGet32(PcdFlashNvStorageVariableBase) % Instance->Media.BlockSize == 0);\r
+ ASSERT(PcdGet32(PcdFlashNvStorageFtwWorkingBase) % Instance->Media.BlockSize == 0);\r
+ ASSERT(PcdGet32(PcdFlashNvStorageFtwSpareBase) % Instance->Media.BlockSize == 0);\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 ((EFI_D_INFO, "%a: No Firmware Volume header present\n",\r
+ __FUNCTION__));\r
+ return EFI_NOT_FOUND;\r
+ }\r
+\r
+ // Check the Firmware Volume Guid\r
+ if( CompareGuid (&FwVolHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid) == FALSE ) {\r
+ DEBUG ((EFI_D_INFO, "%a: Firmware Volume Guid non-compatible\n",\r
+ __FUNCTION__));\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 ((EFI_D_INFO, "%a: FV checksum is invalid (Checksum:0x%X)\n",\r
+ __FUNCTION__, Checksum));\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
+ DEBUG ((EFI_D_INFO, "%a: Variable Store Guid non-compatible\n",\r
+ __FUNCTION__));\r
+ return EFI_NOT_FOUND;\r
+ }\r
+\r
+ VariableStoreLength = PcdGet32 (PcdFlashNvStorageVariableSize) - FwVolHeader->HeaderLength;\r
+ if (VariableStoreHeader->Size != VariableStoreLength) {\r
+ DEBUG ((EFI_D_INFO, "%a: Variable Store Length does not match\n",\r
+ __FUNCTION__));\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
+\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 ((EFI_D_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
+ DEBUG ((EFI_D_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
+ 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 ((EFI_D_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 ((EFI_D_ERROR, "FvbEraseBlocks: ERROR - Lba range goes past the last Lba.\n"));\r
+ Status = EFI_INVALID_PARAMETER;\r
+ goto EXIT;\r
+ }\r
+ } while (TRUE);\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
+\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
+ 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
+\r
+++ /dev/null
-/*++ @file NorFlashFvbDxe.c\r
-\r
- Copyright (c) 2011 - 2020, ARM Ltd. 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/HobLib.h>\r
-#include <Library/UefiLib.h>\r
-#include <Library/BaseMemoryLib.h>\r
-#include <Library/MemoryAllocationLib.h>\r
-#include <Library/DxeServicesTableLib.h>\r
-#include <Library/UefiBootServicesTableLib.h>\r
-\r
-#include <Guid/VariableFormat.h>\r
-#include <Guid/SystemNvDataGuid.h>\r
-#include <Guid/NvVarStoreFormatted.h>\r
-\r
-#include "NorFlashDxe.h"\r
-\r
-STATIC EFI_EVENT mFvbVirtualAddrChangeEvent;\r
-STATIC UINTN mFlashNvStorageVariableBase;\r
-\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
-\r
- HeadersLength = sizeof(EFI_FIRMWARE_VOLUME_HEADER) + sizeof(EFI_FV_BLOCK_MAP_ENTRY) + sizeof(VARIABLE_STORE_HEADER);\r
- Headers = AllocateZeroPool(HeadersLength);\r
-\r
- // FirmwareVolumeHeader->FvLength is declared to have the Variable area AND the FTW working area AND the FTW Spare contiguous.\r
- ASSERT(PcdGet32(PcdFlashNvStorageVariableBase) + PcdGet32(PcdFlashNvStorageVariableSize) == PcdGet32(PcdFlashNvStorageFtwWorkingBase));\r
- ASSERT(PcdGet32(PcdFlashNvStorageFtwWorkingBase) + PcdGet32(PcdFlashNvStorageFtwWorkingSize) == PcdGet32(PcdFlashNvStorageFtwSpareBase));\r
-\r
- // Check if the size of the area is at least one block size\r
- ASSERT((PcdGet32(PcdFlashNvStorageVariableSize) > 0) && (PcdGet32(PcdFlashNvStorageVariableSize) / Instance->Media.BlockSize > 0));\r
- ASSERT((PcdGet32(PcdFlashNvStorageFtwWorkingSize) > 0) && (PcdGet32(PcdFlashNvStorageFtwWorkingSize) / Instance->Media.BlockSize > 0));\r
- ASSERT((PcdGet32(PcdFlashNvStorageFtwSpareSize) > 0) && (PcdGet32(PcdFlashNvStorageFtwSpareSize) / Instance->Media.BlockSize > 0));\r
-\r
- // Ensure the Variable area Base Addresses are aligned on a block size boundaries\r
- ASSERT(PcdGet32(PcdFlashNvStorageVariableBase) % Instance->Media.BlockSize == 0);\r
- ASSERT(PcdGet32(PcdFlashNvStorageFtwWorkingBase) % Instance->Media.BlockSize == 0);\r
- ASSERT(PcdGet32(PcdFlashNvStorageFtwSpareBase) % Instance->Media.BlockSize == 0);\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 ((EFI_D_INFO, "%a: No Firmware Volume header present\n",\r
- __FUNCTION__));\r
- return EFI_NOT_FOUND;\r
- }\r
-\r
- // Check the Firmware Volume Guid\r
- if( CompareGuid (&FwVolHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid) == FALSE ) {\r
- DEBUG ((EFI_D_INFO, "%a: Firmware Volume Guid non-compatible\n",\r
- __FUNCTION__));\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 ((EFI_D_INFO, "%a: FV checksum is invalid (Checksum:0x%X)\n",\r
- __FUNCTION__, Checksum));\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
- DEBUG ((EFI_D_INFO, "%a: Variable Store Guid non-compatible\n",\r
- __FUNCTION__));\r
- return EFI_NOT_FOUND;\r
- }\r
-\r
- VariableStoreLength = PcdGet32 (PcdFlashNvStorageVariableSize) - FwVolHeader->HeaderLength;\r
- if (VariableStoreHeader->Size != VariableStoreLength) {\r
- DEBUG ((EFI_D_INFO, "%a: Variable Store Length does not match\n",\r
- __FUNCTION__));\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
-\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 ((EFI_D_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
- DEBUG ((EFI_D_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
- 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 ((EFI_D_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 ((EFI_D_ERROR, "FvbEraseBlocks: ERROR - Lba range goes past the last Lba.\n"));\r
- Status = EFI_INVALID_PARAMETER;\r
- goto EXIT;\r
- }\r
- } while (TRUE);\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
-\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
- 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
-\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, RuntimeMmioRegionSize,\r
- EFI_MEMORY_UC | EFI_MEMORY_RUNTIME\r
- );\r
- ASSERT_EFI_ERROR (Status);\r
-\r
- Status = gDS->SetMemorySpaceAttributes (\r
- Instance->DeviceBaseAddress, RuntimeMmioRegionSize,\r
- EFI_MEMORY_UC | EFI_MEMORY_RUNTIME);\r
- ASSERT_EFI_ERROR (Status);\r
-\r
- mFlashNvStorageVariableBase = PcdGet32 (PcdFlashNvStorageVariableBase);\r
-\r
- // Set the index of the first LBA for the FVB\r
- Instance->StartLba = (PcdGet32 (PcdFlashNvStorageVariableBase) - 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 ((EFI_D_INFO, "%a: The FVB Header is not valid.\n", __FUNCTION__));\r
- DEBUG ((EFI_D_INFO, "%a: Installing a correct one for this volume.\n",\r
- __FUNCTION__));\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
projects / mirror_edk2.git / commitdiff