//\r
// Global variable declarations\r
//\r
-extern NOR_FLASH_INSTANCE **mNorFlashInstances;\r
-extern UINT32 mNorFlashDeviceCount;\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
+ IN NOR_FLASH_INSTANCE *Instance,\r
+ IN UINTN SR_Address\r
)\r
{\r
// Prepare to read the status register\r
STATIC\r
BOOLEAN\r
NorFlashBlockIsLocked (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN BlockAddress\r
+ IN NOR_FLASH_INSTANCE *Instance,\r
+ IN UINTN BlockAddress\r
)\r
{\r
- UINT32 LockStatus;\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
+ LockStatus = MmioRead32 (CREATE_NOR_ADDRESS (BlockAddress, 2));\r
\r
// Decode block lock status\r
- LockStatus = FOLD_32BIT_INTO_16BIT(LockStatus);\r
+ LockStatus = FOLD_32BIT_INTO_16BIT (LockStatus);\r
\r
if ((LockStatus & 0x2) != 0) {\r
- DEBUG((DEBUG_ERROR, "NorFlashBlockIsLocked: WARNING: Block LOCKED DOWN\n"));\r
+ DEBUG ((DEBUG_ERROR, "NorFlashBlockIsLocked: WARNING: Block LOCKED DOWN\n"));\r
}\r
\r
return ((LockStatus & 0x1) != 0);\r
STATIC\r
EFI_STATUS\r
NorFlashUnlockSingleBlock (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN BlockAddress\r
+ IN NOR_FLASH_INSTANCE *Instance,\r
+ IN UINTN BlockAddress\r
)\r
{\r
- UINT32 LockStatus;\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
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
+ LockStatus = MmioRead32 (CREATE_NOR_ADDRESS (BlockAddress, 2));\r
\r
// Decode block lock status\r
- LockStatus = FOLD_32BIT_INTO_16BIT(LockStatus);\r
+ LockStatus = FOLD_32BIT_INTO_16BIT (LockStatus);\r
} while ((LockStatus & 0x1) == 1);\r
} else {\r
// Request a lock setup\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
+ 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
+ IN NOR_FLASH_INSTANCE *Instance,\r
+ IN UINTN BlockAddress\r
)\r
{\r
- EFI_STATUS Status;\r
+ EFI_STATUS Status;\r
\r
Status = EFI_SUCCESS;\r
\r
return Status;\r
}\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
+ IN NOR_FLASH_INSTANCE *Instance,\r
+ IN UINTN BlockAddress\r
)\r
{\r
- EFI_STATUS Status;\r
- UINT32 StatusRegister;\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
+ 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
} 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
+ 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
+ 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
+ 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
+ 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
+ if (EFI_ERROR (Status)) {\r
// Clear the Status Register\r
SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER);\r
}\r
\r
EFI_STATUS\r
NorFlashWriteSingleWord (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN WordAddress,\r
- IN UINT32 WriteData\r
+ IN NOR_FLASH_INSTANCE *Instance,\r
+ IN UINTN WordAddress,\r
+ IN UINT32 WriteData\r
)\r
{\r
- EFI_STATUS Status;\r
- UINT32 StatusRegister;\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
+ SEND_NOR_COMMAND (WordAddress, 0, P30_CMD_WORD_PROGRAM_SETUP);\r
\r
// Store the word into NOR Flash;\r
MmioWrite32 (WordAddress, WriteData);\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((DEBUG_ERROR,"NorFlashWriteSingleWord(WordAddress:0x%X): VPP Range Error\n",WordAddress));\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
+ 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
+ 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
+ if (!EFI_ERROR (Status)) {\r
// Clear the Status Register\r
SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER);\r
}\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
+ 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
+ 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
// 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
+ 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
\r
// Update the loop counter\r
WaitForBuffer--;\r
-\r
} while ((WaitForBuffer > 0) && (BufferAvailable == FALSE));\r
\r
// The buffer was not available for writing\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
+ 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
+ for (Count = 0; Count < BufferSizeInWords; Count++, Data++, Buffer++) {\r
MmioWrite32 ((UINTN)Data, *Buffer);\r
}\r
\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
+ 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
+ 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
+ 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
+ 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
+ if (!EFI_ERROR (Status)) {\r
// Clear the Status Register\r
SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER);\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
+ 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
+ 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
return EFI_INVALID_PARAMETER;\r
}\r
\r
- if(Instance->Media.ReadOnly == TRUE) {\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
+ 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
+ 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
+ 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
+ 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((DEBUG_ERROR, "NorFlashWriteBlocks: ERROR - Write will exceed last block.\n"));\r
+ DEBUG ((DEBUG_ERROR, "NorFlashWriteBlocks: ERROR - Write will exceed last block.\n"));\r
return EFI_INVALID_PARAMETER;\r
}\r
\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
+ 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
+ if (EFI_ERROR (Status)) {\r
break;\r
}\r
}\r
\r
- DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: Exit Status = \"%r\".\n", Status));\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
+#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
STATIC\r
VOID *\r
AlignedCopyMem (\r
- OUT VOID *DestinationBuffer,\r
- IN CONST VOID *SourceBuffer,\r
- IN UINTN Length\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
+ 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
+ Source64 = SourceBuffer;\r
while (Length >= 8) {\r
*Destination64++ = *Source64++;\r
- Length -= 8;\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
+ Source8 = (CONST UINT8 *)Source64;\r
+ } else if (BOTH_ALIGNED (DestinationBuffer, SourceBuffer, 4) && (Length >= 4)) {\r
Destination32 = DestinationBuffer;\r
- Source32 = SourceBuffer;\r
+ Source32 = SourceBuffer;\r
while (Length >= 4) {\r
*Destination32++ = *Source32++;\r
- Length -= 4;\r
+ Length -= 4;\r
}\r
\r
Destination8 = (UINT8 *)Destination32;\r
- Source8 = (CONST UINT8 *)Source32;\r
+ Source8 = (CONST UINT8 *)Source32;\r
} else {\r
Destination8 = DestinationBuffer;\r
- Source8 = SourceBuffer;\r
+ Source8 = SourceBuffer;\r
}\r
+\r
while (Length-- != 0) {\r
*Destination8++ = *Source8++;\r
}\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
+ 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
+ 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->Media.BlockSize,\r
+ Instance->Media.LastBlock,\r
+ Lba\r
+ ));\r
\r
// The buffer must be valid\r
if (Buffer == NULL) {\r
}\r
\r
// All blocks must be within the device\r
- NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->Media.BlockSize ;\r
+ NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->Media.BlockSize;\r
\r
if ((Lba + NumBlocks) > (Instance->Media.LastBlock + 1)) {\r
- DEBUG((DEBUG_ERROR, "NorFlashReadBlocks: ERROR - Read will exceed last block\n"));\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 (Instance->RegionBaseAddress,\r
- Lba,\r
- Instance->Media.BlockSize\r
- );\r
+ StartAddress = GET_NOR_BLOCK_ADDRESS (\r
+ 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
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
+ 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
\r
// Get the address to start reading from\r
- StartAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress,\r
- Lba,\r
- Instance->Media.BlockSize\r
- );\r
+ StartAddress = GET_NOR_BLOCK_ADDRESS (\r
+ 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
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
+ 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
\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 ((DEBUG_ERROR, "NorFlashWriteSingleBlock: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", Offset, *NumBytes, BlockSize ));\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
+ 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
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
+ 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
+ WordAddr = (CurOffset & ~(0x3)) + GET_NOR_BLOCK_ADDRESS (\r
+ Instance->RegionBaseAddress,\r
+ Lba,\r
+ BlockSize\r
+ );\r
// The word of data that is to be written.\r
- TmpBuf = *((UINT32*)(Buffer + (*NumBytes - BytesToWrite)));\r
+ TmpBuf = *((UINT32 *)(Buffer + (*NumBytes - BytesToWrite)));\r
\r
// First do word aligned chunks.\r
if ((CurOffset & 0x3) == 0) {\r
break;\r
}\r
}\r
+\r
// Write this word to NOR\r
- WordToWrite = TmpBuf;\r
- CurOffset += sizeof(TmpBuf);\r
- BytesToWrite -= sizeof(TmpBuf);\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
break;\r
}\r
}\r
+\r
// Merge old and new data. Write merged word to NOR\r
- WordToWrite = (Tmp & ~Mask) | TmpBuf;\r
- CurOffset += BytesToWrite;\r
+ WordToWrite = (Tmp & ~Mask) | TmpBuf;\r
+ CurOffset += BytesToWrite;\r
BytesToWrite = 0;\r
}\r
} else {\r
break;\r
}\r
}\r
+\r
// Merge old and new data. Write merged word to NOR\r
- WordToWrite = (Tmp & ~Mask) | TmpBuf;\r
+ WordToWrite = (Tmp & ~Mask) | TmpBuf;\r
BytesToWrite -= (4 - (CurOffset & 0x3));\r
- CurOffset += (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
break;\r
}\r
}\r
+\r
// Merge old and new data. Write merged word to NOR\r
- WordToWrite = (Tmp & ~Mask) | TmpBuf;\r
- CurOffset += BytesToWrite;\r
+ WordToWrite = (Tmp & ~Mask) | TmpBuf;\r
+ CurOffset += BytesToWrite;\r
BytesToWrite = 0;\r
}\r
}\r
if (EFI_ERROR (TempStatus)) {\r
return EFI_DEVICE_ERROR;\r
}\r
+\r
PrevBlockAddress = BlockAddress;\r
}\r
+\r
TempStatus = NorFlashWriteSingleWord (Instance, WordAddr, WordToWrite);\r
if (EFI_ERROR (TempStatus)) {\r
return EFI_DEVICE_ERROR;\r
}\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
}\r
\r
// Put the data at the appropriate location inside the buffer area\r
- CopyMem ((VOID*)((UINTN)Instance->ShadowBuffer + Offset), Buffer, *NumBytes);\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
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
+ 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
+ NOR_FLASH_INSTANCE *Instance;\r
UINT32 BlockSize;\r
UINT32 BlockOffset;\r
EFI_LBA Lba;\r
\r
- Instance = INSTANCE_FROM_DISKIO_THIS(This);\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
+ Lba = (EFI_LBA)DivU64x32Remainder (DiskOffset, BlockSize, &BlockOffset);\r
\r
return NorFlashRead (Instance, Lba, BlockOffset, BufferSize, Buffer);\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
+ 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
+ NOR_FLASH_INSTANCE *Instance;\r
UINT32 BlockSize;\r
UINT32 BlockOffset;\r
EFI_LBA Lba;\r
UINTN WriteSize;\r
EFI_STATUS Status;\r
\r
- Instance = INSTANCE_FROM_DISKIO_THIS(This);\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
+ Lba = (EFI_LBA)DivU64x32Remainder (DiskOffset, BlockSize, &BlockOffset);\r
\r
RemainingBytes = BufferSize;\r
\r
// Write a partial block\r
Status = NorFlashWriteSingleBlock (Instance, Lba, BlockOffset, &WriteSize, Buffer);\r
}\r
+\r
if (EFI_ERROR (Status)) {\r
return Status;\r
}\r
+\r
// Now continue writing either all the remaining bytes or single blocks.\r
RemainingBytes -= WriteSize;\r
- Buffer = (UINT8 *) Buffer + WriteSize;\r
+ Buffer = (UINT8 *)Buffer + WriteSize;\r
Lba++;\r
BlockOffset = 0;\r
- WriteSize = MIN (RemainingBytes, BlockSize);\r
+ WriteSize = MIN (RemainingBytes, BlockSize);\r
} while (RemainingBytes);\r
\r
return Status;\r
\r
EFI_STATUS\r
NorFlashReset (\r
- IN NOR_FLASH_INSTANCE *Instance\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
VOID\r
EFIAPI\r
NorFlashVirtualNotifyEvent (\r
- IN EFI_EVENT Event,\r
- IN VOID *Context\r
+ IN EFI_EVENT Event,\r
+ IN VOID *Context\r
)\r
{\r
- UINTN Index;\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
+ 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
+ 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
+ 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
+ EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->ShadowBuffer);\r
}\r
}\r
\r
projects / mirror_edk2.git / blobdiff