-/** @file NorFlashDxe.c
-
- Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>
-
- This program and the accompanying materials
- are licensed and made available under the terms and conditions of the BSD License
- which accompanies this distribution. The full text of the license may be found at
- http://opensource.org/licenses/bsd-license.php
-
- THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
- WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include <Library/UefiLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/MemoryAllocationLib.h>
-#include <Library/UefiBootServicesTableLib.h>
-#include <Library/PcdLib.h>
-
-#include "NorFlashDxe.h"
-
-
-//
-// Global variable declarations
-//
-NOR_FLASH_INSTANCE **mNorFlashInstances;
-
-NOR_FLASH_INSTANCE mNorFlashInstanceTemplate = {
- NOR_FLASH_SIGNATURE, // Signature
- NULL, // Handle ... NEED TO BE FILLED
-
- FALSE, // Initialized
- NULL, // Initialize
-
- 0, // DeviceBaseAddress ... NEED TO BE FILLED
- 0, // RegionBaseAddress ... NEED TO BE FILLED
- 0, // Size ... NEED TO BE FILLED
- 0, // StartLba
-
+/** @file NorFlashDxe.c\r
+\r
+ Copyright (c) 2011 - 2014, ARM Ltd. All rights reserved.<BR>\r
+\r
+ This program and the accompanying materials\r
+ are licensed and made available under the terms and conditions of the BSD License\r
+ which accompanies this distribution. The full text of the license may be found at\r
+ http://opensource.org/licenses/bsd-license.php\r
+\r
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+\r
+**/\r
+\r
+#include <Library/UefiLib.h>\r
+#include <Library/BaseMemoryLib.h>\r
+#include <Library/MemoryAllocationLib.h>\r
+#include <Library/UefiBootServicesTableLib.h>\r
+#include <Library/PcdLib.h>\r
+\r
+#include "NorFlashDxe.h"\r
+\r
+STATIC EFI_EVENT mNorFlashVirtualAddrChangeEvent;\r
+\r
+//\r
+// Global variable declarations\r
+//\r
+NOR_FLASH_INSTANCE **mNorFlashInstances;\r
+UINT32 mNorFlashDeviceCount;\r
+\r
+NOR_FLASH_INSTANCE mNorFlashInstanceTemplate = {\r
+ NOR_FLASH_SIGNATURE, // Signature\r
+ NULL, // Handle ... NEED TO BE FILLED\r
+\r
+ 0, // DeviceBaseAddress ... NEED TO BE FILLED\r
+ 0, // RegionBaseAddress ... NEED TO BE FILLED\r
+ 0, // Size ... NEED TO BE FILLED\r
+ 0, // StartLba\r
+\r
{\r
EFI_BLOCK_IO_PROTOCOL_REVISION2, // Revision\r
NULL, // Media ... NEED TO BE FILLED\r
NorFlashBlockIoReset, // Reset;\r
- NorFlashBlockIoReadBlocks, // ReadBlocks
- NorFlashBlockIoWriteBlocks, // WriteBlocks
+ NorFlashBlockIoReadBlocks, // ReadBlocks\r
+ NorFlashBlockIoWriteBlocks, // WriteBlocks\r
NorFlashBlockIoFlushBlocks // FlushBlocks\r
- }, // BlockIoProtocol
-
+ }, // BlockIoProtocol\r
+\r
{\r
0, // MediaId ... NEED TO BE FILLED\r
FALSE, // RemovableMedia\r
0, // LastBlock ... NEED TO BE FILLED\r
0, // LowestAlignedLba\r
1, // LogicalBlocksPerPhysicalBlock\r
- }, //Media;
-
- FALSE, // SupportFvb ... NEED TO BE FILLED
+ }, //Media;\r
+\r
+ {\r
+ EFI_DISK_IO_PROTOCOL_REVISION, // Revision\r
+ NorFlashDiskIoReadDisk, // ReadDisk\r
+ NorFlashDiskIoWriteDisk // WriteDisk\r
+ },\r
+\r
{\r
- FvbGetAttributes, // GetAttributes
- FvbSetAttributes, // SetAttributes
- FvbGetPhysicalAddress, // GetPhysicalAddress
- FvbGetBlockSize, // GetBlockSize
- FvbRead, // Read
- FvbWrite, // Write
+ FvbGetAttributes, // GetAttributes\r
+ FvbSetAttributes, // SetAttributes\r
+ FvbGetPhysicalAddress, // GetPhysicalAddress\r
+ FvbGetBlockSize, // GetBlockSize\r
+ FvbRead, // Read\r
+ FvbWrite, // Write\r
FvbEraseBlocks, // EraseBlocks\r
NULL, //ParentHandle\r
- }, // FvbProtoccol;
-
- {
- {
- {
- HARDWARE_DEVICE_PATH,
- HW_VENDOR_DP,
- (UINT8)( sizeof(VENDOR_DEVICE_PATH) ),
- (UINT8)((sizeof(VENDOR_DEVICE_PATH)) >> 8),
- },
- { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }, // GUID ... NEED TO BE FILLED
- },
- {
- END_DEVICE_PATH_TYPE,
- END_ENTIRE_DEVICE_PATH_SUBTYPE,
- sizeof (EFI_DEVICE_PATH_PROTOCOL),
- 0
- }
- } // DevicePath
-};
-
-EFI_STATUS
-NorFlashCreateInstance (
- IN UINTN NorFlashDeviceBase,
- IN UINTN NorFlashRegionBase,
- IN UINTN NorFlashSize,
- IN UINT32 MediaId,
- IN UINT32 BlockSize,
- IN BOOLEAN SupportFvb,
- IN CONST GUID *NorFlashGuid,
- OUT NOR_FLASH_INSTANCE** NorFlashInstance
- )
-{
- EFI_STATUS Status;
- NOR_FLASH_INSTANCE* Instance;
-
- ASSERT(NorFlashInstance != NULL);
-
- Instance = AllocateCopyPool (sizeof(NOR_FLASH_INSTANCE),&mNorFlashInstanceTemplate);
- if (Instance == NULL) {
- return EFI_OUT_OF_RESOURCES;
- }
-
- Instance->DeviceBaseAddress = NorFlashDeviceBase;
- Instance->RegionBaseAddress = NorFlashRegionBase;
- Instance->Size = NorFlashSize;
-
- Instance->BlockIoProtocol.Media = &Instance->Media;
- Instance->Media.MediaId = MediaId;
- Instance->Media.BlockSize = BlockSize;
- Instance->Media.LastBlock = (NorFlashSize / BlockSize)-1;
-\r
- CopyGuid (&Instance->DevicePath.Vendor.Guid,NorFlashGuid);\r
-
- if (SupportFvb) {
- Instance->SupportFvb = TRUE;
- Instance->Initialize = NorFlashFvbInitialize;
-
- Status = gBS->InstallMultipleProtocolInterfaces (
- &Instance->Handle,
- &gEfiDevicePathProtocolGuid, &Instance->DevicePath,
- &gEfiBlockIoProtocolGuid, &Instance->BlockIoProtocol,
- &gEfiFirmwareVolumeBlockProtocolGuid, &Instance->FvbProtocol,
- NULL
- );
- if (EFI_ERROR(Status)) {
- FreePool(Instance);
- return Status;
- }
- } else {
- Instance->Initialized = TRUE;
-
- Status = gBS->InstallMultipleProtocolInterfaces (
- &Instance->Handle,
- &gEfiDevicePathProtocolGuid, &Instance->DevicePath,
- &gEfiBlockIoProtocolGuid, &Instance->BlockIoProtocol,
- NULL
- );
- if (EFI_ERROR(Status)) {
- FreePool(Instance);
- return Status;
- }
- }
+ }, // FvbProtoccol;\r
+ NULL, // ShadowBuffer\r
+ {\r
+ {\r
+ {\r
+ HARDWARE_DEVICE_PATH,\r
+ HW_VENDOR_DP,\r
+ {\r
+ (UINT8)(OFFSET_OF (NOR_FLASH_DEVICE_PATH, End)),\r
+ (UINT8)(OFFSET_OF (NOR_FLASH_DEVICE_PATH, End) >> 8)\r
+ }\r
+ },\r
+ { 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } }, // GUID ... NEED TO BE FILLED\r
+ },\r
+ {\r
+ END_DEVICE_PATH_TYPE,\r
+ END_ENTIRE_DEVICE_PATH_SUBTYPE,\r
+ { sizeof (EFI_DEVICE_PATH_PROTOCOL), 0 }\r
+ }\r
+ } // DevicePath\r
+};\r
+\r
+EFI_STATUS\r
+NorFlashCreateInstance (\r
+ IN UINTN NorFlashDeviceBase,\r
+ IN UINTN NorFlashRegionBase,\r
+ IN UINTN NorFlashSize,\r
+ IN UINT32 Index,\r
+ IN UINT32 BlockSize,\r
+ IN BOOLEAN SupportFvb,\r
+ IN CONST GUID *NorFlashGuid,\r
+ OUT NOR_FLASH_INSTANCE** NorFlashInstance\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ NOR_FLASH_INSTANCE* Instance;\r
+\r
+ ASSERT(NorFlashInstance != NULL);\r
+\r
+ Instance = AllocateRuntimeCopyPool (sizeof(NOR_FLASH_INSTANCE),&mNorFlashInstanceTemplate);\r
+ if (Instance == NULL) {\r
+ return EFI_OUT_OF_RESOURCES;\r
+ }\r
+\r
+ Instance->DeviceBaseAddress = NorFlashDeviceBase;\r
+ Instance->RegionBaseAddress = NorFlashRegionBase;\r
+ Instance->Size = NorFlashSize;\r
+\r
+ Instance->BlockIoProtocol.Media = &Instance->Media;\r
+ Instance->Media.MediaId = Index;\r
+ Instance->Media.BlockSize = BlockSize;\r
+ Instance->Media.LastBlock = (NorFlashSize / BlockSize)-1;\r
+\r
+ CopyGuid (&Instance->DevicePath.Vendor.Guid, NorFlashGuid);\r
+\r
+ Instance->ShadowBuffer = AllocateRuntimePool (BlockSize);;\r
+ if (Instance->ShadowBuffer == NULL) {\r
+ return EFI_OUT_OF_RESOURCES;\r
+ }\r
+\r
+ if (SupportFvb) {\r
+ NorFlashFvbInitialize (Instance);\r
+\r
+ Status = gBS->InstallMultipleProtocolInterfaces (\r
+ &Instance->Handle,\r
+ &gEfiDevicePathProtocolGuid, &Instance->DevicePath,\r
+ &gEfiBlockIoProtocolGuid, &Instance->BlockIoProtocol,\r
+ &gEfiFirmwareVolumeBlockProtocolGuid, &Instance->FvbProtocol,\r
+ NULL\r
+ );\r
+ if (EFI_ERROR(Status)) {\r
+ FreePool (Instance);\r
+ return Status;\r
+ }\r
+ } else {\r
+ Status = gBS->InstallMultipleProtocolInterfaces (\r
+ &Instance->Handle,\r
+ &gEfiDevicePathProtocolGuid, &Instance->DevicePath,\r
+ &gEfiBlockIoProtocolGuid, &Instance->BlockIoProtocol,\r
+ &gEfiDiskIoProtocolGuid, &Instance->DiskIoProtocol,\r
+ NULL\r
+ );\r
+ if (EFI_ERROR(Status)) {\r
+ FreePool (Instance);\r
+ return Status;\r
+ }\r
+ }\r
\r
*NorFlashInstance = Instance;\r
- return Status;
-}
-
-UINT32
-NorFlashReadStatusRegister (
- IN NOR_FLASH_INSTANCE *Instance,
- IN UINTN SR_Address
- )
-{
- // Prepare to read the status register
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_STATUS_REGISTER);
- return MmioRead32 (Instance->DeviceBaseAddress);
-}
-
-
-BOOLEAN
-NorFlashBlockIsLocked (
- IN NOR_FLASH_INSTANCE *Instance,
- IN UINTN BlockAddress
- )
-{
- UINT32 LockStatus;
- BOOLEAN BlockIsLocked;
-
- BlockIsLocked = TRUE;
-
- // Send command for reading device id
- SEND_NOR_COMMAND (BlockAddress, 2, P30_CMD_READ_DEVICE_ID);
-
- // Read block lock status
- LockStatus = MmioRead32 (CREATE_NOR_ADDRESS(BlockAddress, 2));
-
- // Decode block lock status
- LockStatus = FOLD_32BIT_INTO_16BIT(LockStatus);
-
- if ((LockStatus & 0x2) != 0) {
- DEBUG((EFI_D_ERROR, "NorFlashBlockIsLocked: WARNING: Block LOCKED DOWN\n"));
- }
-
- if ((LockStatus & 0x1) == 0) {
- // This means the block is unlocked
- DEBUG((DEBUG_BLKIO, "UnlockSingleBlock: Block 0x%08x unlocked\n", BlockAddress));
- BlockIsLocked = FALSE;
- }
-
- return BlockIsLocked;
-}
-
-
-EFI_STATUS
-NorFlashUnlockSingleBlock (
- IN NOR_FLASH_INSTANCE *Instance,
- IN UINTN BlockAddress
- )
-{
- EFI_STATUS Status = EFI_SUCCESS;
- UINT32 LockStatus;
-
- // Raise the Task Priority Level to TPL_NOTIFY to serialise all its operations
- // and to protect shared data structures.
-
- if (FeaturePcdGet (PcdNorFlashCheckBlockLocked) == TRUE) {
- do {
- // Request a lock setup
- SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_LOCK_BLOCK_SETUP);
-
- // Request an unlock
- SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_UNLOCK_BLOCK);
-
- // Send command for reading device id
- SEND_NOR_COMMAND (BlockAddress, 2, P30_CMD_READ_DEVICE_ID);
-
- // Read block lock status
- LockStatus = MmioRead32 (CREATE_NOR_ADDRESS(BlockAddress, 2));
-
- // Decode block lock status
- LockStatus = FOLD_32BIT_INTO_16BIT(LockStatus);
- } while ((LockStatus & 0x1) == 1);
- } else {
- // Request a lock setup
- SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_LOCK_BLOCK_SETUP);
-
- // Request an unlock
- SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_UNLOCK_BLOCK);
-
- // Wait until the status register gives us the all clear
- do {
- LockStatus = NorFlashReadStatusRegister (Instance, BlockAddress);
- } while ((LockStatus & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);
- }
-
- // Put device back into Read Array mode
- SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_READ_ARRAY);
-
- DEBUG((DEBUG_BLKIO, "UnlockSingleBlock: BlockAddress=0x%08x, Exit Status = \"%r\".\n", BlockAddress, Status));
-
- return Status;
-}
-
-
-EFI_STATUS
-NorFlashUnlockSingleBlockIfNecessary (
- IN NOR_FLASH_INSTANCE *Instance,
- IN UINTN BlockAddress
- )
-{
- EFI_STATUS Status = EFI_SUCCESS;
-
- if (NorFlashBlockIsLocked (Instance, BlockAddress) == TRUE) {
- Status = NorFlashUnlockSingleBlock (Instance, BlockAddress);
- }
-
- return Status;
-}
-
-
-/**
- * The following function presumes that the block has already been unlocked.
- **/
-EFI_STATUS
-NorFlashEraseSingleBlock (
- IN NOR_FLASH_INSTANCE *Instance,
- IN UINTN BlockAddress
- )
-{
- EFI_STATUS Status;
- UINT32 StatusRegister;
-
- Status = EFI_SUCCESS;
-
- // Request a block erase and then confirm it
- SEND_NOR_COMMAND(BlockAddress, 0, P30_CMD_BLOCK_ERASE_SETUP);
- SEND_NOR_COMMAND(BlockAddress, 0, P30_CMD_BLOCK_ERASE_CONFIRM);
-
- // Wait until the status register gives us the all clear
- do {
- StatusRegister = NorFlashReadStatusRegister (Instance, BlockAddress);
- } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);
-
- if (StatusRegister & P30_SR_BIT_VPP) {
- DEBUG((EFI_D_ERROR,"EraseSingleBlock(BlockAddress=0x%08x: VPP Range Error\n", BlockAddress));
- Status = EFI_DEVICE_ERROR;
- }
-
- if ((StatusRegister & (P30_SR_BIT_ERASE | P30_SR_BIT_PROGRAM)) == (P30_SR_BIT_ERASE | P30_SR_BIT_PROGRAM)) {
- DEBUG((EFI_D_ERROR,"EraseSingleBlock(BlockAddress=0x%08x: Command Sequence Error\n", BlockAddress));
- Status = EFI_DEVICE_ERROR;
- }
-
- if (StatusRegister & P30_SR_BIT_ERASE) {
- DEBUG((EFI_D_ERROR,"EraseSingleBlock(BlockAddress=0x%08x: Block Erase Error StatusRegister:0x%X\n", BlockAddress, StatusRegister));
- Status = EFI_DEVICE_ERROR;
- }
-
- if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) {
- // The debug level message has been reduced because a device lock might happen. In this case we just retry it ...
- DEBUG((EFI_D_INFO,"EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error\n", BlockAddress));
- Status = EFI_WRITE_PROTECTED;
- }
-
- if (EFI_ERROR(Status)) {
- // Clear the Status Register
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER);
- }
-
- // Put device back into Read Array mode
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);
-
- return Status;
-}
-
-/**
- * The following function presumes that the block has already been unlocked.
- **/
-EFI_STATUS
-NorFlashUnlockAndEraseSingleBlock (
- IN NOR_FLASH_INSTANCE *Instance,
- IN UINTN BlockAddress
- )
-{
- EFI_STATUS Status;
- UINTN Index;
- EFI_TPL OriginalTPL;
-
- // Raise TPL to TPL_HIGH to stop anyone from interrupting us.
- OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);
-
- Index = 0;
- // The block erase might fail a first time (SW bug ?). Retry it ...
- do {
- // Unlock the block if we have to
- Status = NorFlashUnlockSingleBlockIfNecessary (Instance, BlockAddress);
- if (!EFI_ERROR(Status)) {
- Status = NorFlashEraseSingleBlock (Instance, BlockAddress);
- }
- Index++;
- } while ((Index < NOR_FLASH_ERASE_RETRY) && (Status == EFI_WRITE_PROTECTED));
-
- if (Index == NOR_FLASH_ERASE_RETRY) {
- DEBUG((EFI_D_ERROR,"EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error (try to erase %d times)\n", BlockAddress,Index));
- }
-
- // Interruptions can resume.
- gBS->RestoreTPL (OriginalTPL);
-
- return Status;
-}
-
-
-EFI_STATUS
-NorFlashWriteSingleWord (
- IN NOR_FLASH_INSTANCE *Instance,
- IN UINTN WordAddress,
- IN UINT32 WriteData
- )
-{
- EFI_STATUS Status;
- UINT32 StatusRegister;
-
- Status = EFI_SUCCESS;
-
- // Request a write single word command
- SEND_NOR_COMMAND(WordAddress, 0, P30_CMD_WORD_PROGRAM_SETUP);
-
- // Store the word into NOR Flash;
- MmioWrite32 (WordAddress, WriteData);
-
- // Wait for the write to complete and then check for any errors; i.e. check the Status Register
- do {
- // Prepare to read the status register
- StatusRegister = NorFlashReadStatusRegister (Instance, WordAddress);
- // The chip is busy while the WRITE bit is not asserted
- } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);
-
-
- // Perform a full status check:
- // Mask the relevant bits of Status Register.
- // Everything should be zero, if not, we have a problem
-
- if (StatusRegister & P30_SR_BIT_VPP) {
- DEBUG((EFI_D_ERROR,"NorFlashWriteSingleWord(WordAddress:0x%X): VPP Range Error\n",WordAddress));
- Status = EFI_DEVICE_ERROR;
- }
-
- if (StatusRegister & P30_SR_BIT_PROGRAM) {
- DEBUG((EFI_D_ERROR,"NorFlashWriteSingleWord(WordAddress:0x%X): Program Error\n",WordAddress));
- Status = EFI_DEVICE_ERROR;
- }
-
- if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) {
- DEBUG((EFI_D_ERROR,"NorFlashWriteSingleWord(WordAddress:0x%X): Device Protect Error\n",WordAddress));
- Status = EFI_DEVICE_ERROR;
- }
-
- if (!EFI_ERROR(Status)) {
- // Clear the Status Register
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER);
- }
-
- // Put device back into Read Array mode
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);
-
- return Status;
-}
-
-/*
- * Writes data to the NOR Flash using the Buffered Programming method.
- *
- * The maximum size of the on-chip buffer is 32-words, because of hardware restrictions.
- * Therefore this function will only handle buffers up to 32 words or 128 bytes.
- * To deal with larger buffers, call this function again.
- *
- * This function presumes that both the TargetAddress and the TargetAddress+BufferSize
- * exist entirely within the NOR Flash. Therefore these conditions will not be checked here.
- *
- * In buffered programming, if the target address not at the beginning of a 32-bit word boundary,
- * then programming time is doubled and power consumption is increased.
- * Therefore, it is a requirement to align buffer writes to 32-bit word boundaries.
- * i.e. the last 4 bits of the target start address must be zero: 0x......00
- */
-EFI_STATUS
-NorFlashWriteBuffer (
- IN NOR_FLASH_INSTANCE *Instance,
- IN UINTN TargetAddress,
- IN UINTN BufferSizeInBytes,
- IN UINT32 *Buffer
- )
-{
- EFI_STATUS Status;
- UINTN BufferSizeInWords;
- UINTN Count;
- volatile UINT32 *Data;
- UINTN WaitForBuffer;
- BOOLEAN BufferAvailable;
- UINT32 StatusRegister;
-
- WaitForBuffer = MAX_BUFFERED_PROG_ITERATIONS;
- BufferAvailable = FALSE;
-
- // Check that the target address does not cross a 32-word boundary.
- if ((TargetAddress & BOUNDARY_OF_32_WORDS) != 0) {
- return EFI_INVALID_PARAMETER;
- }
-
- // Check there are some data to program
- if (BufferSizeInBytes == 0) {
- return EFI_BUFFER_TOO_SMALL;
- }
-
- // Check that the buffer size does not exceed the maximum hardware buffer size on chip.
- if (BufferSizeInBytes > P30_MAX_BUFFER_SIZE_IN_BYTES) {
- return EFI_BAD_BUFFER_SIZE;
- }
-
- // Check that the buffer size is a multiple of 32-bit words
- if ((BufferSizeInBytes % 4) != 0) {
- return EFI_BAD_BUFFER_SIZE;
- }
-
- // Pre-programming conditions checked, now start the algorithm.
-
- // Prepare the data destination address
- Data = (UINT32 *)TargetAddress;
-
- // Check the availability of the buffer
- do {
- // Issue the Buffered Program Setup command
- SEND_NOR_COMMAND(TargetAddress, 0, P30_CMD_BUFFERED_PROGRAM_SETUP);
-
- // Read back the status register bit#7 from the same address
- if (((*Data) & P30_SR_BIT_WRITE) == P30_SR_BIT_WRITE) {
- BufferAvailable = TRUE;
- }
-
- // Update the loop counter
- WaitForBuffer--;
-
- } while ((WaitForBuffer > 0) && (BufferAvailable == FALSE));
-
- // The buffer was not available for writing
- if (WaitForBuffer == 0) {
- Status = EFI_DEVICE_ERROR;
- goto EXIT;
- }
-
- // From now on we work in 32-bit words
- BufferSizeInWords = BufferSizeInBytes / (UINTN)4;
-
- // Write the word count, which is (buffer_size_in_words - 1),
- // because word count 0 means one word.
- SEND_NOR_COMMAND(TargetAddress, 0, (BufferSizeInWords - 1));
-
- // Write the data to the NOR Flash, advancing each address by 4 bytes
- for(Count=0; Count < BufferSizeInWords; Count++, Data++, Buffer++) {
- *Data = *Buffer;
- }
-
- // Issue the Buffered Program Confirm command, to start the programming operation
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_BUFFERED_PROGRAM_CONFIRM);
-
- // Wait for the write to complete and then check for any errors; i.e. check the Status Register
- do {
- StatusRegister = NorFlashReadStatusRegister (Instance, TargetAddress);
- // The chip is busy while the WRITE bit is not asserted
- } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);
-
-
- // Perform a full status check:
- // Mask the relevant bits of Status Register.
- // Everything should be zero, if not, we have a problem
-
- Status = EFI_SUCCESS;
-
- if (StatusRegister & P30_SR_BIT_VPP) {
- DEBUG((EFI_D_ERROR,"NorFlashWriteBuffer(TargetAddress:0x%X): VPP Range Error\n", TargetAddress));
- Status = EFI_DEVICE_ERROR;
- }
-
- if (StatusRegister & P30_SR_BIT_PROGRAM) {
- DEBUG((EFI_D_ERROR,"NorFlashWriteBuffer(TargetAddress:0x%X): Program Error\n", TargetAddress));
- Status = EFI_DEVICE_ERROR;
- }
-
- if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) {
- DEBUG((EFI_D_ERROR,"NorFlashWriteBuffer(TargetAddress:0x%X): Device Protect Error\n",TargetAddress));
- Status = EFI_DEVICE_ERROR;
- }
-
- if (!EFI_ERROR(Status)) {
- // Clear the Status Register
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER);
- }
-
-EXIT:
- // Put device back into Read Array mode
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);
-
- return Status;
-}
-
-EFI_STATUS
-NorFlashWriteSingleBlock (
- IN NOR_FLASH_INSTANCE *Instance,
- IN EFI_LBA Lba,
- IN UINT32 *DataBuffer,
- IN UINT32 BlockSizeInWords
- )
-{
- EFI_STATUS Status;
- UINTN WordAddress;
- UINT32 WordIndex;
- UINTN BufferIndex;
- UINTN BlockAddress;
- UINTN BuffersInBlock;
- UINTN RemainingWords;
- EFI_TPL OriginalTPL;
-
- Status = EFI_SUCCESS;
-
- // Get the physical address of the block
- BlockAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, Lba, BlockSizeInWords * 4);
-
- // Start writing from the first address at the start of the block
- WordAddress = BlockAddress;
-
- // Raise TPL to TPL_HIGH to stop anyone from interrupting us.
- OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);
-
- Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress);
- if (EFI_ERROR(Status)) {
- DEBUG((EFI_D_ERROR, "WriteSingleBlock: ERROR - Failed to Unlock and Erase the single block at 0x%X\n", BlockAddress));
- goto EXIT;
- }
-
- // To speed up the programming operation, NOR Flash is programmed using the Buffered Programming method.
-
- // Check that the address starts at a 32-word boundary, i.e. last 7 bits must be zero
- if ((WordAddress & BOUNDARY_OF_32_WORDS) == 0x00) {
-
- // First, break the entire block into buffer-sized chunks.
- BuffersInBlock = (UINTN)BlockSizeInWords / P30_MAX_BUFFER_SIZE_IN_BYTES;
-
- // Then feed each buffer chunk to the NOR Flash
- for(BufferIndex=0;
- BufferIndex < BuffersInBlock;
- BufferIndex++, WordAddress += P30_MAX_BUFFER_SIZE_IN_BYTES, DataBuffer += P30_MAX_BUFFER_SIZE_IN_WORDS
- ) {
- Status = NorFlashWriteBuffer (Instance, WordAddress, P30_MAX_BUFFER_SIZE_IN_BYTES, DataBuffer);
- if (EFI_ERROR(Status)) {
- goto EXIT;
- }
- }
-
- // Finally, finish off any remaining words that are less than the maximum size of the buffer
- RemainingWords = BlockSizeInWords % P30_MAX_BUFFER_SIZE_IN_WORDS;
-
- if(RemainingWords != 0) {
- Status = NorFlashWriteBuffer (Instance, WordAddress, (RemainingWords * 4), DataBuffer);
- if (EFI_ERROR(Status)) {
- goto EXIT;
- }
- }
-
- } else {
- // For now, use the single word programming algorithm
- // It is unlikely that the NOR Flash will exist in an address which falls within a 32 word boundary range,
- // i.e. which ends in the range 0x......01 - 0x......7F.
- for(WordIndex=0; WordIndex<BlockSizeInWords; WordIndex++, DataBuffer++, WordAddress = WordAddress + 4) {
- Status = NorFlashWriteSingleWord (Instance, WordAddress, *DataBuffer);
- if (EFI_ERROR(Status)) {
- goto EXIT;
- }
- }
- }
-
-EXIT:
- // Interruptions can resume.
- gBS->RestoreTPL (OriginalTPL);
-
- if (EFI_ERROR(Status)) {
- DEBUG((EFI_D_ERROR, "NOR FLASH Programming [WriteSingleBlock] failed at address 0x%08x. Exit Status = \"%r\".\n", WordAddress, Status));
- }
- return Status;
-}
-
-
-EFI_STATUS
-NorFlashWriteBlocks (
- IN NOR_FLASH_INSTANCE *Instance,
- IN EFI_LBA Lba,
- IN UINTN BufferSizeInBytes,
- IN VOID *Buffer
- )
-{
- UINT32 *pWriteBuffer;
- EFI_STATUS Status = EFI_SUCCESS;
- EFI_LBA CurrentBlock;
- UINT32 BlockSizeInWords;
- UINT32 NumBlocks;
- UINT32 BlockCount;
-
- // The buffer must be valid
- if (Buffer == NULL) {
- return EFI_INVALID_PARAMETER;
- }
-
- if(Instance->Media.ReadOnly == TRUE) {
- return EFI_WRITE_PROTECTED;
- }
-
- // We must have some bytes to read
- DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: BufferSizeInBytes=0x%x\n", BufferSizeInBytes));
- if(BufferSizeInBytes == 0) {
- return EFI_BAD_BUFFER_SIZE;
- }
-
- // The size of the buffer must be a multiple of the block size
- DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: BlockSize in bytes =0x%x\n", Instance->Media.BlockSize));
- if ((BufferSizeInBytes % Instance->Media.BlockSize) != 0) {
- return EFI_BAD_BUFFER_SIZE;
- }
-
- // All blocks must be within the device
- NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->Media.BlockSize ;
-
- DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: NumBlocks=%d, LastBlock=%ld, Lba=%ld.\n", NumBlocks, Instance->Media.LastBlock, Lba));
-
- if ((Lba + NumBlocks) > (Instance->Media.LastBlock + 1)) {
- DEBUG((EFI_D_ERROR, "NorFlashWriteBlocks: ERROR - Write will exceed last block.\n"));
- return EFI_INVALID_PARAMETER;
- }
-
- BlockSizeInWords = Instance->Media.BlockSize / 4;
-
- // Because the target *Buffer is a pointer to VOID, we must put all the data into a pointer
- // to a proper data type, so use *ReadBuffer
- pWriteBuffer = (UINT32 *)Buffer;
-
- CurrentBlock = Lba;
- for (BlockCount=0; BlockCount < NumBlocks; BlockCount++, CurrentBlock++, pWriteBuffer = pWriteBuffer + BlockSizeInWords) {
-
- DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: Writing block #%d\n", (UINTN)CurrentBlock));
-
- Status = NorFlashWriteSingleBlock (Instance, CurrentBlock, pWriteBuffer, BlockSizeInWords);
-
- if (EFI_ERROR(Status)) {
- break;
- }
- }
-
- DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: Exit Status = \"%r\".\n", Status));
- return Status;
-}
-
-EFI_STATUS
-NorFlashReadBlocks (
- IN NOR_FLASH_INSTANCE *Instance,
- IN EFI_LBA Lba,
- IN UINTN BufferSizeInBytes,
- OUT VOID *Buffer
- )
-{
- UINT32 NumBlocks;
- UINTN StartAddress;
-
- // The buffer must be valid
- if (Buffer == NULL) {
- return EFI_INVALID_PARAMETER;
- }
-
- // We must have some bytes to read
- DEBUG((DEBUG_BLKIO, "NorFlashReadBlocks: BufferSize=0x%x bytes.\n", BufferSizeInBytes));
- if(BufferSizeInBytes == 0) {
- return EFI_BAD_BUFFER_SIZE;
- }
-
- // The size of the buffer must be a multiple of the block size
- DEBUG((DEBUG_BLKIO, "NorFlashReadBlocks: BlockSize=0x%x bytes.\n", Instance->Media.BlockSize));
- if ((BufferSizeInBytes % Instance->Media.BlockSize) != 0) {
- return EFI_BAD_BUFFER_SIZE;
- }
-
- // All blocks must be within the device
- NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->Media.BlockSize ;
-
- DEBUG((DEBUG_BLKIO, "NorFlashReadBlocks: NumBlocks=%d, LastBlock=%ld, Lba=%ld\n", NumBlocks, Instance->Media.LastBlock, Lba));
-
- if ((Lba + NumBlocks) > (Instance->Media.LastBlock + 1)) {
- DEBUG((EFI_D_ERROR, "NorFlashReadBlocks: ERROR - Read will exceed last block\n"));
- return EFI_INVALID_PARAMETER;
- }
-
- // Get the address to start reading from
- StartAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress,
- Lba,
- Instance->Media.BlockSize
- );
-
- // Put the device into Read Array mode
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);
-
- // Readout the data
- CopyMem(Buffer, (UINTN *)StartAddress, BufferSizeInBytes);
-
- return EFI_SUCCESS;
-}
-
-EFI_STATUS
-NorFlashReset (
- IN NOR_FLASH_INSTANCE *Instance
- )
-{
- // As there is no specific RESET to perform, ensure that the devices is in the default Read Array mode
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);
- return EFI_SUCCESS;
-}
-
-EFI_STATUS
-EFIAPI
-NorFlashInitialise (
- IN EFI_HANDLE ImageHandle,
- IN EFI_SYSTEM_TABLE *SystemTable
- )
-{
- EFI_STATUS Status;
- UINT32 Index;
- NOR_FLASH_DESCRIPTION* NorFlashDevices;
- UINT32 NorFlashDeviceCount;
- BOOLEAN ContainVariableStorage;
-
- Status = NorFlashPlatformInitialization ();
- if (EFI_ERROR(Status)) {
- DEBUG((EFI_D_ERROR,"NorFlashInitialise: Fail to initialize Nor Flash devices\n"));
- return Status;
- }
-
- Status = NorFlashPlatformGetDevices (&NorFlashDevices,&NorFlashDeviceCount);
- if (EFI_ERROR(Status)) {
- DEBUG((EFI_D_ERROR,"NorFlashInitialise: Fail to get Nor Flash devices\n"));
- return Status;
- }
-
- mNorFlashInstances = AllocatePool (sizeof(NOR_FLASH_INSTANCE*) * NorFlashDeviceCount);
-
- for (Index = 0; Index < NorFlashDeviceCount; Index++) {
- // Check if this NOR Flash device contain the variable storage region
- ContainVariableStorage =
- (NorFlashDevices[Index].RegionBaseAddress <= PcdGet32 (PcdFlashNvStorageVariableBase)) &&
- (PcdGet32 (PcdFlashNvStorageVariableBase) + PcdGet32 (PcdFlashNvStorageVariableSize) <= NorFlashDevices[Index].RegionBaseAddress + NorFlashDevices[Index].Size);
-
- Status = NorFlashCreateInstance (
- NorFlashDevices[Index].DeviceBaseAddress,
- NorFlashDevices[Index].RegionBaseAddress,
- NorFlashDevices[Index].Size,
- Index,
- NorFlashDevices[Index].BlockSize,
- ContainVariableStorage,
- &NorFlashDevices[Index].Guid,
- &mNorFlashInstances[Index]
- );
- if (EFI_ERROR(Status)) {
- DEBUG((EFI_D_ERROR,"NorFlashInitialise: Fail to create instance for NorFlash[%d]\n",Index));
- }
- }
-
- return Status;
-}
+ 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) == TRUE) {\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
+EFI_STATUS\r
+NorFlashUnlockAndEraseSingleBlock (\r
+ IN NOR_FLASH_INSTANCE *Instance,\r
+ IN UINTN BlockAddress\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ UINTN Index;\r
+ EFI_TPL OriginalTPL;\r
+\r
+ if (!EfiAtRuntime ()) {\r
+ // Raise TPL to TPL_HIGH to stop anyone from interrupting us.\r
+ OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);\r
+ } else {\r
+ // This initialization is only to prevent the compiler to complain about the\r
+ // use of uninitialized variables\r
+ OriginalTPL = TPL_HIGH_LEVEL;\r
+ }\r
+\r
+ Index = 0;\r
+ // The block erase might fail a first time (SW bug ?). Retry it ...\r
+ do {\r
+ // Unlock the block if we have to\r
+ Status = NorFlashUnlockSingleBlockIfNecessary (Instance, BlockAddress);\r
+ if (EFI_ERROR (Status)) {\r
+ break;\r
+ }\r
+ Status = NorFlashEraseSingleBlock (Instance, BlockAddress);\r
+ Index++;\r
+ } while ((Index < NOR_FLASH_ERASE_RETRY) && (Status == EFI_WRITE_PROTECTED));\r
+\r
+ if (Index == NOR_FLASH_ERASE_RETRY) {\r
+ DEBUG((EFI_D_ERROR,"EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error (try to erase %d times)\n", BlockAddress,Index));\r
+ }\r
+\r
+ if (!EfiAtRuntime ()) {\r
+ // Interruptions can resume.\r
+ gBS->RestoreTPL (OriginalTPL);\r
+ }\r
+\r
+ return Status;\r
+}\r
+\r
+\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
+ IN EFI_LBA Lba,\r
+ IN UINT32 *DataBuffer,\r
+ IN UINT32 BlockSizeInWords\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ UINTN WordAddress;\r
+ UINT32 WordIndex;\r
+ UINTN BufferIndex;\r
+ UINTN BlockAddress;\r
+ UINTN BuffersInBlock;\r
+ UINTN RemainingWords;\r
+ EFI_TPL OriginalTPL;\r
+ UINTN Cnt;\r
+\r
+ Status = EFI_SUCCESS;\r
+\r
+ // Get the physical address of the block\r
+ BlockAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, Lba, BlockSizeInWords * 4);\r
+\r
+ // Start writing from the first address at the start of the block\r
+ WordAddress = BlockAddress;\r
+\r
+ if (!EfiAtRuntime ()) {\r
+ // Raise TPL to TPL_HIGH to stop anyone from interrupting us.\r
+ OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);\r
+ } else {\r
+ // This initialization is only to prevent the compiler to complain about the\r
+ // use of uninitialized variables\r
+ OriginalTPL = TPL_HIGH_LEVEL;\r
+ }\r
+\r
+ Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress);\r
+ if (EFI_ERROR(Status)) {\r
+ DEBUG((EFI_D_ERROR, "WriteSingleBlock: ERROR - Failed to Unlock and Erase the single block at 0x%X\n", BlockAddress));\r
+ goto EXIT;\r
+ }\r
+\r
+ // To speed up the programming operation, NOR Flash is programmed using the Buffered Programming method.\r
+\r
+ // Check that the address starts at a 32-word boundary, i.e. last 7 bits must be zero\r
+ if ((WordAddress & BOUNDARY_OF_32_WORDS) == 0x00) {\r
+\r
+ // First, break the entire block into buffer-sized chunks.\r
+ BuffersInBlock = (UINTN)(BlockSizeInWords * 4) / P30_MAX_BUFFER_SIZE_IN_BYTES;\r
+\r
+ // Then feed each buffer chunk to the NOR Flash\r
+ // If a buffer does not contain any data, don't write it.\r
+ for(BufferIndex=0;\r
+ BufferIndex < BuffersInBlock;\r
+ BufferIndex++, WordAddress += P30_MAX_BUFFER_SIZE_IN_BYTES, DataBuffer += P30_MAX_BUFFER_SIZE_IN_WORDS\r
+ ) {\r
+ // Check the buffer to see if it contains any data (not set all 1s).\r
+ for (Cnt = 0; Cnt < P30_MAX_BUFFER_SIZE_IN_WORDS; Cnt++) {\r
+ if (~DataBuffer[Cnt] != 0 ) {\r
+ // Some data found, write the buffer.\r
+ Status = NorFlashWriteBuffer (Instance, WordAddress, P30_MAX_BUFFER_SIZE_IN_BYTES,\r
+ DataBuffer);\r
+ if (EFI_ERROR(Status)) {\r
+ goto EXIT;\r
+ }\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ // Finally, finish off any remaining words that are less than the maximum size of the buffer\r
+ RemainingWords = BlockSizeInWords % P30_MAX_BUFFER_SIZE_IN_WORDS;\r
+\r
+ if(RemainingWords != 0) {\r
+ Status = NorFlashWriteBuffer (Instance, WordAddress, (RemainingWords * 4), DataBuffer);\r
+ if (EFI_ERROR(Status)) {\r
+ goto EXIT;\r
+ }\r
+ }\r
+\r
+ } else {\r
+ // For now, use the single word programming algorithm\r
+ // It is unlikely that the NOR Flash will exist in an address which falls within a 32 word boundary range,\r
+ // i.e. which ends in the range 0x......01 - 0x......7F.\r
+ for(WordIndex=0; WordIndex<BlockSizeInWords; WordIndex++, DataBuffer++, WordAddress = WordAddress + 4) {\r
+ Status = NorFlashWriteSingleWord (Instance, WordAddress, *DataBuffer);\r
+ if (EFI_ERROR(Status)) {\r
+ goto EXIT;\r
+ }\r
+ }\r
+ }\r
+\r
+EXIT:\r
+ if (!EfiAtRuntime ()) {\r
+ // Interruptions can resume.\r
+ gBS->RestoreTPL (OriginalTPL);\r
+ }\r
+\r
+ if (EFI_ERROR(Status)) {\r
+ DEBUG((EFI_D_ERROR, "NOR FLASH Programming [WriteSingleBlock] failed at address 0x%08x. Exit Status = \"%r\".\n", WordAddress, Status));\r
+ }\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 = EFI_SUCCESS;\r
+ EFI_LBA CurrentBlock;\r
+ UINT32 BlockSizeInWords;\r
+ UINT32 NumBlocks;\r
+ UINT32 BlockCount;\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_CHNAGED The MediaId does not matched 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_CHNAGED The MediaId does not matched 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
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ UINT32 Index;\r
+ NOR_FLASH_DESCRIPTION* NorFlashDevices;\r
+ BOOLEAN ContainVariableStorage;\r
+\r
+ Status = NorFlashPlatformInitialization ();\r
+ if (EFI_ERROR(Status)) {\r
+ DEBUG((EFI_D_ERROR,"NorFlashInitialise: Fail to initialize Nor Flash devices\n"));\r
+ return Status;\r
+ }\r
+\r
+ Status = NorFlashPlatformGetDevices (&NorFlashDevices, &mNorFlashDeviceCount);\r
+ if (EFI_ERROR(Status)) {\r
+ DEBUG((EFI_D_ERROR,"NorFlashInitialise: Fail to get Nor Flash devices\n"));\r
+ return Status;\r
+ }\r
+\r
+ mNorFlashInstances = AllocateRuntimePool (sizeof(NOR_FLASH_INSTANCE*) * mNorFlashDeviceCount);\r
+\r
+ for (Index = 0; Index < mNorFlashDeviceCount; Index++) {\r
+ // Check if this NOR Flash device contain the variable storage region\r
+ ContainVariableStorage =\r
+ (NorFlashDevices[Index].RegionBaseAddress <= PcdGet32 (PcdFlashNvStorageVariableBase)) &&\r
+ (PcdGet32 (PcdFlashNvStorageVariableBase) + PcdGet32 (PcdFlashNvStorageVariableSize) <= NorFlashDevices[Index].RegionBaseAddress + NorFlashDevices[Index].Size);\r
+\r
+ Status = NorFlashCreateInstance (\r
+ NorFlashDevices[Index].DeviceBaseAddress,\r
+ NorFlashDevices[Index].RegionBaseAddress,\r
+ NorFlashDevices[Index].Size,\r
+ Index,\r
+ NorFlashDevices[Index].BlockSize,\r
+ ContainVariableStorage,\r
+ &NorFlashDevices[Index].Guid,\r
+ &mNorFlashInstances[Index]\r
+ );\r
+ if (EFI_ERROR(Status)) {\r
+ DEBUG((EFI_D_ERROR,"NorFlashInitialise: Fail to create instance for NorFlash[%d]\n",Index));\r
+ }\r
+ }\r
+\r
+ //\r
+ // Register for the virtual address change event\r
+ //\r
+ Status = gBS->CreateEventEx (\r
+ EVT_NOTIFY_SIGNAL,\r
+ TPL_NOTIFY,\r
+ NorFlashVirtualNotifyEvent,\r
+ NULL,\r
+ &gEfiEventVirtualAddressChangeGuid,\r
+ &mNorFlashVirtualAddrChangeEvent\r
+ );\r
+ ASSERT_EFI_ERROR (Status);\r
+\r
+ return Status;\r
+}\r