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

/** @file  NorFlashDxe.c\r
\r
  Copyright (c) 2011 - 2020, Arm Limited. All rights reserved.<BR>\r
\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\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
    0, // Index\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
  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, &gEfiCallerIdGuid);\r
  Instance->DevicePath.Index = (UINT8)Index;\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)) {\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;\r
  EFI_LBA         CurrentBlock;\r
  UINT32          BlockSizeInWords;\r
  UINT32          NumBlocks;\r
  UINT32          BlockCount;\r
\r
  Status = EFI_SUCCESS;\r
\r
  // The buffer must be valid\r
  if (Buffer == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if(Instance->Media.ReadOnly == TRUE) {\r
    return EFI_WRITE_PROTECTED;\r
  }\r
\r
  // We must have some bytes to read\r
  DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: BufferSizeInBytes=0x%x\n", BufferSizeInBytes));\r
  if(BufferSizeInBytes == 0) {\r
    return EFI_BAD_BUFFER_SIZE;\r
  }\r
\r
  // The size of the buffer must be a multiple of the block size\r
  DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: BlockSize in bytes =0x%x\n", Instance->Media.BlockSize));\r
  if ((BufferSizeInBytes % Instance->Media.BlockSize) != 0) {\r
    return EFI_BAD_BUFFER_SIZE;\r
  }\r
\r
  // All blocks must be within the device\r
  NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->Media.BlockSize ;\r
\r
  DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: NumBlocks=%d, LastBlock=%ld, Lba=%ld.\n", NumBlocks, Instance->Media.LastBlock, Lba));\r
\r
  if ((Lba + NumBlocks) > (Instance->Media.LastBlock + 1)) {\r
    DEBUG((EFI_D_ERROR, "NorFlashWriteBlocks: ERROR - Write will exceed last block.\n"));\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  BlockSizeInWords = Instance->Media.BlockSize / 4;\r
\r
  // Because the target *Buffer is a pointer to VOID, we must put all the data into a pointer\r
  // to a proper data type, so use *ReadBuffer\r
  pWriteBuffer = (UINT32 *)Buffer;\r
\r
  CurrentBlock = Lba;\r
  for (BlockCount=0; BlockCount < NumBlocks; BlockCount++, CurrentBlock++, pWriteBuffer = pWriteBuffer + BlockSizeInWords) {\r
\r
    DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: Writing block #%d\n", (UINTN)CurrentBlock));\r
\r
    Status = NorFlashWriteFullBlock (Instance, CurrentBlock, pWriteBuffer, BlockSizeInWords);\r
\r
    if (EFI_ERROR(Status)) {\r
      break;\r
    }\r
  }\r
\r
  DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: Exit Status = \"%r\".\n", Status));\r
  return Status;\r
}\r
\r
#define BOTH_ALIGNED(a, b, align) ((((UINTN)(a) | (UINTN)(b)) & ((align) - 1)) == 0)\r
\r
/**\r
  Copy Length bytes from Source to Destination, using aligned accesses only.\r
  Note that this implementation uses memcpy() semantics rather then memmove()\r
  semantics, i.e., SourceBuffer and DestinationBuffer should not overlap.\r
\r
  @param  DestinationBuffer The target of the copy request.\r
  @param  SourceBuffer      The place to copy from.\r
  @param  Length            The number of bytes to copy.\r
\r
  @return Destination\r
\r
**/\r
STATIC\r
VOID *\r
AlignedCopyMem (\r
  OUT     VOID                      *DestinationBuffer,\r
  IN      CONST VOID                *SourceBuffer,\r
  IN      UINTN                     Length\r
  )\r
{\r
  UINT8             *Destination8;\r
  CONST UINT8       *Source8;\r
  UINT32            *Destination32;\r
  CONST UINT32      *Source32;\r
  UINT64            *Destination64;\r
  CONST UINT64      *Source64;\r
\r
  if (BOTH_ALIGNED(DestinationBuffer, SourceBuffer, 8) && Length >= 8) {\r
    Destination64 = DestinationBuffer;\r
    Source64 = SourceBuffer;\r
    while (Length >= 8) {\r
      *Destination64++ = *Source64++;\r
      Length -= 8;\r
    }\r
\r
    Destination8 = (UINT8 *)Destination64;\r
    Source8 = (CONST UINT8 *)Source64;\r
  } else if (BOTH_ALIGNED(DestinationBuffer, SourceBuffer, 4) && Length >= 4) {\r
    Destination32 = DestinationBuffer;\r
    Source32 = SourceBuffer;\r
    while (Length >= 4) {\r
      *Destination32++ = *Source32++;\r
      Length -= 4;\r
    }\r
\r
    Destination8 = (UINT8 *)Destination32;\r
    Source8 = (CONST UINT8 *)Source32;\r
  } else {\r
    Destination8 = DestinationBuffer;\r
    Source8 = SourceBuffer;\r
  }\r
  while (Length-- != 0) {\r
    *Destination8++ = *Source8++;\r
  }\r
  return DestinationBuffer;\r
}\r
\r
EFI_STATUS\r
NorFlashReadBlocks (\r
  IN NOR_FLASH_INSTANCE   *Instance,\r
  IN EFI_LBA              Lba,\r
  IN UINTN                BufferSizeInBytes,\r
  OUT VOID                *Buffer\r
  )\r
{\r
  UINT32              NumBlocks;\r
  UINTN               StartAddress;\r
\r
  DEBUG((DEBUG_BLKIO, "NorFlashReadBlocks: BufferSize=0x%xB BlockSize=0x%xB LastBlock=%ld, Lba=%ld.\n",\r
      BufferSizeInBytes, Instance->Media.BlockSize, Instance->Media.LastBlock, Lba));\r
\r
  // The buffer must be valid\r
  if (Buffer == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  // Return if we have not any byte to read\r
  if (BufferSizeInBytes == 0) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  // The size of the buffer must be a multiple of the block size\r
  if ((BufferSizeInBytes % Instance->Media.BlockSize) != 0) {\r
    return EFI_BAD_BUFFER_SIZE;\r
  }\r
\r
  // All blocks must be within the device\r
  NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->Media.BlockSize ;\r
\r
  if ((Lba + NumBlocks) > (Instance->Media.LastBlock + 1)) {\r
    DEBUG((EFI_D_ERROR, "NorFlashReadBlocks: ERROR - Read will exceed last block\n"));\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  // Get the address to start reading from\r
  StartAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress,\r
                                        Lba,\r
                                        Instance->Media.BlockSize\r
                                       );\r
\r
  // Put the device into Read Array mode\r
  SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);\r
\r
  // Readout the data\r
  AlignedCopyMem (Buffer, (VOID *)StartAddress, BufferSizeInBytes);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
NorFlashRead (\r
  IN NOR_FLASH_INSTANCE   *Instance,\r
  IN EFI_LBA              Lba,\r
  IN UINTN                Offset,\r
  IN UINTN                BufferSizeInBytes,\r
  OUT VOID                *Buffer\r
  )\r
{\r
  UINTN  StartAddress;\r
\r
  // The buffer must be valid\r
  if (Buffer == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  // Return if we have not any byte to read\r
  if (BufferSizeInBytes == 0) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  if (((Lba * Instance->Media.BlockSize) + Offset + BufferSizeInBytes) > Instance->Size) {\r
    DEBUG ((EFI_D_ERROR, "NorFlashRead: ERROR - Read will exceed device size.\n"));\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  // Get the address to start reading from\r
  StartAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress,\r
                                        Lba,\r
                                        Instance->Media.BlockSize\r
                                       );\r
\r
  // Put the device into Read Array mode\r
  SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);\r
\r
  // Readout the data\r
  AlignedCopyMem (Buffer, (VOID *)(StartAddress + Offset), BufferSizeInBytes);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/*\r
  Write a full or portion of a block. It must not span block boundaries; that is,\r
  Offset + *NumBytes <= Instance->Media.BlockSize.\r
*/\r
EFI_STATUS\r
NorFlashWriteSingleBlock (\r
  IN        NOR_FLASH_INSTANCE   *Instance,\r
  IN        EFI_LBA               Lba,\r
  IN        UINTN                 Offset,\r
  IN OUT    UINTN                *NumBytes,\r
  IN        UINT8                *Buffer\r
  )\r
{\r
  EFI_STATUS  TempStatus;\r
  UINT32      Tmp;\r
  UINT32      TmpBuf;\r
  UINT32      WordToWrite;\r
  UINT32      Mask;\r
  BOOLEAN     DoErase;\r
  UINTN       BytesToWrite;\r
  UINTN       CurOffset;\r
  UINTN       WordAddr;\r
  UINTN       BlockSize;\r
  UINTN       BlockAddress;\r
  UINTN       PrevBlockAddress;\r
\r
  PrevBlockAddress = 0;\r
\r
  DEBUG ((DEBUG_BLKIO, "NorFlashWriteSingleBlock(Parameters: Lba=%ld, Offset=0x%x, *NumBytes=0x%x, Buffer @ 0x%08x)\n", Lba, Offset, *NumBytes, Buffer));\r
\r
  // Detect WriteDisabled state\r
  if (Instance->Media.ReadOnly == TRUE) {\r
    DEBUG ((EFI_D_ERROR, "NorFlashWriteSingleBlock: ERROR - Can not write: Device is in WriteDisabled state.\n"));\r
    // It is in WriteDisabled state, return an error right away\r
    return EFI_ACCESS_DENIED;\r
  }\r
\r
  // Cache the block size to avoid de-referencing pointers all the time\r
  BlockSize = Instance->Media.BlockSize;\r
\r
  // The write must not span block boundaries.\r
  // We need to check each variable individually because adding two large values together overflows.\r
  if ( ( Offset               >= BlockSize ) ||\r
       ( *NumBytes            >  BlockSize ) ||\r
       ( (Offset + *NumBytes) >  BlockSize )    ) {\r
    DEBUG ((EFI_D_ERROR, "NorFlashWriteSingleBlock: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", Offset, *NumBytes, BlockSize ));\r
    return EFI_BAD_BUFFER_SIZE;\r
  }\r
\r
  // We must have some bytes to write\r
  if (*NumBytes == 0) {\r
    DEBUG ((EFI_D_ERROR, "NorFlashWriteSingleBlock: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", Offset, *NumBytes, BlockSize ));\r
    return EFI_BAD_BUFFER_SIZE;\r
  }\r
\r
  // Pick 128bytes as a good start for word operations as opposed to erasing the\r
  // block and writing the data regardless if an erase is really needed.\r
  // It looks like most individual NV variable writes are smaller than 128bytes.\r
  if (*NumBytes <= 128) {\r
    // Check to see if we need to erase before programming the data into NOR.\r
    // If the destination bits are only changing from 1s to 0s we can just write.\r
    // After a block is erased all bits in the block is set to 1.\r
    // If any byte requires us to erase we just give up and rewrite all of it.\r
    DoErase      = FALSE;\r
    BytesToWrite = *NumBytes;\r
    CurOffset    = Offset;\r
\r
    while (BytesToWrite > 0) {\r
      // Read full word from NOR, splice as required. A word is the smallest\r
      // unit we can write.\r
      TempStatus = NorFlashRead (Instance, Lba, CurOffset & ~(0x3), sizeof(Tmp), &Tmp);\r
      if (EFI_ERROR (TempStatus)) {\r
        return EFI_DEVICE_ERROR;\r
      }\r
\r
      // Physical address of word in NOR to write.\r
      WordAddr = (CurOffset & ~(0x3)) + GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress,\r
                                                               Lba, BlockSize);\r
      // The word of data that is to be written.\r
      TmpBuf = *((UINT32*)(Buffer + (*NumBytes - BytesToWrite)));\r
\r
      // First do word aligned chunks.\r
      if ((CurOffset & 0x3) == 0) {\r
        if (BytesToWrite >= 4) {\r
          // Is the destination still in 'erased' state?\r
          if (~Tmp != 0) {\r
            // Check to see if we are only changing bits to zero.\r
            if ((Tmp ^ TmpBuf) & TmpBuf) {\r
              DoErase = TRUE;\r
              break;\r
            }\r
          }\r
          // Write this word to NOR\r
          WordToWrite = TmpBuf;\r
          CurOffset += sizeof(TmpBuf);\r
          BytesToWrite -= sizeof(TmpBuf);\r
        } else {\r
          // BytesToWrite < 4. Do small writes and left-overs\r
          Mask = ~((~0) << (BytesToWrite * 8));\r
          // Mask out the bytes we want.\r
          TmpBuf &= Mask;\r
          // Is the destination still in 'erased' state?\r
          if ((Tmp & Mask) != Mask) {\r
            // Check to see if we are only changing bits to zero.\r
            if ((Tmp ^ TmpBuf) & TmpBuf) {\r
              DoErase = TRUE;\r
              break;\r
            }\r
          }\r
          // Merge old and new data. Write merged word to NOR\r
          WordToWrite = (Tmp & ~Mask) | TmpBuf;\r
          CurOffset += BytesToWrite;\r
          BytesToWrite = 0;\r
        }\r
      } else {\r
        // Do multiple words, but starting unaligned.\r
        if (BytesToWrite > (4 - (CurOffset & 0x3))) {\r
          Mask = ((~0) << ((CurOffset & 0x3) * 8));\r
          // Mask out the bytes we want.\r
          TmpBuf &= Mask;\r
          // Is the destination still in 'erased' state?\r
          if ((Tmp & Mask) != Mask) {\r
            // Check to see if we are only changing bits to zero.\r
            if ((Tmp ^ TmpBuf) & TmpBuf) {\r
              DoErase = TRUE;\r
              break;\r
            }\r
          }\r
          // Merge old and new data. Write merged word to NOR\r
          WordToWrite = (Tmp & ~Mask) | TmpBuf;\r
          BytesToWrite -= (4 - (CurOffset & 0x3));\r
          CurOffset += (4 - (CurOffset & 0x3));\r
        } else {\r
          // Unaligned and fits in one word.\r
          Mask = (~((~0) << (BytesToWrite * 8))) << ((CurOffset & 0x3) * 8);\r
          // Mask out the bytes we want.\r
          TmpBuf = (TmpBuf << ((CurOffset & 0x3) * 8)) & Mask;\r
          // Is the destination still in 'erased' state?\r
          if ((Tmp & Mask) != Mask) {\r
            // Check to see if we are only changing bits to zero.\r
            if ((Tmp ^ TmpBuf) & TmpBuf) {\r
              DoErase = TRUE;\r
              break;\r
            }\r
          }\r
          // Merge old and new data. Write merged word to NOR\r
          WordToWrite = (Tmp & ~Mask) | TmpBuf;\r
          CurOffset += BytesToWrite;\r
          BytesToWrite = 0;\r
        }\r
      }\r
\r
      //\r
      // Write the word to NOR.\r
      //\r
\r
      BlockAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, Lba, BlockSize);\r
      if (BlockAddress != PrevBlockAddress) {\r
        TempStatus = NorFlashUnlockSingleBlockIfNecessary (Instance, BlockAddress);\r
        if (EFI_ERROR (TempStatus)) {\r
          return EFI_DEVICE_ERROR;\r
        }\r
        PrevBlockAddress = BlockAddress;\r
      }\r
      TempStatus = NorFlashWriteSingleWord (Instance, WordAddr, WordToWrite);\r
      if (EFI_ERROR (TempStatus)) {\r
        return EFI_DEVICE_ERROR;\r
      }\r
    }\r
    // Exit if we got here and could write all the data. Otherwise do the\r
    // Erase-Write cycle.\r
    if (!DoErase) {\r
      return EFI_SUCCESS;\r
    }\r
  }\r
\r
  // Check we did get some memory. Buffer is BlockSize.\r
  if (Instance->ShadowBuffer == NULL) {\r
    DEBUG ((EFI_D_ERROR, "FvbWrite: ERROR - Buffer not ready\n"));\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  // Read NOR Flash data into shadow buffer\r
  TempStatus = NorFlashReadBlocks (Instance, Lba, BlockSize, Instance->ShadowBuffer);\r
  if (EFI_ERROR (TempStatus)) {\r
    // Return one of the pre-approved error statuses\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  // Put the data at the appropriate location inside the buffer area\r
  CopyMem ((VOID*)((UINTN)Instance->ShadowBuffer + Offset), Buffer, *NumBytes);\r
\r
  // Write the modified buffer back to the NorFlash\r
  TempStatus = NorFlashWriteBlocks (Instance, Lba, BlockSize, Instance->ShadowBuffer);\r
  if (EFI_ERROR (TempStatus)) {\r
    // Return one of the pre-approved error statuses\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/*\r
  Although DiskIoDxe will automatically install the DiskIO protocol whenever\r
  we install the BlockIO protocol, its implementation is sub-optimal as it reads\r
  and writes entire blocks using the BlockIO protocol. In fact we can access\r
  NOR flash with a finer granularity than that, so we can improve performance\r
  by directly producing the DiskIO protocol.\r
*/\r
\r
/**\r
  Read BufferSize bytes from Offset into Buffer.\r
\r
  @param  This                  Protocol instance pointer.\r
  @param  MediaId               Id of the media, changes every time the media is replaced.\r
  @param  Offset                The starting byte offset to read from\r
  @param  BufferSize            Size of Buffer\r
  @param  Buffer                Buffer containing read data\r
\r
  @retval EFI_SUCCESS           The data was read correctly from the device.\r
  @retval EFI_DEVICE_ERROR      The device reported an error while performing the read.\r
  @retval EFI_NO_MEDIA          There is no media in the device.\r
  @retval EFI_MEDIA_CHANGED     The MediaId does not match the current device.\r
  @retval EFI_INVALID_PARAMETER The read request contains device addresses that are not\r
                                valid for the device.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
NorFlashDiskIoReadDisk (\r
  IN EFI_DISK_IO_PROTOCOL         *This,\r
  IN UINT32                       MediaId,\r
  IN UINT64                       DiskOffset,\r
  IN UINTN                        BufferSize,\r
  OUT VOID                        *Buffer\r
  )\r
{\r
  NOR_FLASH_INSTANCE *Instance;\r
  UINT32              BlockSize;\r
  UINT32              BlockOffset;\r
  EFI_LBA             Lba;\r
\r
  Instance = INSTANCE_FROM_DISKIO_THIS(This);\r
\r
  if (MediaId != Instance->Media.MediaId) {\r
    return EFI_MEDIA_CHANGED;\r
  }\r
\r
  BlockSize = Instance->Media.BlockSize;\r
  Lba = (EFI_LBA) DivU64x32Remainder (DiskOffset, BlockSize, &BlockOffset);\r
\r
  return NorFlashRead (Instance, Lba, BlockOffset, BufferSize, Buffer);\r
}\r
\r
/**\r
  Writes a specified number of bytes to a device.\r
\r
  @param  This       Indicates a pointer to the calling context.\r
  @param  MediaId    ID of the medium to be written.\r
  @param  Offset     The starting byte offset on the logical block I/O device to write.\r
  @param  BufferSize The size in bytes of Buffer. The number of bytes to write to the device.\r
  @param  Buffer     A pointer to the buffer containing the data to be written.\r
\r
  @retval EFI_SUCCESS           The data was written correctly to the device.\r
  @retval EFI_WRITE_PROTECTED   The device can not be written to.\r
  @retval EFI_DEVICE_ERROR      The device reported an error while performing the write.\r
  @retval EFI_NO_MEDIA          There is no media in the device.\r
  @retval EFI_MEDIA_CHANGED     The MediaId does not match the current device.\r
  @retval EFI_INVALID_PARAMETER The write request contains device addresses that are not\r
                                 valid for the device.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
NorFlashDiskIoWriteDisk (\r
  IN EFI_DISK_IO_PROTOCOL         *This,\r
  IN UINT32                       MediaId,\r
  IN UINT64                       DiskOffset,\r
  IN UINTN                        BufferSize,\r
  IN VOID                         *Buffer\r
  )\r
{\r
  NOR_FLASH_INSTANCE *Instance;\r
  UINT32              BlockSize;\r
  UINT32              BlockOffset;\r
  EFI_LBA             Lba;\r
  UINTN               RemainingBytes;\r
  UINTN               WriteSize;\r
  EFI_STATUS          Status;\r
\r
  Instance = INSTANCE_FROM_DISKIO_THIS(This);\r
\r
  if (MediaId != Instance->Media.MediaId) {\r
    return EFI_MEDIA_CHANGED;\r
  }\r
\r
  BlockSize = Instance->Media.BlockSize;\r
  Lba = (EFI_LBA) DivU64x32Remainder (DiskOffset, BlockSize, &BlockOffset);\r
\r
  RemainingBytes = BufferSize;\r
\r
  // Write either all the remaining bytes, or the number of bytes that bring\r
  // us up to a block boundary, whichever is less.\r
  // (DiskOffset | (BlockSize - 1)) + 1) rounds DiskOffset up to the next\r
  // block boundary (even if it is already on one).\r
  WriteSize = MIN (RemainingBytes, ((DiskOffset | (BlockSize - 1)) + 1) - DiskOffset);\r
\r
  do {\r
    if (WriteSize == BlockSize) {\r
      // Write a full block\r
      Status = NorFlashWriteFullBlock (Instance, Lba, Buffer, BlockSize / sizeof (UINT32));\r
    } else {\r
      // Write a partial block\r
      Status = NorFlashWriteSingleBlock (Instance, Lba, BlockOffset, &WriteSize, Buffer);\r
    }\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
    // Now continue writing either all the remaining bytes or single blocks.\r
    RemainingBytes -= WriteSize;\r
    Buffer = (UINT8 *) Buffer + WriteSize;\r
    Lba++;\r
    BlockOffset = 0;\r
    WriteSize = MIN (RemainingBytes, BlockSize);\r
  } while (RemainingBytes);\r
\r
  return Status;\r
}\r
\r
EFI_STATUS\r
NorFlashReset (\r
  IN  NOR_FLASH_INSTANCE *Instance\r
  )\r
{\r
  // As there is no specific RESET to perform, ensure that the devices is in the default Read Array mode\r
  SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Fixup internal data so that EFI can be call in virtual mode.\r
  Call the passed in Child Notify event and convert any pointers in\r
  lib to virtual mode.\r
\r
  @param[in]    Event   The Event that is being processed\r
  @param[in]    Context Event Context\r
**/\r
VOID\r
EFIAPI\r
NorFlashVirtualNotifyEvent (\r
  IN EFI_EVENT        Event,\r
  IN VOID             *Context\r
  )\r
{\r
  UINTN Index;\r
\r
  for (Index = 0; Index < mNorFlashDeviceCount; Index++) {\r
    EfiConvertPointer (0x0, (VOID**)&mNorFlashInstances[Index]->DeviceBaseAddress);\r
    EfiConvertPointer (0x0, (VOID**)&mNorFlashInstances[Index]->RegionBaseAddress);\r
\r
    // Convert BlockIo protocol\r
    EfiConvertPointer (0x0, (VOID**)&mNorFlashInstances[Index]->BlockIoProtocol.FlushBlocks);\r
    EfiConvertPointer (0x0, (VOID**)&mNorFlashInstances[Index]->BlockIoProtocol.ReadBlocks);\r
    EfiConvertPointer (0x0, (VOID**)&mNorFlashInstances[Index]->BlockIoProtocol.Reset);\r
    EfiConvertPointer (0x0, (VOID**)&mNorFlashInstances[Index]->BlockIoProtocol.WriteBlocks);\r
\r
    // Convert Fvb\r
    EfiConvertPointer (0x0, (VOID**)&mNorFlashInstances[Index]->FvbProtocol.EraseBlocks);\r
    EfiConvertPointer (0x0, (VOID**)&mNorFlashInstances[Index]->FvbProtocol.GetAttributes);\r
    EfiConvertPointer (0x0, (VOID**)&mNorFlashInstances[Index]->FvbProtocol.GetBlockSize);\r
    EfiConvertPointer (0x0, (VOID**)&mNorFlashInstances[Index]->FvbProtocol.GetPhysicalAddress);\r
    EfiConvertPointer (0x0, (VOID**)&mNorFlashInstances[Index]->FvbProtocol.Read);\r
    EfiConvertPointer (0x0, (VOID**)&mNorFlashInstances[Index]->FvbProtocol.SetAttributes);\r
    EfiConvertPointer (0x0, (VOID**)&mNorFlashInstances[Index]->FvbProtocol.Write);\r
\r
    if (mNorFlashInstances[Index]->ShadowBuffer != NULL) {\r
      EfiConvertPointer (0x0, (VOID**)&mNorFlashInstances[Index]->ShadowBuffer);\r
    }\r
  }\r
\r
  return;\r
}\r
\r
EFI_STATUS\r
EFIAPI\r
NorFlashInitialise (\r
  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
      &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