stv0g/embeddedsw
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

nandpsu: Remove NO_OOB option for bbt

Browse source 
As per the csurom, Bbt signature is always stored in oob area.
So, to sync with csurom, removing the NO_OOB(Bbt signature stores
in page area) functionality.

Signed-off-by: Punnaiah Choudary Kalluri <punnaia@xilinx.com>
Acked-by: Anirudha Sarangi   <anirudh@xilinx.com>
This commit is contained in:
Punnaiah Choudary Kalluri 2015-07-28 17:15:10 +05:30 • committed by Nava kishore Manne
parent aeb988e08a
commit ac89dc0908
3 changed files with 44 additions and 204 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

64
XilinxProcessorIPLib/drivers/nandpsu/src/xnandpsu.c
View file

@ -797,70 +797,6 @@ void XNandPsu_DisableEccMode(XNandPsu *InstancePtr)
InstancePtr->EccMode = XNANDPSU_NONE;
}
/*****************************************************************************/
/**
*
* This function enables storing bbt version in oob area.
*
* @param InstancePtr is a pointer to the XNandPsu instance.
*
* @return
* None
*
* @note None
*
******************************************************************************/
void XNandPsu_EnableBbtOobMode(XNandPsu *InstancePtr)
{
/*
* Assert the input arguments.
*/
Xil_AssertVoid(InstancePtr != NULL);
Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
InstancePtr->BbtDesc.Option = XNANDPSU_BBT_OOB;
InstancePtr->BbtMirrorDesc.Option = XNANDPSU_BBT_OOB;
/*
* Setting the Signature and Version Offset
*/
InstancePtr->BbtDesc.SigOffset = XNANDPSU_BBT_DESC_SIG_OFFSET;
InstancePtr->BbtMirrorDesc.SigOffset = XNANDPSU_BBT_DESC_SIG_OFFSET;
InstancePtr->BbtDesc.VerOffset = XNANDPSU_BBT_DESC_VER_OFFSET;
InstancePtr->BbtMirrorDesc.VerOffset = XNANDPSU_BBT_DESC_VER_OFFSET;
}
/*****************************************************************************/
/**
*
* This function enables storing bbt version in no oob area i.e. page memory.
*
* @param InstancePtr is a pointer to the XNandPsu instance.
*
* @return
* None
*
* @note None
*
******************************************************************************/
void XNandPsu_DisableBbtOobMode(XNandPsu *InstancePtr)
{
/*
* Assert the input arguments.
*/
Xil_AssertVoid(InstancePtr != NULL);
Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
InstancePtr->BbtDesc.Option = XNANDPSU_BBT_NO_OOB;
InstancePtr->BbtMirrorDesc.Option = XNANDPSU_BBT_NO_OOB;
/*
* Setting the Signature and Version Offset
*/
InstancePtr->BbtDesc.SigOffset = XNANDPSU_NO_OOB_BBT_DESC_SIG_OFFSET;
InstancePtr->BbtMirrorDesc.SigOffset =
XNANDPSU_NO_OOB_BBT_DESC_SIG_OFFSET;
InstancePtr->BbtDesc.VerOffset = XNANDPSU_NO_OOB_BBT_DESC_VER_OFFSET;
InstancePtr->BbtMirrorDesc.VerOffset =
XNANDPSU_NO_OOB_BBT_DESC_VER_OFFSET;
}
/*****************************************************************************/
/**
*

12
XilinxProcessorIPLib/drivers/nandpsu/src/xnandpsu.h
View file

@ -271,14 +271,6 @@ typedef enum {
XNANDPSU_ONDIE
} XNandPsu_EccMode;
/**
* The XNandPsu_BbtOption enum contains the BBT storage option.
*/
typedef enum {
XNANDPSU_BBT_OOB = 0, /**< OOB area */
XNANDPSU_BBT_NO_OOB, /**< No OOB i.e page area */
} XNandPsu_BbtOption;
/**
* Bad block table descriptor
*/
@ -293,7 +285,6 @@ typedef struct {
u8 Version[XNANDPSU_MAX_TARGETS];
/**< BBT version */
u32 Valid; /**< BBT descriptor is valid or not */
XNandPsu_BbtOption Option; /**< BBT Oob option enabled/disabled */
} XNandPsu_BbtDesc;
/**
@ -569,9 +560,6 @@ void XNandPsu_DisableEccMode(XNandPsu *InstancePtr);
void XNandPsu_Prepare_Cmd(XNandPsu *InstancePtr, u8 Cmd1, u8 Cmd2, u8 EccState,
u8 DmaMode, u8 AddrCycles);
void XNandPsu_EnableBbtOobMode(XNandPsu *InstancePtr);
void XNandPsu_DisableBbtOobMode(XNandPsu *InstancePtr);
/*
* XNandPsu_LookupConfig in xnandpsu_sinit.c
*/

