[mirror_edk2.git] / OvmfPkg / VirtNorFlashDxe / VirtNorFlash.c

/** @file  NorFlash.c\r
\r
  Copyright (c) 2011 - 2020, Arm Limited. All rights reserved.<BR>\r
  Copyright (c) 2020, Linaro, Ltd. All rights reserved.<BR>\r
\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include <Library/BaseMemoryLib.h>\r
\r
#include "VirtNorFlash.h"\r
\r
//\r
// Global variable declarations\r
//\r
extern NOR_FLASH_INSTANCE  **mNorFlashInstances;\r
extern UINT32              mNorFlashDeviceCount;\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 ((DEBUG_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
  // 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
  // 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
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
 * The following function presumes that the block has already been unlocked.\r
 **/\r
EFI_STATUS\r
NorFlashEraseSingleBlock (\r
  IN NOR_FLASH_INSTANCE  *Instance,\r
  IN UINTN               BlockAddress\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINT32      StatusRegister;\r
\r
  Status = EFI_SUCCESS;\r
\r
  // Request a block erase and then confirm it\r
  SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_BLOCK_ERASE_SETUP);\r
  SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_BLOCK_ERASE_CONFIRM);\r
\r
  // Wait until the status register gives us the all clear\r
  do {\r
    StatusRegister = NorFlashReadStatusRegister (Instance, BlockAddress);\r
  } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);\r
