+++ /dev/null
-/** @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
- FALSE, // Initialized\r
- NULL, // Initialize\r
-\r
- 0, // DeviceBaseAddress ... NEED TO BE FILLED\r
- 0, // RegionBaseAddress ... NEED TO BE FILLED\r
- 0, // Size ... NEED TO BE FILLED\r
- 0, // StartLba\r
-\r
- {\r
- EFI_BLOCK_IO_PROTOCOL_REVISION2, // Revision\r
- NULL, // Media ... NEED TO BE FILLED\r
- NorFlashBlockIoReset, // Reset;\r
- NorFlashBlockIoReadBlocks, // ReadBlocks\r
- NorFlashBlockIoWriteBlocks, // WriteBlocks\r
- NorFlashBlockIoFlushBlocks // FlushBlocks\r
- }, // BlockIoProtocol\r
-\r
- {\r
- 0, // MediaId ... NEED TO BE FILLED\r
- FALSE, // RemovableMedia\r
- TRUE, // MediaPresent\r
- FALSE, // LogicalPartition\r
- FALSE, // ReadOnly\r
- FALSE, // WriteCaching;\r
- 0, // BlockSize ... NEED TO BE FILLED\r
- 4, // IoAlign\r
- 0, // LastBlock ... NEED TO BE FILLED\r
- 0, // LowestAlignedLba\r
- 1, // LogicalBlocksPerPhysicalBlock\r
- }, //Media;\r
-\r
- FALSE, // SupportFvb ... NEED TO BE FILLED\r
- {\r
- FvbGetAttributes, // GetAttributes\r
- FvbSetAttributes, // SetAttributes\r
- FvbGetPhysicalAddress, // GetPhysicalAddress\r
- FvbGetBlockSize, // GetBlockSize\r
- FvbRead, // Read\r
- FvbWrite, // Write\r
- FvbEraseBlocks, // EraseBlocks\r
- NULL, //ParentHandle\r
- }, // FvbProtoccol;\r
- NULL, // FvbBuffer\r
- {\r
- {\r
- {\r
- HARDWARE_DEVICE_PATH,\r
- HW_VENDOR_DP,\r
- (UINT8)( sizeof(VENDOR_DEVICE_PATH) ),\r
- (UINT8)((sizeof(VENDOR_DEVICE_PATH)) >> 8),\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),\r
- 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 MediaId,\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 = MediaId;\r
- Instance->Media.BlockSize = BlockSize;\r
- Instance->Media.LastBlock = (NorFlashSize / BlockSize)-1;\r
-\r
- CopyGuid (&Instance->DevicePath.Vendor.Guid, NorFlashGuid);\r
-\r
- if (SupportFvb) {\r
- Instance->SupportFvb = TRUE;\r
- Instance->Initialize = NorFlashFvbInitialize;\r
- Instance->FvbBuffer = AllocateRuntimePool (BlockSize);;\r
- if (Instance->FvbBuffer == NULL) {\r
- return EFI_OUT_OF_RESOURCES;\r
- }\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
- Instance->Initialized = TRUE;\r
-\r
- Status = gBS->InstallMultipleProtocolInterfaces (\r
- &Instance->Handle,\r
- &gEfiDevicePathProtocolGuid, &Instance->DevicePath,\r
- &gEfiBlockIoProtocolGuid, &Instance->BlockIoProtocol,\r
- NULL\r
- );\r
- if (EFI_ERROR(Status)) {\r
- FreePool (Instance);\r
- return Status;\r
- }\r
- }\r
-\r
- *NorFlashInstance = Instance;\r
- return Status;\r
-}\r
-\r
-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
-\r
-BOOLEAN\r
-NorFlashBlockIsLocked (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN BlockAddress\r
- )\r
-{\r
- UINT32 LockStatus;\r
- BOOLEAN BlockIsLocked;\r
-\r
- BlockIsLocked = TRUE;\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
- if ((LockStatus & 0x1) == 0) {\r
- // This means the block is unlocked\r
- DEBUG((DEBUG_BLKIO, "UnlockSingleBlock: Block 0x%08x unlocked\n", BlockAddress));\r
- BlockIsLocked = FALSE;\r
- }\r
-\r
- return BlockIsLocked;\r
-}\r
-\r
-\r
-EFI_STATUS\r
-NorFlashUnlockSingleBlock (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN BlockAddress\r
- )\r
-{\r
- EFI_STATUS Status = EFI_SUCCESS;\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, Exit Status = \"%r\".\n", BlockAddress, Status));\r
-\r
- return Status;\r
-}\r
-\r
-\r
-EFI_STATUS\r
-NorFlashUnlockSingleBlockIfNecessary (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN BlockAddress\r
- )\r
-{\r
- EFI_STATUS 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
-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
- * The following function presumes that the block has already been unlocked.\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
- Status = NorFlashEraseSingleBlock (Instance, BlockAddress);\r
- }\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
-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
- *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
-EFI_STATUS\r
-NorFlashWriteSingleBlock (\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 = NorFlashWriteSingleBlock (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
-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
- CopyMem(Buffer, (UINTN *)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
- UINT32 NumBlocks;\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
- // 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, "NorFlashRead: ERROR - Read will exceed last block\n"));\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- if (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
- CopyMem (Buffer, (UINTN *)(StartAddress + Offset), BufferSizeInBytes);\r
-\r
- return EFI_SUCCESS;\r
-}\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]->FvbBuffer != NULL) {\r
- EfiConvertPointer (0x0, (VOID**)&mNorFlashInstances[Index]->FvbBuffer);\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