dbparser.cpp

AliEditor_Source code

	BO_set_head_freeaddr(addr + 4);


	//change old head sector status ERASING
	BO_read_sec_info(header_sec, &sec_info);
	sec_info.status = BO_SS_ERASING;
	BO_set_sec_list(header_sec, sec_info);
	BO_write_sec_info(header_sec, &sec_info);

	//erase old header sector
	if(DB_SUCCES != BO_erase_sector(header_sec))
		return DBERR_RECLAIM;
	return DB_SUCCES;	
}
INT32 CDbParser::BO_read_sec_info(UINT8 sec_idx, struct BO_Sec_Info *sec_info)
{
	UINT32 sector_index = sec_idx;
	
	if(sec_idx == 0xFF)
		return -1;
	return BO_read_data((sector_index<<NODE_ADDR_OFFSET_BIT), sizeof(struct BO_Sec_Info), (UINT8 *)sec_info);
}
void CDbParser::BO_set_sec_list(UINT8 sec_idx, struct BO_Sec_Info sec_info)
{
	memcpy(&bo_sec_list[sec_idx], &sec_info, sizeof(struct BO_Sec_Info));
}
INT32 CDbParser::BO_write_sec_info(UINT8 sec_idx, struct BO_Sec_Info *sec_info)
{
	UINT32 sector_index = sec_idx;
	
	if(sec_idx == 0xFF)
		return -1;
	return BO_flash_write((UINT8 *)sec_info, sizeof(struct BO_Sec_Info), (sector_index<<NODE_ADDR_OFFSET_BIT));

}
INT32 CDbParser::BO_get_free_sector(UINT8 *sec_index)
{
	UINT8 sec_num = bo_free_sec_list[0];
	UINT8 i = 1;
	
	if(sec_num > BO_RECLAIM_THRESHOLD)
	{
		*sec_index = bo_free_sec_list[1];
		for(; i < sec_num; i++)
			bo_free_sec_list[i] = bo_free_sec_list[i+1];
		
		bo_free_sec_list[0] -= 1;
		return DB_SUCCES;
	}
	else 
		return DBERR_BO_THRESHOLD;

}
UINT8 CDbParser::BO_get_reserve_sec()
{
	UINT8 sec_idx, i;
	
	//if(bo_free_sec_list[0] == BO_RECLAIM_THRESHOLD)
	if(bo_free_sec_list[0] > 0)
	{
		sec_idx = bo_free_sec_list[1];
		for(i = 1; i < bo_free_sec_list[0]; i++)
			bo_free_sec_list[i] = bo_free_sec_list[i+1];
		
		bo_free_sec_list[0] -= 1;		
		return sec_idx;
	}
	else
	{
		ASSERT(0);

		return -1;
	}
}
INT32 CDbParser::BO_set_header_addr(UINT32 addr)
{
	if(addr != 0xFFFFFFFF)
	{
		bo_header_addr = addr;
		return DB_SUCCES;
	}
	else
		return DBERR_PARAM;
}

INT32 CDbParser::BO_set_head_freeaddr(UINT32 addr)
{
	if(addr != 0xFFFFFFFF)
	{
		bo_head_free_addr = addr;
		return DB_SUCCES;
	}
	else
		return DBERR_PARAM;
}