172
XilinxProcessorIPLib/drivers/nandpsu/src/xnandpsu_bbm.c
View file

@ -108,28 +108,16 @@ void XNandPsu_InitBbtDesc(XNandPsu *InstancePtr)
/*
* Initialize primary Bad Block Table(BBT)
*/
InstancePtr->BbtDesc.Option = XNANDPSU_BBT_OOB;
for (Index = 0U; Index < XNANDPSU_MAX_TARGETS; Index++) {
InstancePtr->BbtDesc.PageOffset[Index] =
XNANDPSU_BBT_DESC_PAGE_OFFSET;
}
if(InstancePtr->BbtDesc.Option == XNANDPSU_BBT_OOB) {
if (InstancePtr->EccMode == XNANDPSU_ONDIE) {
InstancePtr->BbtDesc.SigOffset =
XNANDPSU_ONDIE_SIG_OFFSET;
InstancePtr->BbtDesc.VerOffset =
XNANDPSU_ONDIE_VER_OFFSET;
} else {
InstancePtr->BbtDesc.SigOffset =
XNANDPSU_BBT_DESC_SIG_OFFSET;
InstancePtr->BbtDesc.VerOffset =
XNANDPSU_BBT_DESC_VER_OFFSET;
}
if (InstancePtr->EccMode == XNANDPSU_ONDIE) {
InstancePtr->BbtDesc.SigOffset = XNANDPSU_ONDIE_SIG_OFFSET;
InstancePtr->BbtDesc.VerOffset = XNANDPSU_ONDIE_VER_OFFSET;
} else {
InstancePtr->BbtDesc.SigOffset =
XNANDPSU_NO_OOB_BBT_DESC_SIG_OFFSET;
InstancePtr->BbtDesc.VerOffset =
XNANDPSU_NO_OOB_BBT_DESC_VER_OFFSET;
InstancePtr->BbtDesc.SigOffset = XNANDPSU_BBT_DESC_SIG_OFFSET;
InstancePtr->BbtDesc.VerOffset = XNANDPSU_BBT_DESC_VER_OFFSET;
}
InstancePtr->BbtDesc.SigLength = XNANDPSU_BBT_DESC_SIG_LEN;
InstancePtr->BbtDesc.MaxBlocks = XNANDPSU_BBT_DESC_MAX_BLOCKS;
@ -150,28 +138,20 @@ void XNandPsu_InitBbtDesc(XNandPsu *InstancePtr)
/*
* Initialize mirror Bad Block Table(BBT)
*/
InstancePtr->BbtMirrorDesc.Option = XNANDPSU_BBT_OOB;
for (Index = 0U; Index < XNANDPSU_MAX_TARGETS; Index++) {
InstancePtr->BbtMirrorDesc.PageOffset[Index] =
XNANDPSU_BBT_DESC_PAGE_OFFSET;
}
if(InstancePtr->BbtMirrorDesc.Option == XNANDPSU_BBT_OOB) {
if (InstancePtr->EccMode == XNANDPSU_ONDIE) {
InstancePtr->BbtMirrorDesc.SigOffset =
XNANDPSU_ONDIE_SIG_OFFSET;
InstancePtr->BbtMirrorDesc.VerOffset =
XNANDPSU_ONDIE_VER_OFFSET;
} else {
InstancePtr->BbtMirrorDesc.SigOffset =
XNANDPSU_BBT_DESC_SIG_OFFSET;
InstancePtr->BbtMirrorDesc.VerOffset =
XNANDPSU_BBT_DESC_VER_OFFSET;
}
if (InstancePtr->EccMode == XNANDPSU_ONDIE) {
InstancePtr->BbtMirrorDesc.SigOffset =
XNANDPSU_ONDIE_SIG_OFFSET;
InstancePtr->BbtMirrorDesc.VerOffset =
XNANDPSU_ONDIE_VER_OFFSET;
} else {
InstancePtr->BbtMirrorDesc.SigOffset =
XNANDPSU_NO_OOB_BBT_DESC_SIG_OFFSET;
XNANDPSU_BBT_DESC_SIG_OFFSET;
InstancePtr->BbtMirrorDesc.VerOffset =
XNANDPSU_NO_OOB_BBT_DESC_VER_OFFSET;
XNANDPSU_BBT_DESC_VER_OFFSET;
}
InstancePtr->BbtMirrorDesc.SigLength = XNANDPSU_BBT_DESC_SIG_LEN;
InstancePtr->BbtMirrorDesc.MaxBlocks = XNANDPSU_BBT_DESC_MAX_BLOCKS;
@ -462,15 +442,11 @@ static s32 XNandPsu_ReadBbt(XNandPsu *InstancePtr, u32 Target)
s32 Status2;
s32 Status;
u32 BufLen;
u8 * BufPtr = Buf;
XNandPsu_BbtDesc *Desc = &InstancePtr->BbtDesc;
XNandPsu_BbtDesc *MirrorDesc = &InstancePtr->BbtMirrorDesc;
BufLen = InstancePtr->Geometry.NumBlocks >>
XNANDPSU_BBT_BLOCK_SHIFT;
if (Desc->Option == XNANDPSU_BBT_NO_OOB) {
BufLen += Desc->VerOffset + XNANDPSU_BBT_VERSION_LENGTH;
}
/*
* Search the Bad Block Table(BBT) in flash
*/
@ -497,19 +473,14 @@ static s32 XNandPsu_ReadBbt(XNandPsu *InstancePtr, u32 Target)
Offset = (u64)Desc->PageOffset[Target] *
(u64)InstancePtr->Geometry.BytesPerPage;
Status = XNandPsu_Read(InstancePtr, Offset, BufLen,
&BufPtr[0]);
&Buf[0]);
if (Status != XST_SUCCESS) {
goto Out;
}
if (Desc->Option == XNANDPSU_BBT_NO_OOB){
BufPtr = BufPtr + Desc->VerOffset +
XNANDPSU_BBT_VERSION_LENGTH;
}
/*
* Convert flash BBT to memory based BBT
*/
XNandPsu_ConvertBbt(InstancePtr, &BufPtr[0], Target);
XNandPsu_ConvertBbt(InstancePtr, &Buf[0], Target);
MirrorDesc->Version[Target] = Desc->Version[Target];
/*
@ -525,18 +496,14 @@ static s32 XNandPsu_ReadBbt(XNandPsu *InstancePtr, u32 Target)
Offset = (u64)MirrorDesc->PageOffset[Target] *
(u64)InstancePtr->Geometry.BytesPerPage;
Status = XNandPsu_Read(InstancePtr, Offset, BufLen,
&BufPtr[0]);
&Buf[0]);
if (Status != XST_SUCCESS) {
goto Out;
}
if(Desc->Option == XNANDPSU_BBT_NO_OOB){
BufPtr = BufPtr + Desc->VerOffset +
XNANDPSU_BBT_VERSION_LENGTH;
}
/*
* Convert flash BBT to memory based BBT
*/
XNandPsu_ConvertBbt(InstancePtr, &BufPtr[0], Target);
XNandPsu_ConvertBbt(InstancePtr, &Buf[0], Target);
Desc->Version[Target] = MirrorDesc->Version[Target];
/*
@ -552,20 +519,14 @@ static s32 XNandPsu_ReadBbt(XNandPsu *InstancePtr, u32 Target)
Offset = (u64)Desc->PageOffset[Target] *
(u64)InstancePtr->Geometry.BytesPerPage;
Status = XNandPsu_Read(InstancePtr, Offset, BufLen,
&BufPtr[0]);
&Buf[0]);
if (Status != XST_SUCCESS) {
goto Out;
}
if(Desc->Option == XNANDPSU_BBT_NO_OOB){
BufPtr = BufPtr + Desc->VerOffset +
XNANDPSU_BBT_VERSION_LENGTH;
}
/*
* Convert flash BBT to memory based BBT
*/
XNandPsu_ConvertBbt(InstancePtr, &BufPtr[0], Target);
XNandPsu_ConvertBbt(InstancePtr, &Buf[0], Target);
}
} else if (Desc->Valid != 0U) {
/*
@ -573,18 +534,14 @@ static s32 XNandPsu_ReadBbt(XNandPsu *InstancePtr, u32 Target)
*/
Offset = (u64)Desc->PageOffset[Target] *
(u64)InstancePtr->Geometry.BytesPerPage;
Status = XNandPsu_Read(InstancePtr, Offset, BufLen, &BufPtr[0]);
Status = XNandPsu_Read(InstancePtr, Offset, BufLen, &Buf[0]);
if (Status != XST_SUCCESS) {
goto Out;
}
if(Desc->Option == XNANDPSU_BBT_NO_OOB){
BufPtr = BufPtr + Desc->VerOffset +
XNANDPSU_BBT_VERSION_LENGTH;
}
/*
* Convert flash BBT to memory based BBT
*/
XNandPsu_ConvertBbt(InstancePtr, &BufPtr[0], Target);
XNandPsu_ConvertBbt(InstancePtr, &Buf[0], Target);
MirrorDesc->Version[Target] = Desc->Version[Target];
/*
@ -601,19 +558,14 @@ static s32 XNandPsu_ReadBbt(XNandPsu *InstancePtr, u32 Target)
*/
Offset = (u64)MirrorDesc->PageOffset[Target] *
(u64)InstancePtr->Geometry.BytesPerPage;
Status = XNandPsu_Read(InstancePtr, Offset, BufLen, &BufPtr[0]);
Status = XNandPsu_Read(InstancePtr, Offset, BufLen, &Buf[0]);
if (Status != XST_SUCCESS) {
goto Out;
}
if(Desc->Option == XNANDPSU_BBT_NO_OOB){
BufPtr = BufPtr + Desc->VerOffset +
XNANDPSU_BBT_VERSION_LENGTH;
}
/*
* Convert flash BBT to memory based BBT
*/
XNandPsu_ConvertBbt(InstancePtr, &BufPtr[0], Target);
XNandPsu_ConvertBbt(InstancePtr, &Buf[0], Target);
Desc->Version[Target] = MirrorDesc->Version[Target];
/*
@ -672,13 +624,7 @@ static s32 XNandPsu_SearchBbt(XNandPsu *InstancePtr, XNandPsu_BbtDesc *Desc,
PageOff = (StartBlock - Block) *
InstancePtr->Geometry.PagesPerBlock;
if(Desc->Option == XNANDPSU_BBT_NO_OOB){
BlockOff = (u64)PageOff * (u64)InstancePtr->Geometry.BytesPerPage;
Status = XNandPsu_Read(InstancePtr, BlockOff,
Desc->VerOffset + XNANDPSU_BBT_VERSION_LENGTH, &Buf[0]);
}else{
Status = XNandPsu_ReadSpareBytes(InstancePtr, PageOff, &Buf[0]);
}
if (Status != XST_SUCCESS) {
continue;
}
@ -745,11 +691,6 @@ static s32 XNandPsu_WriteBbt(XNandPsu *InstancePtr, XNandPsu_BbtDesc *Desc,
u8 BlockType;
u32 BbtLen = InstancePtr->Geometry.NumBlocks >>
XNANDPSU_BBT_BLOCK_SHIFT;
u32 BufLen = BbtLen;
if (Desc->Option == XNANDPSU_BBT_NO_OOB) {
BufLen += Desc->VerOffset + XNANDPSU_BBT_VERSION_LENGTH;
}
u8* BufPtr = Buf;
/*
* Find a valid block to write the Bad Block Table(BBT)
*/
@ -797,15 +738,12 @@ static s32 XNandPsu_WriteBbt(XNandPsu *InstancePtr, XNandPsu_BbtDesc *Desc,
/*
* Convert the memory based BBT to flash based table
*/
(void)memset(Buf, 0xff, BufLen);
(void)memset(Buf, 0xff, BbtLen);
if(Desc->Option == XNANDPSU_BBT_NO_OOB){
BufPtr = BufPtr + Desc->VerOffset + XNANDPSU_BBT_VERSION_LENGTH;
}
/*
* Loop through the number of blocks
*/
for(BlockOffset = 0U; BlockOffset < BufLen; BlockOffset++) {
for(BlockOffset = 0U; BlockOffset < BbtLen; BlockOffset++) {
Data = InstancePtr->Bbt[BlockOffset];
/*
* Calculate the bit mask for 4 blocks at a time in loop
@ -813,7 +751,7 @@ static s32 XNandPsu_WriteBbt(XNandPsu *InstancePtr, XNandPsu_BbtDesc *Desc,
for(BlockIndex = 0U; BlockIndex < XNANDPSU_BBT_ENTRY_NUM_BLOCKS;
BlockIndex++) {
BlockShift = XNandPsu_BbtBlockShift(BlockIndex);
BufPtr[BlockOffset] &= ~(Mask[Data &
Buf[BlockOffset] &= ~(Mask[Data &
XNANDPSU_BLOCK_TYPE_MASK] <<
BlockShift);
Data >>= XNANDPSU_BBT_BLOCK_SHIFT;
@ -827,51 +765,29 @@ static s32 XNandPsu_WriteBbt(XNandPsu *InstancePtr, XNandPsu_BbtDesc *Desc,
goto Out;
}
if(Desc->Option == XNANDPSU_BBT_NO_OOB){
/*
* Copy the signature and version to the Buffer
*/
(void)memcpy(Buf + Desc->SigOffset, &Desc->Signature[0],
Desc->SigLength);
(void)memcpy(Buf + Desc->VerOffset, &Desc->Version[Target], 1U);
/*
* Write the Buffer to page offset
*/
Offset = (u64)Desc->PageOffset[Target] *
(u64)InstancePtr->Geometry.BytesPerPage;
Status = XNandPsu_Write(InstancePtr, Offset, BufLen, &Buf[0]);
if (Status != XST_SUCCESS) {
goto Out;
}
}else{
/*
* Write the BBT to page offset
*/
Offset = (u64)Desc->PageOffset[Target] *
(u64)InstancePtr->Geometry.BytesPerPage;
Status = XNandPsu_Write(InstancePtr, Offset, BbtLen, &Buf[0]);
if (Status != XST_SUCCESS) {
goto Out;
}
/*
* Write the signature and version in the spare data area
*/
(void)memset(SpareBuf, 0xff, InstancePtr->Geometry.SpareBytesPerPage);
Status = XNandPsu_ReadSpareBytes(InstancePtr, Desc->PageOffset[Target],
&SpareBuf[0]);
if (Status != XST_SUCCESS) {
goto Out;
}
/* Write the BBT to page offset */
Offset = (u64)Desc->PageOffset[Target] *
(u64)InstancePtr->Geometry.BytesPerPage;
Status = XNandPsu_Write(InstancePtr, Offset, BbtLen, &Buf[0]);
if (Status != XST_SUCCESS) {
goto Out;
}
/* Write the signature and version in the spare data area */
(void)memset(SpareBuf, 0xff, InstancePtr->Geometry.SpareBytesPerPage);
Status = XNandPsu_ReadSpareBytes(InstancePtr, Desc->PageOffset[Target],
&SpareBuf[0]);
if (Status != XST_SUCCESS) {
goto Out;
}
(void)memcpy(SpareBuf + Desc->SigOffset, &Desc->Signature[0],
(void)memcpy(SpareBuf + Desc->SigOffset, &Desc->Signature[0],
Desc->SigLength);
(void)memcpy(SpareBuf + Desc->VerOffset, &Desc->Version[Target], 1U);
(void)memcpy(SpareBuf + Desc->VerOffset, &Desc->Version[Target], 1U);
Status = XNandPsu_WriteSpareBytes(InstancePtr,
Status = XNandPsu_WriteSpareBytes(InstancePtr,
Desc->PageOffset[Target], &SpareBuf[0]);
if (Status != XST_SUCCESS) {
goto Out;
}
if (Status != XST_SUCCESS) {
goto Out;
}
Status = XST_SUCCESS;