[mirror_edk2.git] / Omap35xxPkg / Flash / Flash.c

/** @file\r
\r
  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>\r
\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "Flash.h"\r
\r
NAND_PART_INFO_TABLE gNandPartInfoTable[1] = {\r
  { 0x2C, 0xBA, 17, 11 }\r
};\r
\r
NAND_FLASH_INFO *gNandFlashInfo = NULL;\r
UINT8           *gEccCode;\r
UINTN           gNum512BytesChunks = 0;\r
\r
//\r
\r
// Device path for SemiHosting. It contains our autogened Caller ID GUID.\r
\r
//\r
\r
typedef struct {\r
\r
  VENDOR_DEVICE_PATH        Guid;\r
\r
  EFI_DEVICE_PATH_PROTOCOL  End;\r
\r
} FLASH_DEVICE_PATH;\r
\r
\r
\r
FLASH_DEVICE_PATH gDevicePath = {\r
  {\r
    { HARDWARE_DEVICE_PATH, HW_VENDOR_DP, { sizeof (VENDOR_DEVICE_PATH), 0 } },\r
    EFI_CALLER_ID_GUID\r
  },\r
  { END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE, { sizeof (EFI_DEVICE_PATH_PROTOCOL), 0} }\r
};\r
\r
\r
\r
//Actual page address = Column address + Page address + Block address.\r
UINTN\r
GetActualPageAddressInBytes (\r
  UINTN BlockIndex,\r
  UINTN PageIndex\r
)\r
{\r
  //BlockAddressStart = Start of the Block address in actual NAND\r
  //PageAddressStart = Start of the Page address in actual NAND\r
  return ((BlockIndex << gNandFlashInfo->BlockAddressStart) + (PageIndex << gNandFlashInfo->PageAddressStart));\r
}\r
\r
VOID\r
NandSendCommand (\r
  UINT8 Command\r
)\r
{\r
  MmioWrite16(GPMC_NAND_COMMAND_0, Command);\r
}\r
\r
VOID\r
NandSendAddress (\r
  UINT8 Address\r
)\r
{\r
  MmioWrite16(GPMC_NAND_ADDRESS_0, Address);\r
}\r
\r
UINT16\r
NandReadStatus (\r
  VOID\r
  )\r
{\r
  //Send READ STATUS command\r
  NandSendCommand(READ_STATUS_CMD);\r
\r
  //Read status.\r
  return MmioRead16(GPMC_NAND_DATA_0);\r
}\r
\r
VOID\r
NandSendAddressCycles (\r
  UINTN Address\r
)\r
{\r
  //Column address\r
  NandSendAddress(Address & 0xff);\r
  Address >>= 8;\r
\r
  //Column address\r
  NandSendAddress(Address & 0x07);\r
  Address >>= 3;\r
\r
  //Page and Block address\r
  NandSendAddress(Address & 0xff);\r
  Address >>= 8;\r
\r
  //Block address\r
  NandSendAddress(Address & 0xff);\r
  Address >>= 8;\r
\r
  //Block address\r
  NandSendAddress(Address & 0x01);\r
}\r
\r
VOID\r
GpmcInit (\r
  VOID\r
  )\r
{\r
  //Enable Smart-idle mode.\r
  MmioWrite32 (GPMC_SYSCONFIG, SMARTIDLEMODE);\r
\r
  //Set IRQSTATUS and IRQENABLE to the reset value\r
  MmioWrite32 (GPMC_IRQSTATUS, 0x0);\r
  MmioWrite32 (GPMC_IRQENABLE, 0x0);\r
\r
  //Disable GPMC timeout control.\r
  MmioWrite32 (GPMC_TIMEOUT_CONTROL, TIMEOUTDISABLE);\r
\r
  //Set WRITEPROTECT bit to enable write access.\r
  MmioWrite32 (GPMC_CONFIG, WRITEPROTECT_HIGH);\r
\r
  //NOTE: Following GPMC_CONFIGi_0 register settings are taken from u-boot memory dump.\r
  MmioWrite32 (GPMC_CONFIG1_0, DEVICETYPE_NAND | DEVICESIZE_X16);\r
  MmioWrite32 (GPMC_CONFIG2_0, CSRDOFFTIME | CSWROFFTIME);\r
  MmioWrite32 (GPMC_CONFIG3_0, ADVRDOFFTIME | ADVWROFFTIME);\r
  MmioWrite32 (GPMC_CONFIG4_0, OEONTIME | OEOFFTIME | WEONTIME | WEOFFTIME);\r
  MmioWrite32 (GPMC_CONFIG5_0, RDCYCLETIME | WRCYCLETIME | RDACCESSTIME | PAGEBURSTACCESSTIME);\r
  MmioWrite32 (GPMC_CONFIG6_0, WRACCESSTIME | WRDATAONADMUXBUS | CYCLE2CYCLEDELAY | CYCLE2CYCLESAMECSEN);\r
  MmioWrite32 (GPMC_CONFIG7_0, MASKADDRESS_128MB | CSVALID | BASEADDRESS);\r
}\r
\r
EFI_STATUS\r
NandDetectPart (\r
  VOID\r
)\r
{\r
  UINT8      NandInfo = 0;\r
  UINT8      PartInfo[5];\r
  UINTN      Index;\r
  BOOLEAN    Found = FALSE;\r
\r
  //Send READ ID command\r
  NandSendCommand(READ_ID_CMD);\r
\r
  //Send one address cycle.\r
  NandSendAddress(0);\r
\r
  //Read 5-bytes to idenfity code programmed into the NAND flash devices.\r
  //BYTE 0 = Manufacture ID\r
  //Byte 1 = Device ID\r
  //Byte 2, 3, 4 = Nand part specific information (Page size, Block size etc)\r
  for (Index = 0; Index < sizeof(PartInfo); Index++) {\r
    PartInfo[Index] = MmioRead16(GPMC_NAND_DATA_0);\r
  }\r
\r
  //Check if the ManufactureId and DeviceId are part of the currently supported nand parts.\r
  for (Index = 0; Index < sizeof(gNandPartInfoTable)/sizeof(NAND_PART_INFO_TABLE); Index++) {\r
    if (gNandPartInfoTable[Index].ManufactureId == PartInfo[0] && gNandPartInfoTable[Index].DeviceId == PartInfo[1]) {\r
      gNandFlashInfo->BlockAddressStart = gNandPartInfoTable[Index].BlockAddressStart;\r
      gNandFlashInfo->PageAddressStart = gNandPartInfoTable[Index].PageAddressStart;\r
      Found = TRUE;\r
      break;\r
    }\r
  }\r
\r
  if (Found == FALSE) {\r
    DEBUG ((EFI_D_ERROR, "Nand part is not currently supported. Manufacture id: %x, Device id: %x\n", PartInfo[0], PartInfo[1]));\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  //Populate NAND_FLASH_INFO based on the result of READ ID command.\r
  gNandFlashInfo->ManufactureId = PartInfo[0];\r
  gNandFlashInfo->DeviceId = PartInfo[1];\r
  NandInfo = PartInfo[3];\r
\r
  if (PAGE_SIZE(NandInfo) == PAGE_SIZE_2K_VAL) {\r
    gNandFlashInfo->PageSize = PAGE_SIZE_2K;\r
  } else {\r
    DEBUG ((EFI_D_ERROR, "Unknown Page size.\n"));\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  if (SPARE_AREA_SIZE(NandInfo) == SPARE_AREA_SIZE_64B_VAL) {\r
    gNandFlashInfo->SparePageSize = SPARE_AREA_SIZE_64B;\r
  } else {\r
    DEBUG ((EFI_D_ERROR, "Unknown Spare area size.\n"));\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  if (BLOCK_SIZE(NandInfo) == BLOCK_SIZE_128K_VAL) {\r
    gNandFlashInfo->BlockSize = BLOCK_SIZE_128K;\r
  } else {\r
    DEBUG ((EFI_D_ERROR, "Unknown Block size.\n"));\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  if (ORGANIZATION(NandInfo) == ORGANIZATION_X8) {\r
    gNandFlashInfo->Organization = 0;\r
  } else if (ORGANIZATION(NandInfo) == ORGANIZATION_X16) {\r
    gNandFlashInfo->Organization = 1;\r
  }\r
\r
  //Calculate total number of blocks.\r
  gNandFlashInfo->NumPagesPerBlock = DivU64x32(gNandFlashInfo->BlockSize, gNandFlashInfo->PageSize);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
VOID\r
NandConfigureEcc (\r
  VOID\r
  )\r
{\r
  //Define ECC size 0 and size 1 to 512 bytes\r
  MmioWrite32 (GPMC_ECC_SIZE_CONFIG, (ECCSIZE0_512BYTES | ECCSIZE1_512BYTES));\r
}\r
\r
VOID\r
NandEnableEcc (\r
  VOID\r
  )\r
{\r
  //Clear all the ECC result registers and select ECC result register 1\r
  MmioWrite32 (GPMC_ECC_CONTROL, (ECCCLEAR | ECCPOINTER_REG1));\r
\r
  //Enable ECC engine on CS0\r
  MmioWrite32 (GPMC_ECC_CONFIG, (ECCENABLE | ECCCS_0 | ECC16B));\r
}\r
\r
VOID\r
NandDisableEcc (\r
  VOID\r
  )\r
{\r
  //Turn off ECC engine.\r
  MmioWrite32 (GPMC_ECC_CONFIG, ECCDISABLE);\r
}\r
\r
VOID\r
NandCalculateEcc (\r
  VOID\r
  )\r
{\r
  UINTN Index;\r
  UINTN EccResultRegister;\r
  UINTN EccResult;\r
\r
  //Capture 32-bit ECC result for each 512-bytes chunk.\r
  //In our case PageSize is 2K so read ECC1-ECC4 result registers and\r
  //generate total of 12-bytes of ECC code for the particular page.\r
\r
  EccResultRegister = GPMC_ECC1_RESULT;\r
\r
  for (Index = 0; Index < gNum512BytesChunks; Index++) {\r
\r
    EccResult = MmioRead32 (EccResultRegister);\r
\r
    //Calculate ECC code from 32-bit ECC result value.\r
    //NOTE: Following calculation is not part of TRM. We got this information\r
    //from Beagleboard mailing list.\r
    gEccCode[Index * 3] = EccResult & 0xFF;\r
    gEccCode[(Index * 3) + 1] = (EccResult >> 16) & 0xFF;\r
    gEccCode[(Index * 3) + 2] = (((EccResult >> 20) & 0xF0) | ((EccResult >> 8) & 0x0F));\r
\r
    //Point to next ECC result register.\r
    EccResultRegister += 4;\r
  }\r
}\r
\r
EFI_STATUS\r
NandReadPage (\r
  IN  UINTN                         BlockIndex,\r
  IN  UINTN                         PageIndex,\r
  OUT VOID                          *Buffer,\r
  OUT UINT8                         *SpareBuffer\r
)\r
{\r
  UINTN      Address;\r
  UINTN      Index;\r
  UINTN      NumMainAreaWords = (gNandFlashInfo->PageSize/2);\r
  UINTN      NumSpareAreaWords = (gNandFlashInfo->SparePageSize/2);\r
  UINT16     *MainAreaWordBuffer = Buffer;\r
  UINT16     *SpareAreaWordBuffer = (UINT16 *)SpareBuffer;\r
  UINTN      Timeout = MAX_RETRY_COUNT;\r
\r
  //Generate device address in bytes to access specific block and page index\r
  Address = GetActualPageAddressInBytes(BlockIndex, PageIndex);\r
\r
  //Send READ command\r
  NandSendCommand(PAGE_READ_CMD);\r
\r
  //Send 5 Address cycles to access specific device address\r
  NandSendAddressCycles(Address);\r
\r
  //Send READ CONFIRM command\r
  NandSendCommand(PAGE_READ_CONFIRM_CMD);\r
\r
  //Poll till device is busy.\r
  while (Timeout) {\r
    if ((NandReadStatus() & NAND_READY) == NAND_READY) {\r
      break;\r
    }\r
    Timeout--;\r
  }\r
\r
  if (Timeout == 0) {\r
    DEBUG ((EFI_D_ERROR, "Read page timed out.\n"));\r
    return EFI_TIMEOUT;\r
  }\r
\r
  //Reissue READ command\r
  NandSendCommand(PAGE_READ_CMD);\r
\r
  //Enable ECC engine.\r
  NandEnableEcc();\r
\r
  //Read data into the buffer.\r
  for (Index = 0; Index < NumMainAreaWords; Index++) {\r
    *MainAreaWordBuffer++ = MmioRead16(GPMC_NAND_DATA_0);\r
  }\r
\r
  //Read spare area into the buffer.\r
  for (Index = 0; Index < NumSpareAreaWords; Index++) {\r
    *SpareAreaWordBuffer++ = MmioRead16(GPMC_NAND_DATA_0);\r
  }\r
\r
  //Calculate ECC.\r
  NandCalculateEcc();\r
\r
  //Turn off ECC engine.\r
  NandDisableEcc();\r
\r
  //Perform ECC correction.\r
  //Need to implement..\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
NandWritePage (\r
  IN  UINTN                         BlockIndex,\r
  IN  UINTN                         PageIndex,\r
  OUT VOID                          *Buffer,\r
  IN  UINT8                         *SpareBuffer\r
)\r
{\r
  UINTN      Address;\r
  UINT16     *MainAreaWordBuffer = Buffer;\r
  UINT16     *SpareAreaWordBuffer = (UINT16 *)SpareBuffer;\r
  UINTN      Index;\r
  UINTN      NandStatus;\r
  UINTN      Timeout = MAX_RETRY_COUNT;\r
\r
  //Generate device address in bytes to access specific block and page index\r
  Address = GetActualPageAddressInBytes(BlockIndex, PageIndex);\r
\r
  //Send SERIAL DATA INPUT command\r
  NandSendCommand(PROGRAM_PAGE_CMD);\r
\r
  //Send 5 Address cycles to access specific device address\r
  NandSendAddressCycles(Address);\r
\r
  //Enable ECC engine.\r
  NandEnableEcc();\r
\r
  //Data input from Buffer\r
  for (Index = 0; Index < (gNandFlashInfo->PageSize/2); Index++) {\r
    MmioWrite16(GPMC_NAND_DATA_0, *MainAreaWordBuffer++);\r
\r
    //After each write access, device has to wait to accept data.\r
    //Currently we may not be programming proper timing parameters to\r
    //the GPMC_CONFIGi_0 registers and we would need to figure that out.\r
    //Without following delay, page programming fails.\r
    gBS->Stall(1);\r
  }\r
\r
  //Calculate ECC.\r
  NandCalculateEcc();\r
\r
  //Turn off ECC engine.\r
  NandDisableEcc();\r
\r
  //Prepare Spare area buffer with ECC codes.\r
  SetMem(SpareBuffer, gNandFlashInfo->SparePageSize, 0xFF);\r
  CopyMem(&SpareBuffer[ECC_POSITION], gEccCode, gNum512BytesChunks * 3);\r
\r
  //Program spare area with calculated ECC.\r
  for (Index = 0; Index < (gNandFlashInfo->SparePageSize/2); Index++) {\r
    MmioWrite16(GPMC_NAND_DATA_0, *SpareAreaWordBuffer++);\r
  }\r
\r
  //Send PROGRAM command\r
  NandSendCommand(PROGRAM_PAGE_CONFIRM_CMD);\r
\r
  //Poll till device is busy.\r
  NandStatus = 0;\r
  while (Timeout) {\r
    NandStatus = NandReadStatus();\r
    if ((NandStatus & NAND_READY) == NAND_READY) {\r
      break;\r
    }\r
    Timeout--;\r
  }\r
\r
  if (Timeout == 0) {\r
    DEBUG ((EFI_D_ERROR, "Program page timed out.\n"));\r
    return EFI_TIMEOUT;\r
  }\r
\r
  //Bit0 indicates Pass/Fail status\r
  if (NandStatus & NAND_FAILURE) {\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
NandEraseBlock (\r
  IN UINTN BlockIndex\r
)\r
{\r
  UINTN      Address;\r
  UINTN      NandStatus;\r
  UINTN      Timeout = MAX_RETRY_COUNT;\r
\r
  //Generate device address in bytes to access specific block and page index\r
  Address = GetActualPageAddressInBytes(BlockIndex, 0);\r
\r
  //Send ERASE SETUP command\r
  NandSendCommand(BLOCK_ERASE_CMD);\r
\r
  //Send 3 address cycles to device to access Page address and Block address\r
  Address >>= 11; //Ignore column addresses\r
\r
  NandSendAddress(Address & 0xff);\r
  Address >>= 8;\r
\r
  NandSendAddress(Address & 0xff);\r
  Address >>= 8;\r
\r
  NandSendAddress(Address & 0xff);\r
\r
  //Send ERASE CONFIRM command\r
  NandSendCommand(BLOCK_ERASE_CONFIRM_CMD);\r
\r
  //Poll till device is busy.\r
  NandStatus = 0;\r
  while (Timeout) {\r
    NandStatus = NandReadStatus();\r
    if ((NandStatus & NAND_READY) == NAND_READY) {\r
      break;\r
    }\r
    Timeout--;\r
    gBS->Stall(1);\r
  }\r
\r
  if (Timeout == 0) {\r
    DEBUG ((EFI_D_ERROR, "Erase block timed out for Block: %d.\n", BlockIndex));\r
    return EFI_TIMEOUT;\r
  }\r
\r
  //Bit0 indicates Pass/Fail status\r
  if (NandStatus & NAND_FAILURE) {\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
NandReadBlock (\r
  IN UINTN                          StartBlockIndex,\r
  IN UINTN                          EndBlockIndex,\r
  OUT VOID                          *Buffer,\r
  OUT VOID                          *SpareBuffer\r
)\r
{\r
  UINTN      BlockIndex;\r
  UINTN      PageIndex;\r
  EFI_STATUS Status = EFI_SUCCESS;\r
\r
  for (BlockIndex = StartBlockIndex; BlockIndex <= EndBlockIndex; BlockIndex++) {\r
    //For each block read number of pages\r
    for (PageIndex = 0; PageIndex < gNandFlashInfo->NumPagesPerBlock; PageIndex++) {\r
      Status = NandReadPage(BlockIndex, PageIndex, Buffer, SpareBuffer);\r
      if (EFI_ERROR(Status)) {\r
        return Status;\r
      }\r
      Buffer = ((UINT8 *)Buffer + gNandFlashInfo->PageSize);\r
    }\r
  }\r
\r
  return Status;\r
}\r
\r
EFI_STATUS\r
NandWriteBlock (\r
  IN UINTN                          StartBlockIndex,\r
  IN UINTN                          EndBlockIndex,\r
  OUT VOID                          *Buffer,\r
  OUT VOID                          *SpareBuffer\r
  )\r
{\r
  UINTN      BlockIndex;\r
  UINTN      PageIndex;\r
  EFI_STATUS Status = EFI_SUCCESS;\r
\r
  for (BlockIndex = StartBlockIndex; BlockIndex <= EndBlockIndex; BlockIndex++) {\r
    //Page programming.\r
    for (PageIndex = 0; PageIndex < gNandFlashInfo->NumPagesPerBlock; PageIndex++) {\r
      Status = NandWritePage(BlockIndex, PageIndex, Buffer, SpareBuffer);\r
      if (EFI_ERROR(Status)) {\r
        return Status;\r
      }\r
      Buffer = ((UINT8 *)Buffer + gNandFlashInfo->PageSize);\r
    }\r
  }\r
\r
  return Status;\r
}\r
\r
EFI_STATUS\r
EFIAPI\r
NandFlashReset (\r
  IN EFI_BLOCK_IO_PROTOCOL          *This,\r
  IN BOOLEAN                        ExtendedVerification\r
  )\r
{\r
  UINTN BusyStall = 50;                            // microSeconds\r
  UINTN ResetBusyTimeout = (1000000 / BusyStall);  // 1 Second\r
\r
  //Send RESET command to device.\r
  NandSendCommand(RESET_CMD);\r
\r
  //Wait for 1ms before we check status register.\r
  gBS->Stall(1000);\r
\r
  //Check BIT#5 & BIT#6 in Status register to make sure RESET is done.\r
  while ((NandReadStatus() & NAND_RESET_STATUS) != NAND_RESET_STATUS) {\r
\r
    //In case of extended verification, wait for extended amount of time\r
    //to make sure device is reset.\r
    if (ExtendedVerification) {\r
      if (ResetBusyTimeout == 0) {\r
        return EFI_DEVICE_ERROR;\r
      }\r
\r
      gBS->Stall(BusyStall);\r
      ResetBusyTimeout--;\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
EFIAPI\r
NandFlashReadBlocks (\r
  IN EFI_BLOCK_IO_PROTOCOL          *This,\r
  IN UINT32                         MediaId,\r
  IN EFI_LBA                        Lba,\r
  IN UINTN                          BufferSize,\r
  OUT VOID                          *Buffer\r
  )\r
{\r
  UINTN      NumBlocks;\r
  UINTN      EndBlockIndex;\r
  EFI_STATUS Status;\r
  UINT8      *SpareBuffer = NULL;\r
\r
  if (Buffer == NULL) {\r
    Status = EFI_INVALID_PARAMETER;\r
    goto exit;\r
  }\r
\r
  if (Lba > LAST_BLOCK) {\r
    Status = EFI_INVALID_PARAMETER;\r
    goto exit;\r
  }\r
\r
  if ((BufferSize % gNandFlashInfo->BlockSize) != 0) {\r
    Status = EFI_BAD_BUFFER_SIZE;\r
    goto exit;\r
  }\r
\r
  NumBlocks = DivU64x32(BufferSize, gNandFlashInfo->BlockSize);\r
  EndBlockIndex = ((UINTN)Lba + NumBlocks) - 1;\r
\r
  SpareBuffer = (UINT8 *)AllocatePool(gNandFlashInfo->SparePageSize);\r
  if (SpareBuffer == NULL) {\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto exit;\r
  }\r
\r
  //Read block\r
  Status = NandReadBlock((UINTN)Lba, EndBlockIndex, Buffer, SpareBuffer);\r
  if (EFI_ERROR(Status)) {\r
    DEBUG((EFI_D_ERROR, "Read block fails: %x\n", Status));\r
    goto exit;\r
  }\r
\r
exit:\r
  if (SpareBuffer != NULL) {\r
    FreePool (SpareBuffer);\r
  }\r
\r
  return Status;\r
}\r
\r
EFI_STATUS\r
EFIAPI\r
NandFlashWriteBlocks (\r
  IN EFI_BLOCK_IO_PROTOCOL          *This,\r
  IN UINT32                         MediaId,\r
  IN EFI_LBA                        Lba,\r
  IN UINTN                          BufferSize,\r
  IN VOID                           *Buffer\r
  )\r
{\r
  UINTN      BlockIndex;\r
  UINTN      NumBlocks;\r
  UINTN      EndBlockIndex;\r
  EFI_STATUS Status;\r
  UINT8      *SpareBuffer = NULL;\r
\r
  if (Buffer == NULL) {\r
    Status = EFI_INVALID_PARAMETER;\r
    goto exit;\r
  }\r
\r
  if (Lba > LAST_BLOCK) {\r
    Status = EFI_INVALID_PARAMETER;\r
    goto exit;\r
  }\r
\r
  if ((BufferSize % gNandFlashInfo->BlockSize) != 0) {\r
    Status = EFI_BAD_BUFFER_SIZE;\r
    goto exit;\r
  }\r
\r
  NumBlocks = DivU64x32(BufferSize, gNandFlashInfo->BlockSize);\r
  EndBlockIndex = ((UINTN)Lba + NumBlocks) - 1;\r
\r
  SpareBuffer = (UINT8 *)AllocatePool(gNandFlashInfo->SparePageSize);\r
  if (SpareBuffer == NULL) {\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto exit;\r
  }\r
\r
  // Erase block\r
  for (BlockIndex = (UINTN)Lba; BlockIndex <= EndBlockIndex; BlockIndex++) {\r
    Status = NandEraseBlock(BlockIndex);\r
    if (EFI_ERROR(Status)) {\r
      DEBUG((EFI_D_ERROR, "Erase block failed. Status: %x\n", Status));\r
      goto exit;\r
    }\r
  }\r
\r
  // Program data\r
  Status = NandWriteBlock((UINTN)Lba, EndBlockIndex, Buffer, SpareBuffer);\r
  if (EFI_ERROR(Status)) {\r
    DEBUG((EFI_D_ERROR, "Block write fails: %x\n", Status));\r
    goto exit;\r
  }\r
\r
exit:\r
  if (SpareBuffer != NULL) {\r
    FreePool (SpareBuffer);\r
  }\r
\r
  return Status;\r
}\r
\r
EFI_STATUS\r
EFIAPI\r
NandFlashFlushBlocks (\r
  IN EFI_BLOCK_IO_PROTOCOL  *This\r
  )\r
{\r
  return EFI_SUCCESS;\r
}\r
\r
\r
\r
EFI_BLOCK_IO_MEDIA gNandFlashMedia = {\r
  SIGNATURE_32('n','a','n','d'),            // MediaId\r
  FALSE,                                    // RemovableMedia\r
  TRUE,                                     // MediaPresent\r
  FALSE,                                    // LogicalPartition\r
  FALSE,                                    // ReadOnly\r
  FALSE,                                    // WriteCaching\r
  0,                                        // BlockSize\r
  2,                                        // IoAlign\r
  0,                                        // Pad\r
  0                                         // LastBlock\r
};\r
\r
EFI_BLOCK_IO_PROTOCOL BlockIo =\r
{\r
  EFI_BLOCK_IO_INTERFACE_REVISION,  // Revision\r
  &gNandFlashMedia,                  // *Media\r
  NandFlashReset,                   // Reset\r
  NandFlashReadBlocks,              // ReadBlocks\r
  NandFlashWriteBlocks,             // WriteBlocks\r
  NandFlashFlushBlocks              // FlushBlocks\r
};\r
\r
EFI_STATUS\r
NandFlashInitialize (\r
  IN EFI_HANDLE         ImageHandle,\r
  IN EFI_SYSTEM_TABLE   *SystemTable\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  gNandFlashInfo = (NAND_FLASH_INFO *)AllocateZeroPool (sizeof(NAND_FLASH_INFO));\r
\r
  //Initialize GPMC module.\r
  GpmcInit();\r
\r
  //Reset NAND part\r
  NandFlashReset(&BlockIo, FALSE);\r
\r
  //Detect NAND part and populate gNandFlashInfo structure\r
  Status = NandDetectPart ();\r
  if (EFI_ERROR(Status)) {\r
    DEBUG((EFI_D_ERROR, "Nand part id detection failure: Status: %x\n", Status));\r
    return Status;\r
  }\r
\r
  //Count total number of 512Bytes chunk based on the page size.\r
  if (gNandFlashInfo->PageSize == PAGE_SIZE_512B) {\r
    gNum512BytesChunks = 1;\r
  } else if (gNandFlashInfo->PageSize == PAGE_SIZE_2K) {\r
    gNum512BytesChunks = 4;\r
  } else if (gNandFlashInfo->PageSize == PAGE_SIZE_4K) {\r
    gNum512BytesChunks = 8;\r
  }\r
\r
  gEccCode = (UINT8 *)AllocatePool(gNum512BytesChunks * 3);\r
  if (gEccCode == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //Configure ECC\r
  NandConfigureEcc ();\r
\r
  //Patch EFI_BLOCK_IO_MEDIA structure.\r
  gNandFlashMedia.BlockSize = gNandFlashInfo->BlockSize;\r
  gNandFlashMedia.LastBlock = LAST_BLOCK;\r
\r
  //Publish BlockIO.\r
  Status = gBS->InstallMultipleProtocolInterfaces (\r
                  &ImageHandle,\r
                  &gEfiBlockIoProtocolGuid, &BlockIo,\r
                  &gEfiDevicePathProtocolGuid, &gDevicePath,\r
                  NULL\r
                  );\r
  return Status;\r
}\r
\r