INT32 CDbParser::BO_set_header_sec(UINT8 sec_idx)
{
	if(sec_idx != 0xFF)
	{
		bo_head_sec_index = sec_idx;
		return DB_SUCCES;
	}
	else
		return DBERR_PARAM;
}
INT32 CDbParser::BO_erase_sector(UINT8 sec_index)
{
	//struct sto_device * sto_dev = NULL;
	struct BO_Sec_Info *sec_info = &bo_sec_list[sec_index];
	UINT32 sector_idx = sec_index;
	UINT32 sector_size = DB_SECTOR_SIZE;
	
	UINT32 param = (sector_idx <<NODE_ADDR_OFFSET_BIT) + g_db_base_addr;

	//param = (param << 10) + (sector_size >> 10);

	//sto_dev = (struct sto_device *)dev_get_by_id(HLD_DEV_TYPE_STO, 0);

	/*change the sector status to BO_SS_ERASING*/
	//sec_info->status = BO_SS_ERASING;
	//if(BO_flash_write((UINT8 *)sec_info, sizeof(struct BO_Sec_Info), (UINT32)(sec_index<<NODE_ADDR_OFFSET_BIT)) != DB_SUCCES)
	//{
	//	BO_PRINTF("BO_erase_sector(): change sector %d status to erasing failed!\n",sec_index);
	//	return DBERR_BO_ERASE;
	//}

	/*begin to erase*/
/*
	if(sto_io_control(sto_flash_dev, STO_DRIVER_SECTOR_ERASE, param) != SUCCESS)
	{
		BO_PRINTF("BO_erase_sector(): Erase flash sector %d failed!\n",sec_index);
		return DBERR_BO_ERASE;
	}
*/
	memset((void *)param, 0xff, sector_size);
	
	/*after erasing, change sector status and erase_count, set valid flag*/
	UINT32 erase_cnt = sec_info->erase_count;

	memset((UINT8 *)sec_info,0xFF,sizeof(struct BO_Sec_Info));
	sec_info->status = BO_SS_SPARE;
	sec_info->erase_count = erase_cnt+1;
	sec_info->valid_flag = BO_VALID_FLAG;
	if(BO_flash_write((UINT8 *)sec_info, sizeof(struct BO_Sec_Info), (UINT32)(sec_index<<NODE_ADDR_OFFSET_BIT)) != DB_SUCCES)
	{
		//BO_PRINTF("BO_erase_sector(): change sector %d status to spare failed!\n",sec_index);
		return DBERR_BO_ERASE;
	}

#if defined(DB_MULTI_SECTOR)
	/*add the erased sector into free list*/
	if(BO_add_to_free_list(sec_index) != DB_SUCCES)
	{
		//BO_PRINTF("BO_erase_sector(): add sector %d into free list failed!\n",sec_index);
		return DBERR_BO_ERASE;
	}
#endif
	return DB_SUCCES;
}
INT32 CDbParser::DO_set_table_node_length(INT32 len)
{
	db_table_node_length = len;
	return DB_SUCCES;
}
INT32 CDbParser::BO_get_free_addr_in_sector(UINT8 sec_index, UINT8 search_type,UINT8 mode, UINT32 *free_addr)
{
	UINT32 start_addr= 0;
	UINT32 end_addr= 0;
	UINT32 tmp;
	UINT32 sector_idx = sec_index;
	UINT32 tmp_free;
	UINT8 tmp2[4];
	UINT8 i;

	if(mode == BO_SEARCH_FROM_START)
	{
		start_addr = (sector_idx <<NODE_ADDR_OFFSET_BIT) + BO_SECTOR_INFO_SIZE;
		end_addr = ((sector_idx + 1) <<NODE_ADDR_OFFSET_BIT) -4;
	}
	else if(mode == BO_SEARCH_FROM_END)
	{
		start_addr = ((sector_idx + 1) <<NODE_ADDR_OFFSET_BIT) -4;
		end_addr = (sector_idx <<NODE_ADDR_OFFSET_BIT) + BO_SECTOR_INFO_SIZE;
	}

	if(mode == BO_SEARCH_FROM_START)
	{
		while(start_addr < end_addr)
		{
			if(BO_read_data(start_addr,4, (UINT8 *)&tmp) != DB_SUCCES)
				return DBERR_BO_READ;
			
			if(tmp == 0xFFFFFFFF)
			{
				tmp_free = start_addr;
				//check if tmp_free is at sector info end
				if((search_type == BO_SEARCH_OPERATION) &&
					(tmp_free-4 >= ((sector_idx<<NODE_ADDR_OFFSET_BIT)+BO_SECTOR_INFO_SIZE)))
				{
					//check if the 3 bytes before is 0xFF
					BO_read_data(tmp_free-4,4, tmp2);
					for(i = 0; i < 4; i++)
					{
						if(tmp2[3-i] != 0xFF)
						{
							*free_addr = tmp_free - i;
							return DB_SUCCES;
						}
					}
				}
				*free_addr = tmp_free;
				return DB_SUCCES;
			}
			else
				start_addr += 4;
		}
		*free_addr = end_addr;
		return DB_SUCCES;
	}
	else if(mode == BO_SEARCH_FROM_END)
	{
		while(start_addr > end_addr)
		{
			if(BO_read_data(start_addr,4, (UINT8 *)&tmp) != DB_SUCCES)
				return DBERR_BO_READ;
			
			if(tmp == 0xFFFFFFFF)
			{
				tmp_free = start_addr + 4;
				/*
				//check if the 3 bytes next is 0xFF
				BO_read_data(tmp_free,4, tmp2);
				for(i = 0; i < 4; i++)
				{
					if(tmp2[i] != 0xFF)
					{
						*free_addr = tmp_free + i;
						return DB_SUCCES;
					}
				}
				*/
				*free_addr = tmp_free;
				return DB_SUCCES;
			}
			else
				start_addr -= 4;
		}
		*free_addr = end_addr;
		return DB_SUCCES;
	}
	return DB_SUCCES;
}

