__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;
}
/*post current zone map table in cache*/
static __s32 _page_map_tbl_cache_post(__u32 nLogBlkPst)
{
__u8 poisition;
__u8 i;
struct __BlkMapTblCache_t *TmpBmt = BLK_MAP_CACHE;
/*find the cache to be post*/
poisition = _find_page_tbl_post_location();
PAGE_MAP_CACHE = &(PAGE_MAP_CACHE_POOL->PageMapTblCachePool[poisition]);
if (PAGE_MAP_CACHE->DirtyFlag && (PAGE_MAP_CACHE->ZoneNum != 0xff)) {
/*write back page map table*/
if (PAGE_MAP_CACHE->ZoneNum != TmpBmt->ZoneNum) {
for (i = 0; i < BLOCK_MAP_TBL_CACHE_CNT; i++)
{
if (BLK_MAP_CACHE_POOL->BlkMapTblCachePool[i].ZoneNum == PAGE_MAP_CACHE->ZoneNum) {
BLK_MAP_CACHE = &(BLK_MAP_CACHE_POOL->BlkMapTblCachePool[i]);
break;
}
}
if (i == BLOCK_MAP_TBL_CACHE_CNT) {
MAPPING_ERR("_page_map_tbl_cache_post : position %d ,page map zone %d,blk map zone %d\n",
poisition,PAGE_MAP_CACHE->ZoneNum,BLK_MAP_CACHE->ZoneNum);
return NAND_OP_FALSE;
}
}
/* write back new table in flash if dirty*/
BMM_SetDirtyFlag();
if (NAND_OP_TRUE != _write_back_page_map_tbl(PAGE_MAP_CACHE->LogBlkPst)) {
MAPPING_ERR("write back page tbl err\n");
return NAND_OP_FALSE;
}
BLK_MAP_CACHE = TmpBmt;
}
PAGE_MAP_CACHE->DirtyFlag = 0;
/*fetch current page map table*/
if (NAND_OP_TRUE != _read_page_map_tbl(nLogBlkPst)) {
MAPPING_ERR("read page map tbl err\n");
return NAND_OP_FALSE;
}
PAGE_MAP_CACHE->ZoneNum = CUR_MAP_ZONE;
PAGE_MAP_CACHE->LogBlkPst = nLogBlkPst;
return NAND_OP_TRUE;
}
static __s32 _rebuild_page_map_tbl(__u32 nLogBlkPst)
{
__s32 ret;
__u16 TablePage;
__u32 TableBlk;
__u16 logicpagenum;
//__u8 status;
struct __NandUserData_t UserData[2];
struct __PhysicOpPara_t param;
MEMSET(PAGE_MAP_TBL,0xff, PAGE_CNT_OF_SUPER_BLK*sizeof(struct __PageMapTblItem_t));
TableBlk = LOG_BLK_TBL[nLogBlkPst].PhyBlk.PhyBlkNum;
param.MDataPtr = LML_PROCESS_TBL_BUF;
param.SDataPtr = (void *)&UserData;
param.SectBitmap = 0x3;
//PRINT("-----------------------rebuild page table for blk %x\n",TableBlk);
for(TablePage = 0; TablePage < PAGE_CNT_OF_SUPER_BLK; TablePage++) {
LML_CalculatePhyOpPar(¶m, CUR_MAP_ZONE, TableBlk, TablePage);
ret = LML_VirtualPageRead(¶m);
if (ret < 0) {
MAPPING_ERR("rebuild logic block %x page map table : read err\n",LOG_BLK_TBL[nLogBlkPst].LogicBlkNum);
return NAND_OP_FALSE;
}
//status = UserData[0].PageStatus;
logicpagenum = UserData[0].LogicPageNum;
//if(((!TablePage || (status == 0x55))) && (logicpagenum != 0xffff) && (logicpagenum < PAGE_CNT_OF_SUPER_BLK)) /*legal page*/
if((logicpagenum != 0xffff) && (logicpagenum < PAGE_CNT_OF_SUPER_BLK)) /*legal page*/
{
PAGE_MAP_TBL[logicpagenum].PhyPageNum = TablePage; /*l2p:logical to physical*/
}
}
PAGE_MAP_CACHE->DirtyFlag = 1;
BMM_SetDirtyFlag();
return NAND_OP_TRUE;
}
__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);
}
__s32 BMM_GetLogReleasePos(__u32 log_level)
{
__s32 result;
__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 tmpPst;
//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;
}
}
}
//PRINT("BMM_GetLogReleasePos: %d, validlog: %d\n", tmpPst, ValidLogblkCnt);
//PRINT("nand validlog: %d\n", ValidLogblkCnt);
#if 0
for(i=0;i<LOG_BLK_CNT_OF_ZONE; i+=8)
{
int j;
for(j=0; j<8; j++)
{
PRINT(" 0x%x", LOG_ACCESS_AGE[i*8+j]);
}
PRINT("\n");
}
#endif
return tmpPst;
}
