+++ /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
- 0, // DeviceBaseAddress ... NEED TO BE FILLED\r
- 0, // RegionBaseAddress ... NEED TO BE FILLED\r
- 0, // Size ... NEED TO BE FILLED\r
- 0, // StartLba\r
-\r
- {\r
- EFI_BLOCK_IO_PROTOCOL_REVISION2, // Revision\r
- NULL, // Media ... NEED TO BE FILLED\r
- NorFlashBlockIoReset, // Reset;\r
- NorFlashBlockIoReadBlocks, // ReadBlocks\r
- NorFlashBlockIoWriteBlocks, // WriteBlocks\r
- NorFlashBlockIoFlushBlocks // FlushBlocks\r
- }, // BlockIoProtocol\r
-\r
- {\r
- 0, // MediaId ... NEED TO BE FILLED\r
- FALSE, // RemovableMedia\r
- TRUE, // MediaPresent\r
- FALSE, // LogicalPartition\r
- FALSE, // ReadOnly\r
- FALSE, // WriteCaching;\r
- 0, // BlockSize ... NEED TO BE FILLED\r
- 4, // IoAlign\r
- 0, // LastBlock ... NEED TO BE FILLED\r
- 0, // LowestAlignedLba\r
- 1, // LogicalBlocksPerPhysicalBlock\r
- }, //Media;\r
-\r
- {\r
- EFI_DISK_IO_PROTOCOL_REVISION, // Revision\r
- NorFlashDiskIoReadDisk, // ReadDisk\r
- NorFlashDiskIoWriteDisk // WriteDisk\r
- },\r
-\r
- {\r
- FvbGetAttributes, // GetAttributes\r
- FvbSetAttributes, // SetAttributes\r
- FvbGetPhysicalAddress, // GetPhysicalAddress\r
- FvbGetBlockSize, // GetBlockSize\r
- FvbRead, // Read\r
- FvbWrite, // Write\r
- FvbEraseBlocks, // EraseBlocks\r
- NULL, //ParentHandle\r
- }, // FvbProtoccol;\r
- NULL, // ShadowBuffer\r
- {\r
- {\r
- {\r
- HARDWARE_DEVICE_PATH,\r
- HW_VENDOR_DP,\r
- {\r
- (UINT8)(OFFSET_OF (NOR_FLASH_DEVICE_PATH, End)),\r
- (UINT8)(OFFSET_OF (NOR_FLASH_DEVICE_PATH, End) >> 8)\r
- }\r
- },\r
- { 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } }, // 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;\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
projects / mirror_edk2.git / blobdiff