__s32 BMM_RleaseLogBlock(__s32 tmpPst, __s32 start_page, __u32 merge_page_cnt)
{
__s32 result;
//PRINT("BMM_RleaseLogBlock: 0x%x, 0x%x, 0x%x\n", tmpPst, start_page, merge_page_cnt);
BMM_SetDirtyFlag();
//switch the page mapping table for merge the log block
result = PMM_SwitchMapTbl(tmpPst);
if(result < 0)
{
MAPPING_ERR("[MAPPING_ERR] Switch page mapping table failed when create new log block! Err:0x%x\n", result);
return -1;
}
//merge the log block with normal type, to make an empty item
result = LML_MergeLogBlk_Ext(NORMAL_MERGE_MODE, LOG_BLK_TBL[tmpPst].LogicBlkNum, start_page, merge_page_cnt);
if(result < 0)
{
//merge log block failed, report error
MAPPING_ERR("[MAPPING_ERR] Merge log block failed when create new log block! Err:0x%x\n", result);
return -1;
}
return (result);
}
__s32 BMM_MergeAllLogBlock(void)
{
__u32 tmpZoneNum, ZoneCnt, tmpLogPos;
__s32 result;
ZoneCnt = ZONE_CNT_OF_DIE * DieCntOfNand;
PRINT("BMM_MergeAllLogBlock, ZoneCnt: %x\n", ZoneCnt);
for(tmpZoneNum=0; tmpZoneNum<ZoneCnt; tmpZoneNum++)
{
PRINT("BMM_MergeAllLogBlock, tmpZoneNum: %x\n", tmpZoneNum);
//swap the block mapping table to ram which is need be accessing currently
if(tmpLogicalBlk!= 0xffff)
LML_MergeLogBlk_Quit();
result = BMM_SwitchMapTbl(tmpZoneNum);
if(result < 0)
{
MAPPING_ERR("[MAPPING_ERR] BMM_MergeAllLogBlock, Switch block mapping table failed when read logical page! Err:0x%x\n", result);
return -ERR_MAPPING;
}
BMM_SetDirtyFlag();
for(tmpLogPos = 0; tmpLogPos<MAX_LOG_BLK_CNT; tmpLogPos++)
{
if(LOG_BLK_TBL[tmpLogPos].LogicBlkNum != 0xffff)
{
PRINT("BMM_MergeAllLogBlock, logpos: %x, logblock: %x\n", tmpLogPos, LOG_BLK_TBL[tmpLogPos].LogicBlkNum);
//need swap the page mapping table to ram which is accessing currently
result = PMM_SwitchMapTbl(tmpLogPos);
if(result < 0)
{
MAPPING_ERR("[MAPPING_ERR] BMM_MergeAllLogBlock, Switch page mapping table failed when switch page map table! Err:0x%x\n", result);
return -1;
}
result = LML_MergeLogBlk(NORMAL_MERGE_MODE,LOG_BLK_TBL[tmpLogPos].LogicBlkNum);
if(result<0)
{
MAPPING_ERR("[MAPPING_ERR] BMM_MergeAllLogBlock, merge error! Err:0x%x\n", result);
return -ERR_MAPPING;
}
}
}
}
PRINT("BMM_MergeAllLogBlock end\n");
return result;
}
/*
************************************************************************************************************************
* GET LOG PAGE PARAMETER
*
*Description: Get a page from log block for read or write.
*
*Arguments : nBlk the logical block number of the log block;
* nPage the number of the logical page, which page need log page;
* nMode the type of get log page, 'r' or 'w', others is invalid.
*
*Return : the number of the log page;
* != 0xffff get log page successful, return page number;
* = 0xffff get log page failed.
*
*Note : Scan the log block table to try to get the log block.
* when the get type is 'r', if the log block is exsit and the logical
* page contain a log page, return the number of the log page, else,
* return 0xffff;
* when the get type is 'w', if the log block is not exsit, need create
* log block, then, if get log page failed, need merge the log block, and
* try to get log page again, this mode should return a value page number
* except there is no enough valid blocks.
************************************************************************************************************************
*/
__u32 PMM_GetLogPage(__u32 nBlk, __u32 nPage, __u8 nMode)
{
__s32 result, tmpLogPst;
__u16 tmpPage, PhyPageNum;
if(nMode == 'r')
{
tmpLogPst = _GetLogBlkPst(nBlk);
if(tmpLogPst < 0)
{
//get log page by read mode, there is no log block, return invalid value
return INVALID_PAGE_NUM;
}
//need swap the page mapping table to ram which is accessing currently
result = PMM_SwitchMapTbl(tmpLogPst);
if(result < 0)
{
MAPPING_ERR("[MAPPING_ERR] Switch page mapping table failed when get log page! Err:0x%x\n", result);
return INVALID_PAGE_NUM;
}
_CalLogAccessCnt(tmpLogPst);
//get active read log block index
if((SUPPORT_LOG_BLOCK_MANAGE)&&(LOG_BLK_TBL[tmpLogPst].LogBlkType == LSB_TYPE))
{
PhyPageNum = PAGE_MAP_TBL[nPage].PhyPageNum;
if((PhyPageNum&(0x1<<15))&&(PhyPageNum!= 0xffff))
{
LOG_BLK_TBL[tmpLogPst].ReadBlkIndex = 1;
PhyPageNum &= 0x7fff;
}
else
LOG_BLK_TBL[tmpLogPst].ReadBlkIndex = 0;
return (PhyPageNum|LOG_BLK_TBL[tmpLogPst].ReadBlkIndex<<16);
}
else
{
LOG_BLK_TBL[tmpLogPst].ReadBlkIndex = 0;
return PAGE_MAP_TBL[nPage].PhyPageNum;
}
}
result = _GetLogPageForWrite(nBlk, nPage, &tmpPage, (__u32 *)&tmpLogPst);
if(result < 0)
{
//get log page for write failed
MAPPING_ERR("[MAPPING_ERR] Get log page for write failed!\n");
return INVALID_PAGE_NUM;
}
//check if the log page is valid
if(!(tmpPage < PAGE_CNT_OF_SUPER_BLK))
{
//the log page is not invalid, need to merge the log block, and get again
result = LML_MergeLogBlk(SPECIAL_MERGE_MODE, nBlk);
if(result < 0)
{
//merge log block failed, report error
MAPPING_ERR("[MAPPING_ERR] Merge log block failed when get log page! Err:0x%x\n", result);
return INVALID_PAGE_NUM;
}
//try to get log page for write again
result = _GetLogPageForWrite(nBlk, nPage, &tmpPage, (__u32 *)&tmpLogPst);
if(result < 0)
{
//get log page for write failed
MAPPING_ERR("[MAPPING_ERR] Get log page for write failed!\n");
return INVALID_PAGE_NUM;
}
}
//check if the log page is valid
if(!(tmpPage < PAGE_CNT_OF_SUPER_BLK))
{
//get log page for write failed
MAPPING_ERR("[MAPPING_ERR] Get log page for write failed!\n");
return INVALID_PAGE_NUM;
}
else
{
LOG_BLK_TBL[tmpLogPst].LastUsedPage = tmpPage;
}
//update the page mapping table item
if((SUPPORT_LOG_BLOCK_MANAGE)&&(LOG_BLK_TBL[tmpLogPst].LogBlkType == LSB_TYPE))
{
DBUG_MSG("[DBUG_MSG] PMM_GetLogPage 2, select bak log block\n");
PAGE_MAP_TBL[nPage].PhyPageNum = tmpPage|((LOG_BLK_TBL[tmpLogPst].WriteBlkIndex&0x1)<<15);
}
else
PAGE_MAP_TBL[nPage].PhyPageNum = tmpPage;
//set the flag that mark need update the page mapping table
PAGE_MAP_CACHE->DirtyFlag = 1;
_CalLogAccessCnt(tmpLogPst);
if((SUPPORT_LOG_BLOCK_MANAGE)&&(LOG_BLK_TBL[tmpLogPst].LogBlkType == LSB_TYPE))
return (tmpPage|LOG_BLK_TBL[tmpLogPst].WriteBlkIndex<<16);
else
return tmpPage;
}
/*
************************************************************************************************************************
* GET LOG PAGE FOR WRITE
*
*Description: Get a log page for write.
*
*Arguments : nBlk the logical block number of the log block;
* nPage the number of the logical page, which page need log page;
* pLogPage the pointer to the log page number, for return value;
* pLogPst the pointer to the position of the log block in the log block table.
*
*Return : get log page result.
* = 0 get log page for write successful;
* =-1 get log page for write failed.
************************************************************************************************************************
*/
static __s32 _GetLogPageForWrite(__u32 nBlk, __u32 nPage, __u16 *pLogPage, __u32 *pLogPst)
{
__s32 result, tmpLogPst;
__u16 tmpPage, tempBank;
struct __PhysicOpPara_t tmpPhyPage;
struct __NandUserData_t tmpSpare[2];
tmpLogPst = _GetLogBlkPst(nBlk);
if(tmpLogPst < 0)
{
//get log block position failed, there is no such log block, need create a new one
result = _CreateNewLogBlk(nBlk, (__u32 *)&tmpLogPst);
if(result < 0)
{
MAPPING_ERR("[MAPPING_ERR] Create new log block failed!\n");
return -1;
}
}
//need swap the page mapping table to ram which is accessing currently
result = PMM_SwitchMapTbl(tmpLogPst);
if(result < 0)
{
MAPPING_ERR("[MAPPING_ERR] Switch page mapping table failed when get log page! Err:0x%x\n", result);
return -1;
}
//need get log page by write mode,
tmpPage = LOG_BLK_TBL[tmpLogPst].LastUsedPage;
if(SUPPORT_ALIGN_NAND_BNK)
{
if(tmpPage == 0xffff)
{
//the log block is empty, need get log page in the first page line
tmpPage = nPage % INTERLEAVE_BANK_CNT;
}
else
{
//need bank align, the log page and the data page should be in the same bank
if((nPage % INTERLEAVE_BANK_CNT) > (tmpPage % INTERLEAVE_BANK_CNT))
{
//get the log page in the same page line with last used page
tmpPage = tmpPage + ((nPage % INTERLEAVE_BANK_CNT) - (tmpPage % INTERLEAVE_BANK_CNT));
}
else
{
//need get the log page in the next page line of the last used page
tmpPage = tmpPage + (nPage % INTERLEAVE_BANK_CNT) + (INTERLEAVE_BANK_CNT - (tmpPage % INTERLEAVE_BANK_CNT));
}
}
}
else
{
//use the page which is the next of the last used page
tmpPage = tmpPage + 1;
}
if((SUPPORT_LOG_BLOCK_MANAGE)&&(LOG_BLK_TBL[tmpLogPst].LogBlkType == LSB_TYPE))
{
DBUG_MSG("[DBUG_MSG] _GetLogPageForWrite, select bak log block\n");
if(SUPPORT_ALIGN_NAND_BNK)
{
tempBank = tmpPage%INTERLEAVE_BANK_CNT;
tmpPage =PMM_CalNextLogPage(tmpPage);
while(tmpPage%INTERLEAVE_BANK_CNT != tempBank)
{
tmpPage++;
tmpPage =PMM_CalNextLogPage(tmpPage);
if(tmpPage>=PAGE_CNT_OF_SUPER_BLK)
break;
}
}
else
{
tmpPage =PMM_CalNextLogPage(tmpPage);
}
if((tmpPage >= PAGE_CNT_OF_SUPER_BLK)&&(LOG_BLK_TBL[tmpLogPst].WriteBlkIndex == 0))
{
LOG_BLK_TBL[tmpLogPst].WriteBlkIndex = 1;
tmpPage = tmpPage - PAGE_CNT_OF_SUPER_BLK;
}
if(LOG_BLK_TBL[tmpLogPst].WriteBlkIndex == 1)
DBUG_MSG("[DBUG_MSG] _GetLogPageForWrite, log block index: %x, log block num: %x, page: %x \n", LOG_BLK_TBL[tmpLogPst].WriteBlkIndex, LOG_BLK_TBL[tmpLogPst].PhyBlk1.PhyBlkNum, tmpPage);
else
DBUG_MSG("[DBUG_MSG] _GetLogPageForWrite, log block index: %x, log block num: %x, page: %x \n", LOG_BLK_TBL[tmpLogPst].WriteBlkIndex, LOG_BLK_TBL[tmpLogPst].PhyBlk.PhyBlkNum, tmpPage);
}
__CHECK_WRITE_LOGICAL_INFO_OF_LOG_BLOCK:
//check if need write the logical information in the first page of the log block
if((LOG_BLK_TBL[tmpLogPst].LastUsedPage == 0xffff) && (tmpPage != 0))
{
//get logical information from the data block
LML_CalculatePhyOpPar(&tmpPhyPage, CUR_MAP_ZONE, DATA_BLK_TBL[nBlk].PhyBlkNum, 0);
tmpPhyPage.SectBitmap = 0x03;
tmpPhyPage.MDataPtr = LML_TEMP_BUF;
tmpPhyPage.SDataPtr = (void *)tmpSpare;
LML_VirtualPageRead(&tmpPhyPage);
//if((SUPPORT_LOG_BLOCK_MANAGE)&&(LOG_BLK_TBL[tmpLogPst].LogBlkType == LSB_TYPE))
//{
// PRINT("_GetLogPageForWrite log %x page 0, data age: %x, log age: %x\n", LOG_BLK_TBL[tmpLogPst].WriteBlkIndex, tmpSpare[0].PageStatus, tmpSpare[0].PageStatus+1);
//}
tmpSpare[0].BadBlkFlag = 0xff;
tmpSpare[1].BadBlkFlag = 0xff;
tmpSpare[0].LogicInfo = ((CUR_MAP_ZONE % ZONE_CNT_OF_DIE)<<10) | nBlk;
tmpSpare[1].LogicInfo = ((CUR_MAP_ZONE % ZONE_CNT_OF_DIE)<<10) | nBlk;
tmpSpare[0].LogicPageNum = 0xffff;
tmpSpare[1].LogicPageNum = 0xffff;
tmpSpare[0].PageStatus = tmpSpare[0].PageStatus + 1;
tmpSpare[1].PageStatus = tmpSpare[0].PageStatus;
if((SUPPORT_LOG_BLOCK_MANAGE)&&(LOG_BLK_TBL[tmpLogPst].LogBlkType == LSB_TYPE))
{
tmpSpare[0].LogType = LSB_TYPE|(LOG_BLK_TBL[tmpLogPst].WriteBlkIndex<<4);
tmpSpare[1].LogType = LSB_TYPE|(LOG_BLK_TBL[tmpLogPst].WriteBlkIndex<<4);
}
else
{
tmpSpare[0].LogType = 0xff;
tmpSpare[1].LogType = 0xff;
}
//write the logical information to the spare area of the data block
if((SUPPORT_LOG_BLOCK_MANAGE)&&(LOG_BLK_TBL[tmpLogPst].LogBlkType == LSB_TYPE))
{
DBUG_MSG("[DBUG] _GetLogPageForWrite, write the logical information to log page 0, writeblkindex: %x\n", LOG_BLK_TBL[tmpLogPst].WriteBlkIndex);
LML_CalculatePhyOpPar(&tmpPhyPage, CUR_MAP_ZONE, LOG_BLK_TBL[tmpLogPst].PhyBlk.PhyBlkNum, 0);
}
else
LML_CalculatePhyOpPar(&tmpPhyPage, CUR_MAP_ZONE, LOG_BLK_TBL[tmpLogPst].PhyBlk.PhyBlkNum, 0);
tmpPhyPage.SectBitmap = FULL_BITMAP_OF_SUPER_PAGE;
result = LML_VirtualPageWrite(&tmpPhyPage);
if(result < 0)
{
LOGICCTL_ERR("[MAPPING_ERR] Physical write module failed when write logical information, Err:0x%x!\n", result);
return -1;
}
result = PHY_SynchBank(tmpPhyPage.BankNum, SYNC_CHIP_MODE);
if(result < 0)
{
//the last write operation on current bank is failed, the block is bad, need proccess it
LOGICCTL_DBG("[LOGICCTL_DBG] Find a bad block when write logical page! bank:0x%x, block:0x%x, page:0x%x\n",
tmpPhyPage.BankNum, tmpPhyPage.BlkNum, tmpPhyPage.PageNum);
//process the bad block
result = LML_BadBlkManage(&LOG_BLK_TBL[tmpLogPst].PhyBlk, CUR_MAP_ZONE, 0, &LOG_BLK_TBL[tmpLogPst].PhyBlk);
if(result < 0)
{
LOGICCTL_ERR("[MAPPING_ERR] Bad block process failed when get log page for write, Err:0x%x!\n", result);
return -1;
}
goto __CHECK_WRITE_LOGICAL_INFO_OF_LOG_BLOCK;
}
}
//set the log page number for return
*pLogPage = tmpPage;
*pLogPst = tmpLogPst;
return 0;
}
/*
************************************************************************************************************************
* CREATE A NEW LOG BLOCK
*
*Description: Create a new log block.
*
*Arguments : nBlk the logical block number of the log block;
* pLogPst the pointer to the log block position in the log block table.
*
*Return : create new log block result.
* = 0 create new log block successful;
* =-1 create new log block failed.
************************************************************************************************************************
*/
static __s32 _CreateNewLogBlk(__u32 nBlk, __u32 *pLogPst)
{
__s32 i, result, LogBlkType,tmpPst=-1;
__u16 tmpLogAccessAge = 0xffff;
struct __SuperPhyBlkType_t tmpFreeBlk, tmpFreeBlk1;
struct __PhysicOpPara_t tmpPhyPage;
struct __NandUserData_t tmpSpare[2];
#if CFG_SUPPORT_WEAR_LEVELLING
//check if need do wear-levelling
if(BLK_ERASE_CNTER >= WEAR_LEVELLING_FREQUENCY)
{
LML_WearLevelling();
}
#endif
//try to search an empty item in the log block table
for(i=0; i<LOG_BLK_CNT_OF_ZONE; i++)
{
if(LOG_BLK_TBL[i].LogicBlkNum == 0xffff)
{
//find a empty item
tmpPst = i;
break;
}
}
//there is no empty item in the log block table, need merge a log block
if(tmpPst == -1)
{
//check if there is some full log block
for(i=0; i<LOG_BLK_CNT_OF_ZONE; i++)
{
if(LOG_BLK_TBL[i].LastUsedPage == PAGE_CNT_OF_SUPER_BLK-1)
{
tmpPst = i;
break;
}
}
if(tmpPst == -1)
{
//there is no full log block, look for an oldest log block to merge
for(i=0; i<LOG_BLK_CNT_OF_ZONE; i++)
{
if(LOG_ACCESS_AGE[i] < tmpLogAccessAge)
{
tmpLogAccessAge = LOG_ACCESS_AGE[i];
tmpPst = i;
}
}
}
//switch the page mapping table for merge the log block
result = PMM_SwitchMapTbl(tmpPst);
if(result < 0)
{
MAPPING_ERR("[MAPPING_ERR] Switch page mapping table failed when create new log block! Err:0x%x\n", result);
return -1;
}
//merge the log block with normal type, to make an empty item
result = LML_MergeLogBlk(NORMAL_MERGE_MODE, LOG_BLK_TBL[tmpPst].LogicBlkNum);
if(result < 0)
{
//merge log block failed, report error
MAPPING_ERR("[MAPPING_ERR] Merge log block failed when create new log block! Err:0x%x\n", result);
return -1;
}
}
LogBlkType = BMM_CalLogBlkType(nBlk);
if((SUPPORT_LOG_BLOCK_MANAGE)&&(LogBlkType == LSB_TYPE))
{
DBUG_MSG("[DBUG_MSG] _CreateNewLogBlk, select bak log block\n");
//get a free block to create a new log block
result = BMM_GetFreeBlk(LOWEST_EC_TYPE, &tmpFreeBlk);
if(result < 0)
{
MAPPING_ERR("[MAPPING_ERR] Get free block failed when create new log block!\n");
return -1;
}
//get a free block to create a new log block
result = BMM_GetFreeBlk(LOWEST_EC_TYPE, &tmpFreeBlk1);
if(result < 0)
{
MAPPING_ERR("[MAPPING_ERR] Get free block failed when create new log block!\n");
return -1;
}
//DBUG_INF("[DBUG] _CreateNewLogBlk, logic: %x, logblk0: %x, logblk1:%x \n", nBlk, tmpFreeBlk.PhyBlkNum, tmpFreeBlk1.PhyBlkNum);
//make a new log item in the log block table
LOG_BLK_TBL[tmpPst].LogicBlkNum = nBlk;
LOG_BLK_TBL[tmpPst].LastUsedPage = 0xffff;
LOG_BLK_TBL[tmpPst].LogBlkType = LogBlkType;
LOG_BLK_TBL[tmpPst].WriteBlkIndex = 0;
LOG_BLK_TBL[tmpPst].ReadBlkIndex = 0;
LOG_BLK_TBL[tmpPst].PhyBlk = tmpFreeBlk;
LOG_BLK_TBL[tmpPst].PhyBlk1 = tmpFreeBlk1;
//set the return vaule of the log position
*pLogPst = tmpPst;
}
else
{
//get a free block to create a new log block
result = BMM_GetFreeBlk(LOWEST_EC_TYPE, &tmpFreeBlk);
if(result < 0)
{
MAPPING_ERR("[MAPPING_ERR] Get free block failed when create new log block!\n");
return -1;
}
//make a new log item in the log block table
LOG_BLK_TBL[tmpPst].LogicBlkNum = nBlk;
LOG_BLK_TBL[tmpPst].LastUsedPage = 0xffff;
LOG_BLK_TBL[tmpPst].LogBlkType = LogBlkType;
LOG_BLK_TBL[tmpPst].WriteBlkIndex = 0;
LOG_BLK_TBL[tmpPst].ReadBlkIndex = 0;
LOG_BLK_TBL[tmpPst].PhyBlk = tmpFreeBlk;
//set the return vaule of the log position
*pLogPst = tmpPst;
}
__CHECK_LOGICAL_INFO_OF_DATA_BLOCK:
//check if the data block is an empty block, if so, need update the logic information in the spare area
LML_CalculatePhyOpPar(&tmpPhyPage, CUR_MAP_ZONE, DATA_BLK_TBL[nBlk].PhyBlkNum, 0);
tmpPhyPage.SectBitmap = 0x03;
tmpPhyPage.MDataPtr = LML_TEMP_BUF;
tmpPhyPage.SDataPtr = (void *)tmpSpare;
LML_VirtualPageRead(&tmpPhyPage);
if(tmpSpare[0].LogicInfo == 0xffff)
{
tmpSpare[0].BadBlkFlag = 0xff;
tmpSpare[1].BadBlkFlag = 0xff;
tmpSpare[0].LogicInfo = ((CUR_MAP_ZONE % ZONE_CNT_OF_DIE)<<10) | nBlk;
tmpSpare[1].LogicInfo = ((CUR_MAP_ZONE % ZONE_CNT_OF_DIE)<<10) | nBlk;
tmpSpare[0].LogicPageNum = 0xffff;
tmpSpare[1].LogicPageNum = 0xffff;
tmpSpare[0].PageStatus = 0xff;
tmpSpare[1].PageStatus = 0xff;
//write the logical information to the spare area of the data block
tmpPhyPage.SectBitmap = FULL_BITMAP_OF_SUPER_PAGE;
result = LML_VirtualPageWrite(&tmpPhyPage);
if(result < 0)
{
LOGICCTL_ERR("[MAPPING_ERR] Physical write module failed when write logical information, Err:0x%x!\n", result);
return -1;
}
result = PHY_SynchBank(tmpPhyPage.BankNum, SYNC_CHIP_MODE);
if(result < 0)
{
//the last write operation on current bank is failed, the block is bad, need proccess it
LOGICCTL_DBG("[LOGICCTL_DBG] Find a bad block when write logical page! bank:0x%x, block:0x%x, page:0x%x\n",
tmpPhyPage.BankNum, tmpPhyPage.BlkNum, tmpPhyPage.PageNum);
//process the bad block
result = LML_BadBlkManage(&DATA_BLK_TBL[nBlk], CUR_MAP_ZONE, 0, &tmpFreeBlk);
if(result < 0)
{
LOGICCTL_ERR("[MAPPING_ERR] Bad block process failed when create new log block, Err:0x%x!\n", result);
return -1;
}
DATA_BLK_TBL[nBlk] = tmpFreeBlk;
goto __CHECK_LOGICAL_INFO_OF_DATA_BLOCK;
}
}
return 0;
}
__s32 BMM_RleaseLogBlock(__u32 log_level)
{
__u32 tmpZoneNum, ZoneCnt, tmpLogPos;
__s32 result, release_logblk_cnt;
__s32 tmpPst=-1, i, ValidLogblkCnt = 0;
__u16 tmpLogAccessAge = 0xffff;
//check if need to release log block
ValidLogblkCnt = 0;
for(i=0; i<LOG_BLK_CNT_OF_ZONE; i++)
{
if(LOG_BLK_TBL[i].LogicBlkNum != 0xffff)
{
ValidLogblkCnt++;
}
}
//valid log block if less than log_level, no need to release log block
if(ValidLogblkCnt<=log_level)
return 0;
//PRINT("BMM_RleaseLogBlock\n");
BMM_SetDirtyFlag();
//check if there is some full log block
for(i=0; i<LOG_BLK_CNT_OF_ZONE; i++)
{
if(LOG_BLK_TBL[i].LastUsedPage == PAGE_CNT_OF_SUPER_BLK-1)
{
tmpPst = i;
break;
}
}
if(tmpPst == -1)
{
//there is no full log block, look for an oldest log block to merge
for(i=0; i<LOG_BLK_CNT_OF_ZONE; i++)
{
if((LOG_ACCESS_AGE[i] < tmpLogAccessAge)&&(LOG_BLK_TBL[i].LogicBlkNum != 0xffff))
{
tmpLogAccessAge = LOG_ACCESS_AGE[i];
tmpPst = i;
}
}
}
if(tmpPst == -1)
return -1;
//switch the page mapping table for merge the log block
result = PMM_SwitchMapTbl(tmpPst);
if(result < 0)
{
MAPPING_ERR("[MAPPING_ERR] Switch page mapping table failed when create new log block! Err:0x%x\n", result);
return -1;
}
//merge the log block with normal type, to make an empty item
result = LML_MergeLogBlk(NORMAL_MERGE_MODE, LOG_BLK_TBL[tmpPst].LogicBlkNum);
if(result < 0)
{
//merge log block failed, report error
MAPPING_ERR("[MAPPING_ERR] Merge log block failed when create new log block! Err:0x%x\n", result);
return -1;
}
return (ValidLogblkCnt-1);
}