INT32 CDbParser::BO_add_to_free_list(UINT8 sec_index)
{
	UINT8 sec_num = bo_free_sec_list[0];

	if(sec_index >= m_nSectorNum)
	{
		//BO_PRINTF("BO_add_to_free_list(): invalid param!\n");
		return DBERR_PARAM;
	}

	bo_free_sec_list[sec_num+1] = sec_index;
	bo_free_sec_list[0] += 1;
	return DB_SUCCES;

}

INT32 CDbParser::BO_sector_diagnose( UINT8 sec_idx, struct BO_Sec_Info *sec_info)
{
	UINT32 i, addr, tmp;
	INT32 ret = DB_SUCCES;
	UINT32 sector_idx = sec_idx;
	UINT8 sector_err = 0;
	
	if(((sec_info->status == BO_SS_VALID) || (sec_info->status == BO_SS_SPARE)) && (sec_info->valid_flag == BO_VALID_FLAG))
	{
		return DB_SUCCES;
	}
	//be selected as reclaim source sector, then maybe power loss
	else if((sec_info->status == BO_SS_SELECT)&& (sec_info->valid_flag == BO_VALID_FLAG))
	{
		//BO_PRINTF("BO_sector_diagnose():power loss after change sector %d status to select, now change its status back to valid!\n ",sector_idx);
		return DB_SUCCES;
	}
	//as reclaim dest sector, during data copying, maybe power loss
	else if((sec_info->status == BO_SS_COPYING) && (sec_info->valid_flag == BO_VALID_FLAG))
	{
		//BO_PRINTF("BO_sector_diagnose(): power loss during copy data to sector %d, now erase it!\n",sector_idx);
		ret = BO_erase_sector(sector_idx);
	}
	else if(sec_info->type == BO_TYPE_UNKNOWN &&sec_info->status == BO_SS_UNKNOWN
					&& sec_info->logic_number == 0xFFFFFFFF 
					&& sec_info->erase_count == 0xFFFFFFFF
					&& sec_info->valid_flag == 0xFF)
	{	//check last 16 bytes of the sector 
		addr = ((sector_idx+1)<<NODE_ADDR_OFFSET_BIT)-16;
		for(i = 0; i < 16; i += 4)
		{	
			BO_read_data(addr+i, 4, (UINT8 *)&tmp);
			if(tmp != 0xFFFFFFFF)
			{	
				sector_err = 1;
				break;
			}
		}
		//power loss during erasing
		if(sector_err == 1)
		{
			//BO_PRINTF("BO_sector_diagnose():power loss during erase sector %d, now erase it!\n ",sector_idx);
			ret = BO_erase_sector(sector_idx);
		}
		//first init after buring flash
		else
		{
			sec_info->status = BO_SS_SPARE;
			sec_info->erase_count = 0;
			sec_info->valid_flag = BO_VALID_FLAG;
			ret = BO_flash_write((UINT8 *)sec_info, sizeof(struct BO_Sec_Info), sector_idx<<NODE_ADDR_OFFSET_BIT);
		}
	}
	//other errors
	else
	{
		//BO_PRINTF("BO_sector_diagnose(): unknown error in sector %d, now erase it!\n",sector_idx);
		ret = BO_erase_sector(sector_idx);
	}
	return ret;
}

UINT32 CDbParser::BO_get_max_logicnum(UINT8 *sec_index)
{
	UINT32 max_logic_num = 0;
	UINT8 i = 0;
			
	for(;i < m_nSectorNum; i++)
	{
		if((bo_sec_list[i].type == BO_TYPE_DATA) && (bo_sec_list[i].status == BO_SS_VALID ||bo_sec_list[i].status == BO_SS_SELECT)
			&& (bo_sec_list[i].logic_number > max_logic_num))				
			max_logic_num = bo_sec_list[i].logic_number;
	}
	if(max_logic_num > 0)
	{
		for(i = 0;i < m_nSectorNum; i++)
		{
			if(max_logic_num == bo_sec_list[i].logic_number)
			break;
		}
		*sec_index = i ;
		return max_logic_num;

	}
	else
	{
		*sec_index = 0xFF;
		return 0xFFFFFFFF;
	}

}

INT32 CDbParser::BO_reset( )
{
	bo_header_addr = 0xFFFFFFFF;
	bo_head_free_addr = 0xFFFFFFFF;
	bo_data_free_addr = 0xFFFFFFFF;
	m_nSectorNum = 0;

	if(bo_sec_list != NULL)
	{	
		free(bo_sec_list);
		bo_sec_list = NULL;
	}
	
#if defined(DB_MULTI_SECTOR)
	bo_cur_data_sec_index = 0xFF;
	bo_head_sec_index = 0xFF;
#endif

	return DB_SUCCES;

}

