+/*\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