[mirror_edk2.git] / ArmPlatformPkg / Drivers / NorFlashDxe / NorFlashDxe.c

/** @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
  {\r
    EFI_DISK_IO_PROTOCOL_REVISION, // Revision\r
    NorFlashDiskIoReadDisk,        // ReadDisk\r
    NorFlashDiskIoWriteDisk        // WriteDisk\r
  },\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, // ShadowBuffer\r
  {\r
    {\r
      {\r
        HARDWARE_DEVICE_PATH,\r
        HW_VENDOR_DP,\r
        { (UINT8)sizeof(VENDOR_DEVICE_PATH), (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), 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
  Instance->ShadowBuffer = AllocateRuntimePool (BlockSize);;\r
  if (Instance->ShadowBuffer == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  if (SupportFvb) {\r
    Instance->SupportFvb = TRUE;\r
    Instance->Initialize = NorFlashFvbInitialize;\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
                    &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
  if (!Instance->Initialized && Instance->Initialize) {\r
    Instance->Initialize(Instance);\r
  }\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