\r
  if (StatusRegister & P30_SR_BIT_VPP) {\r
    DEBUG ((DEBUG_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 ((DEBUG_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 ((DEBUG_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 ((DEBUG_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
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
  // 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 ((DEBUG_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 ((DEBUG_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 ((DEBUG_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
  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
  } while ((WaitForBuffer > 0) && (BufferAvailable == FALSE));\r
\r
  // The buffer was not available for writing\r
  if (WaitForBuffer == 0) {\r
    return EFI_DEVICE_ERROR;\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
  // 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 ((DEBUG_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 ((DEBUG_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 ((DEBUG_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
  return Status;\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
  // 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->BlockSize));\r
  if ((BufferSizeInBytes % Instance->BlockSize) != 0) {\r
    return EFI_BAD_BUFFER_SIZE;\r
  }\r
\r
  // All blocks must be within the device\r
  NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->BlockSize;\r
\r
  DEBUG ((DEBUG_BLKIO, "NorFlashWriteBlocks: NumBlocks=%d, LastBlock=%ld, Lba=%ld.\n", NumBlocks, Instance->LastBlock, Lba));\r
\r
  if ((Lba + NumBlocks) > (Instance->LastBlock + 1)) {\r
    DEBUG ((DEBUG_ERROR, "NorFlashWriteBlocks: ERROR - Write will exceed last block.\n"));\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  BlockSizeInWords = Instance->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
    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
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 ((\r
    DEBUG_BLKIO,\r
    "NorFlashReadBlocks: BufferSize=0x%xB BlockSize=0x%xB LastBlock=%ld, Lba=%ld.\n",\r
    BufferSizeInBytes,\r
    Instance->BlockSize,\r
    Instance->LastBlock,\r
    Lba\r
    ));\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->BlockSize) != 0) {\r
    return EFI_BAD_BUFFER_SIZE;\r
  }\r
\r
  // All blocks must be within the device\r
  NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->BlockSize;\r
\r
  if ((Lba + NumBlocks) > (Instance->LastBlock + 1)) {\r
    DEBUG ((DEBUG_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 (\r
                   Instance->RegionBaseAddress,\r
                   Lba,\r
                   Instance->BlockSize\r
                   );\r
\r
  // Put the device into Read Array mode\r
  SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);\r
\r
  // Readout the data\r
  CopyMem (Buffer, (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->BlockSize) + Offset + BufferSizeInBytes) > Instance->Size) {\r
    DEBUG ((DEBUG_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 (\r
                   Instance->RegionBaseAddress,\r
                   Lba,\r
                   Instance->BlockSize\r
                   );\r
\r
  // Put the device into Read Array mode\r
  SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);\r
\r
  // Readout the data\r
  CopyMem (Buffer, (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->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  Status;\r
  UINTN       CurOffset;\r
  UINTN       BlockSize;\r
  UINTN       BlockAddress;\r
  UINT8       *OrigData;\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
  // Check we did get some memory. Buffer is BlockSize.\r
  if (Instance->ShadowBuffer == NULL) {\r
    DEBUG ((DEBUG_ERROR, "FvbWrite: ERROR - Buffer not ready\n"));\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  // Cache the block size to avoid de-referencing pointers all the time\r
  BlockSize = Instance->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
  {\r
    DEBUG ((DEBUG_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 ((DEBUG_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 P30_MAX_BUFFER_SIZE_IN_BYTES (== 128 bytes) as a good start for word\r
  // operations as opposed to erasing the block and writing the data regardless\r
  // if an erase is really needed.  It looks like most individual NV variable\r
  // writes are smaller than 128 bytes.\r
  // To avoid pathological cases were a 2 byte write is disregarded because it\r
  // occurs right at a 128 byte buffered write alignment boundary, permit up to\r
  // twice the max buffer size, and perform two writes if needed.\r
  if ((*NumBytes + (Offset & BOUNDARY_OF_32_WORDS)) <= (2 * P30_MAX_BUFFER_SIZE_IN_BYTES)) {\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
\r
    // Read the old version of the data into the shadow buffer\r
    Status = NorFlashRead (\r
               Instance,\r
               Lba,\r
               Offset & ~BOUNDARY_OF_32_WORDS,\r
               (*NumBytes | BOUNDARY_OF_32_WORDS) + 1,\r
               Instance->ShadowBuffer\r
               );\r
    if (EFI_ERROR (Status)) {\r
      return EFI_DEVICE_ERROR;\r
    }\r
\r
    // Make OrigData point to the start of the old version of the data inside\r
    // the word aligned buffer\r
    OrigData = Instance->ShadowBuffer + (Offset & BOUNDARY_OF_32_WORDS);\r
\r
    // Update the buffer containing the old version of the data with the new\r
    // contents, while checking whether the old version had any bits cleared\r
    // that we want to set. In that case, we will need to erase the block first.\r
    for (CurOffset = 0; CurOffset < *NumBytes; CurOffset++) {\r
      if (~OrigData[CurOffset] & Buffer[CurOffset]) {\r
        goto DoErase;\r
      }\r
\r
      OrigData[CurOffset] = Buffer[CurOffset];\r
    }\r
\r
    //\r
    // Write the updated buffer to NOR.\r
    //\r
    BlockAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, Lba, BlockSize);\r
\r
    // Unlock the block if we have to\r
    Status = NorFlashUnlockSingleBlockIfNecessary (Instance, BlockAddress);\r
    if (EFI_ERROR (Status)) {\r
      goto Exit;\r
    }\r
\r
    Status = NorFlashWriteBuffer (\r
               Instance,\r
               BlockAddress + (Offset & ~BOUNDARY_OF_32_WORDS),\r
               P30_MAX_BUFFER_SIZE_IN_BYTES,\r
               Instance->ShadowBuffer\r
               );\r
    if (EFI_ERROR (Status)) {\r
      goto Exit;\r
    }\r
\r
    if ((*NumBytes + (Offset & BOUNDARY_OF_32_WORDS)) > P30_MAX_BUFFER_SIZE_IN_BYTES) {\r
      BlockAddress += P30_MAX_BUFFER_SIZE_IN_BYTES;\r
\r
      Status = NorFlashWriteBuffer (\r
                 Instance,\r
                 BlockAddress + (Offset & ~BOUNDARY_OF_32_WORDS),\r
                 P30_MAX_BUFFER_SIZE_IN_BYTES,\r
                 Instance->ShadowBuffer + P30_MAX_BUFFER_SIZE_IN_BYTES\r
                 );\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
DoErase:\r
  // Read NOR Flash data into shadow buffer\r
  Status = NorFlashReadBlocks (Instance, Lba, BlockSize, Instance->ShadowBuffer);\r
  if (EFI_ERROR (Status)) {\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
  Status = NorFlashWriteBlocks (Instance, Lba, BlockSize, Instance->ShadowBuffer);\r
  if (EFI_ERROR (Status)) {\r
    // Return one of the pre-approved error statuses\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  return EFI_SUCCESS;\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 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