int CDbParser::_create_empty_header(db_header_t *pdbhead)
{
	memcpy(&pdbhead->head_prefix, T_HEADER_ID_PREFIX, 4);
	pdbhead->head_prefix[4] = 0;

	pdbhead->version = 0;

	pdbhead->field_num = 0;

	if(pdbhead->pfield) delete[] pdbhead->pfield;
	pdbhead->pfield = NULL;

//	pdbhead->rec_num = 0;
	pdbhead->rec_length = 0;

	if(pdbhead->precord) delete[] pdbhead->precord;
	pdbhead->precord = NULL;

	pdbhead->end_flag = T_WRITE_END_FLAG;
	
	return 0;
}
int CDbParser::InitDb3Header()//init_parser()
{
	free_all_db3_headers();
	
//	g_table_base_addr = 0;
//	g_table_info_len = 0;

	memset(&m_tpheader, 0, sizeof(m_tpheader));
	memset(&m_satheader, 0, sizeof(m_satheader));
	memset(&m_progheader, 0, sizeof(m_progheader));

	return 0;
}
int CDbParser::free_all_db3_headers()//free_all_headers()
{
	free_db3_header(&m_progheader);
	free_db3_header(&m_satheader);
	free_db3_header(&m_tpheader);
	
	return 0;
}
int CDbParser::free_db3_header(db_header_t *pdbhead)//free_header(db_header_t *pdbhead)
{
	if(pdbhead->pfield) delete[] pdbhead->pfield;

	if(pdbhead->precord) delete[] pdbhead->precord;
	
	return 0;
}
int	CDbParser::db4_to_db3_header()
{
	int ret;

	ret = _db4_2_db3_header(&db_table[TYPE_SAT_NODE], &m_satheader);

	ASSERT(ret != -1);
	if(ret == -1) return -1;
	ret = _db4_2_db3_header(&db_table[TYPE_TP_NODE], &m_tpheader);

	ASSERT(ret != -1);
	if(ret == -1) return -1;

	ret = _db4_2_db3_header(&db_table[TYPE_PROG_NODE], &m_progheader);

	ASSERT(ret != -1);
	if(ret == -1) return -1;

	return 0;
}
int CDbParser::_db4_2_db3_header(DB_TABLE *pdb_table,db_header_t *pdbhead)
{
	int i;
	if(!pdb_table || !pdbhead) return -1;

	//pdbhead->rec_length = pdbhead->rec_num = pdb_table->node_num;
	pdbhead->rec_length = pdb_table->node_num;
	if(!pdbhead->rec_length) return 0;

	if(pdbhead->precord) delete []pdbhead->precord;
	pdbhead->precord = new UINT32[pdb_table->node_num];

	memset(pdbhead->precord, -1, sizeof(UINT32) * pdb_table->node_num);

	for(i = 0; i < pdb_table->node_num; i++)
	{
		pdbhead->precord[i] = 0;
		
		memcpy(&pdbhead->precord[i], pdb_table->table_buf[i].node_addr, sizeof(pdb_table->table_buf->node_addr));
	}

	return 0;
}
BOOL CDbParser::DB4_to_DB3_transfer()
{
	CStringLines *pScripter = &((CMainFrame*)AfxGetMainWnd())->GetEditorView()->m_strlines;
	int bRet;
	
	int i;//, tmp_addr;
	int prog_node_size, tp_node_size, sat_node_size;
	
	char *pdatabuf = m_pdatabuf;
	if(!pdatabuf) return FALSE;

	tp_node_size = pScripter->GetNodeSize(TP_NODE);
	sat_node_size = pScripter->GetNodeSize(SAT_NODE);
	prog_node_size = pScripter->GetNodeSize(PROG_NODE);

	if(!tp_node_size || !sat_node_size || !prog_node_size) return FALSE;

	char *backup_buf = new char[DATA_LIMIT_LEN];
	if(!backup_buf) return FALSE;
	
	memset(backup_buf, -1, DATA_LIMIT_LEN);

	db_header_t *pdbheader  = &m_satheader;//for sat node

	int free_addr = 0;

	//skip -1
	for(i = 0; i < pdbheader->rec_length; i++)
	{
		if(pdbheader->precord[i] == -1) continue;

		bRet = UnpackNode(SAT_NODE, backup_buf + free_addr, pdatabuf + pdbheader->precord[i]);