ArmPlatformPkg/Drivers/NorFlashDxe: Directly implement DiskIO protocol
authorBrendan Jackman <brendan.jackman@arm.com>
Thu, 8 May 2014 14:52:12 +0000 (14:52 +0000)
committeroliviermartin <oliviermartin@6f19259b-4bc3-4df7-8a09-765794883524>
Thu, 8 May 2014 14:52:12 +0000 (14:52 +0000)
This improves performance by accessing NOR with the fine granularity that
the hardware permits, rather than the coarse granularity assumed by DiskIoDxe.

Contributed-under: TianoCore Contribution Agreement 1.0
Signed-off-by: Brendan Jackman <brendan.jackman@arm.com>
Reviewed-by: Olivier Martin <olivier.martin@arm.com>
git-svn-id: https://svn.code.sf.net/p/edk2/code/trunk/edk2@15502 6f19259b-4bc3-4df7-8a09-765794883524

ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashDxe.c
ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashDxe.h
ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashDxe.inf
ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashFvbDxe.c

index 82b9f3f..7030a3c 100644 (file)
@@ -63,6 +63,12 @@ NOR_FLASH_INSTANCE  mNorFlashInstanceTemplate = {
     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
@@ -74,7 +80,7 @@ NOR_FLASH_INSTANCE  mNorFlashInstanceTemplate = {
     FvbEraseBlocks, // EraseBlocks\r
     NULL, //ParentHandle\r
   }, //  FvbProtoccol;\r
-  NULL, // FvbBuffer\r
+  NULL, // ShadowBuffer\r
   {\r
     {\r
       {\r
@@ -127,13 +133,14 @@ NorFlashCreateInstance (
 \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
-    Instance->FvbBuffer = AllocateRuntimePool (BlockSize);;\r
-    if (Instance->FvbBuffer == NULL) {\r
-      return EFI_OUT_OF_RESOURCES;\r
-    }\r
 \r
     Status = gBS->InstallMultipleProtocolInterfaces (\r
                   &Instance->Handle,\r
@@ -153,6 +160,7 @@ NorFlashCreateInstance (
                     &Instance->Handle,\r
                     &gEfiDevicePathProtocolGuid, &Instance->DevicePath,\r
                     &gEfiBlockIoProtocolGuid,  &Instance->BlockIoProtocol,\r
+                    &gEfiDiskIoProtocolGuid, &Instance->DiskIoProtocol,\r
                     NULL\r
                     );\r
     if (EFI_ERROR(Status)) {\r
@@ -379,6 +387,7 @@ NorFlashUnlockAndEraseSingleBlock (
 }\r
 \r
 \r
+STATIC\r
 EFI_STATUS\r
 NorFlashWriteSingleWord (\r
   IN NOR_FLASH_INSTANCE     *Instance,\r
@@ -570,8 +579,9 @@ EXIT:
   return Status;\r
 }\r
 \r
+STATIC\r
 EFI_STATUS\r
-NorFlashWriteSingleBlock (\r
+NorFlashWriteFullBlock (\r
   IN NOR_FLASH_INSTANCE     *Instance,\r
   IN EFI_LBA                Lba,\r
   IN UINT32                 *DataBuffer,\r
@@ -731,7 +741,7 @@ NorFlashWriteBlocks (
 \r
     DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: Writing block #%d\n", (UINTN)CurrentBlock));\r
 \r
-    Status = NorFlashWriteSingleBlock (Instance, CurrentBlock, pWriteBuffer, BlockSizeInWords);\r
+    Status = NorFlashWriteFullBlock (Instance, CurrentBlock, pWriteBuffer, BlockSizeInWords);\r
 \r
     if (EFI_ERROR(Status)) {\r
       break;\r
@@ -761,7 +771,7 @@ NorFlashReadBlocks (
     return EFI_INVALID_PARAMETER;\r
   }\r
 \r
-  // Return if we have not any byte to read \r
+  // Return if we have not any byte to read\r
   if (BufferSizeInBytes == 0) {\r
     return EFI_SUCCESS;\r
   }\r
@@ -844,6 +854,339 @@ NorFlashRead (
   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", Instance->StartLba + 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, Instance->StartLba + Lba,\r
+                                 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, Instance->StartLba + 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, Instance->StartLba + 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
@@ -891,8 +1234,8 @@ NorFlashVirtualNotifyEvent (
     EfiConvertPointer (0x0, (VOID**)&mNorFlashInstances[Index]->FvbProtocol.SetAttributes);\r
     EfiConvertPointer (0x0, (VOID**)&mNorFlashInstances[Index]->FvbProtocol.Write);\r
 \r
-    if (mNorFlashInstances[Index]->FvbBuffer != NULL) {\r
-      EfiConvertPointer (0x0, (VOID**)&mNorFlashInstances[Index]->FvbBuffer);\r
+    if (mNorFlashInstances[Index]->ShadowBuffer != NULL) {\r
+      EfiConvertPointer (0x0, (VOID**)&mNorFlashInstances[Index]->ShadowBuffer);\r
     }\r
   }\r
 \r
index 6c8cea2..a6854aa 100644 (file)
@@ -22,6 +22,7 @@
 #include <Guid/EventGroup.h>\r
 \r
 #include <Protocol/BlockIo.h>\r
+#include <Protocol/DiskIo.h>\r
 #include <Protocol/FirmwareVolumeBlock.h>\r
 \r
 #include <Library/DebugLib.h>\r
 #define NOR_FLASH_SIGNATURE                       SIGNATURE_32('n', 'o', 'r', '0')\r
 #define INSTANCE_FROM_FVB_THIS(a)                 CR(a, NOR_FLASH_INSTANCE, FvbProtocol, NOR_FLASH_SIGNATURE)\r
 #define INSTANCE_FROM_BLKIO_THIS(a)               CR(a, NOR_FLASH_INSTANCE, BlockIoProtocol, NOR_FLASH_SIGNATURE)\r
+#define INSTANCE_FROM_DISKIO_THIS(a)              CR(a, NOR_FLASH_INSTANCE, DiskIoProtocol, NOR_FLASH_SIGNATURE)\r
 \r
 typedef struct _NOR_FLASH_INSTANCE                NOR_FLASH_INSTANCE;\r
 \r
@@ -141,10 +143,11 @@ struct _NOR_FLASH_INSTANCE {
 \r
   EFI_BLOCK_IO_PROTOCOL               BlockIoProtocol;\r
   EFI_BLOCK_IO_MEDIA                  Media;\r
+  EFI_DISK_IO_PROTOCOL                DiskIoProtocol;\r
 \r
   BOOLEAN                             SupportFvb;\r
   EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL FvbProtocol;\r
-  VOID*                               FvbBuffer;\r
+  VOID*                               ShadowBuffer;\r
 \r
   NOR_FLASH_DEVICE_PATH                      DevicePath;\r
 };\r
@@ -210,6 +213,31 @@ NorFlashBlockIoFlushBlocks (
   IN EFI_BLOCK_IO_PROTOCOL    *This\r
 );\r
 \r
+//\r
+// DiskIO Protocol function EFI_DISK_IO_PROTOCOL.ReadDisk\r
+//\r
+EFI_STATUS\r
+EFIAPI\r
+NorFlashDiskIoReadDisk (\r
+  IN EFI_DISK_IO_PROTOCOL         *This,\r
+  IN UINT32                       MediaId,\r
+  IN UINT64                       Offset,\r
+  IN UINTN                        BufferSize,\r
+  OUT VOID                        *Buffer\r
+  );\r
+\r
+//\r
+// DiskIO Protocol function EFI_DISK_IO_PROTOCOL.WriteDisk\r
+//\r
+EFI_STATUS\r
+EFIAPI\r
+NorFlashDiskIoWriteDisk (\r
+  IN EFI_DISK_IO_PROTOCOL         *This,\r
+  IN UINT32                       MediaId,\r
+  IN UINT64                       Offset,\r
+  IN UINTN                        BufferSize,\r
+  IN VOID                         *Buffer\r
+  );\r
 \r
 //\r
 // NorFlashFvbDxe.c\r
@@ -290,10 +318,11 @@ NorFlashUnlockAndEraseSingleBlock (
 \r
 EFI_STATUS\r
 NorFlashWriteSingleBlock (\r
-  IN NOR_FLASH_INSTANCE     *Instance,\r
-  IN EFI_LBA                Lba,\r
-  IN UINT32                 *DataBuffer,\r
-  IN UINT32                 BlockSizeInWords\r
+  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\r
@@ -304,13 +333,6 @@ NorFlashWriteBlocks (
   IN  VOID              *Buffer\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\r
 NorFlashReadBlocks (\r
   IN NOR_FLASH_INSTANCE   *Instance,\r
@@ -328,6 +350,15 @@ NorFlashRead (
   OUT VOID                *Buffer\r
   );\r
 \r
+EFI_STATUS\r
+NorFlashWrite (\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\r
 NorFlashReset (\r
   IN  NOR_FLASH_INSTANCE *Instance\r
index a2eb27e..3003e12 100644 (file)
@@ -53,6 +53,7 @@
   gEfiBlockIoProtocolGuid\r
   gEfiDevicePathProtocolGuid\r
   gEfiFirmwareVolumeBlockProtocolGuid\r
+  gEfiDiskIoProtocolGuid\r
   \r
 [Pcd.common]\r
   gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase\r
index 9ad0e14..bf42085 100644 (file)
@@ -531,201 +531,11 @@ FvbWrite (
   IN        UINT8                                 *Buffer\r
   )\r
 {\r
-  EFI_STATUS  TempStatus;\r
-  UINT32      Tmp;\r
-  UINT32      TmpBuf;\r
-  UINT32      WordToWrite;\r
-  UINT32      Mask;\r
-  UINTN       DoErase;\r
-  UINTN       BytesToWrite;\r
-  UINTN       CurOffset;\r
-  UINTN       WordAddr;\r
-  UINTN       BlockSize;\r
   NOR_FLASH_INSTANCE *Instance;\r
-  UINTN       BlockAddress;\r
-  UINTN       PrevBlockAddress;\r
 \r
-  PrevBlockAddress = 0;\r
+  Instance = INSTANCE_FROM_FVB_THIS (This);\r
 \r
-  Instance = INSTANCE_FROM_FVB_THIS(This);\r
-\r
-  if (!Instance->Initialized && Instance->Initialize) {\r
-    Instance->Initialize(Instance);\r
-  }\r
-\r
-  DEBUG ((DEBUG_BLKIO, "FvbWrite(Parameters: Lba=%ld, Offset=0x%x, *NumBytes=0x%x, Buffer @ 0x%08x)\n", Instance->StartLba + Lba, Offset, *NumBytes, Buffer));\r
-\r
-  // Detect WriteDisabled state\r
-  if (Instance->Media.ReadOnly == TRUE) {\r
-    DEBUG ((EFI_D_ERROR, "FvbWrite: 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, "FvbWrite: 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, "FvbWrite: 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 = 0;\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, Instance->StartLba + Lba,\r
-                                 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 = 1;\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 = 1;\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 = (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 = 1;\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 = 1;\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->FvbBuffer == 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, Instance->StartLba + Lba, BlockSize, Instance->FvbBuffer);\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->FvbBuffer + Offset), Buffer, *NumBytes);\r
-\r
-  // Write the modified buffer back to the NorFlash\r
-  TempStatus = NorFlashWriteBlocks (Instance, Instance->StartLba + Lba, BlockSize, Instance->FvbBuffer);\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
+  return NorFlashWriteSingleBlock (Instance, Lba, Offset, NumBytes, Buffer);\r
 }\r
 \r
 /**\r