dbparser.cpp

AliEditor_Source code

			bo_cur_data_sec_index = free_sec_idx;
			
			bo_sec_list[bo_head_sec_index].type = BO_TYPE_HEAD;
			bo_sec_list[bo_head_sec_index].status = BO_SS_VALID;
			if(BO_flash_write((UINT8 *)&bo_sec_list[bo_head_sec_index], sizeof(struct BO_Sec_Info), (UINT32)(bo_head_sec_index<<NODE_ADDR_OFFSET_BIT)) != DB_SUCCES)
			{
				//BO_PRINTF("BO_init(): set sector 0  to head failed!\n");
				return DBERR_BO_INIT;
			}
			bo_sec_list[bo_cur_data_sec_index].type = BO_TYPE_DATA;
			bo_sec_list[bo_cur_data_sec_index].status = BO_SS_VALID;
			bo_sec_list[bo_cur_data_sec_index].logic_number = 1;
			if(BO_flash_write((UINT8 *)&bo_sec_list[bo_cur_data_sec_index], sizeof(struct BO_Sec_Info), (UINT32)(bo_cur_data_sec_index<<NODE_ADDR_OFFSET_BIT)) != DB_SUCCES)
			{
				//BO_PRINTF("BO_init(): set sector 1  to data failed!\n");
				return DBERR_BO_INIT;
			}
			
		}
		else if(BO_get_max_logicnum(&bo_cur_data_sec_index) == 0xFFFFFFFF)
		{
			//BO_PRINTF("BO_init(): get current data sec index failed!\n");
			return DBERR_BO_INIT;
		}
#endif
	}

	/*addr init*/
	if(bo_head_free_addr == 0xFFFFFFFF)
	{
		if(BO_get_free_addr_in_sector(bo_head_sec_index, BO_SEARCH_OPERATION,BO_SEARCH_FROM_START, &head_free_addr) != DB_SUCCES)
		{
			//BO_PRINTF("BO_init(): init head free addr failed!\n");
			return DBERR_BO_INIT;
		}
		bo_head_free_addr = head_free_addr;

	}
	if(bo_data_free_addr == 0xFFFFFFFF)
	{
		if(m_nSectorNum == 1)
		{
			if(BO_get_free_addr_in_sector(bo_cur_data_sec_index, BO_SEARCH_DATA,BO_SEARCH_FROM_END, &data_free_addr) != DB_SUCCES)
			{
				//BO_PRINTF("BO_init(): init data free addr failed!\n");
				return DBERR_BO_INIT;
			}
		}
		else
		{
			if(BO_get_free_addr_in_sector(bo_cur_data_sec_index, BO_SEARCH_DATA,BO_SEARCH_FROM_START, &data_free_addr) != DB_SUCCES)
			{
				//BO_PRINTF("BO_init(): init data free addr failed!\n");
				return DBERR_BO_INIT;
			}
		}

		bo_data_free_addr = data_free_addr;
		
	}
	
	return DB_SUCCES;

}

INT32 CDbParser::BO_flash_write(UINT8 *data, UINT32 len, UINT32 addr)
{
//	INT32 ret = 0;
//	INT32 bytes_write = 0;
	
	if(addr+len > g_db_length)
	{
		//BO_PRINTF("BO_flash_write(): invalid addr!\n");	
		return -1;
	}
	memcpy((char *)g_db_base_addr + addr, data, len);

	return 0;
	
	//sto_dev = (struct sto_device *)dev_get_by_id(HLD_DEV_TYPE_STO, 0);
	/*	
	bytes_write = sto_put_data(sto_flash_dev, addr+g_db_base_addr, data, (INT32)len);
	if(bytes_write == (INT32)len)
		return DB_SUCCES;
	else
	{
		BO_PRINTF("BO_flash_write(): sto_write error at addr %x, %d bytes write!\n",addr,bytes_write);
		return DBERR_BO_WRITE;
	}
	*/
}

INT32 CDbParser::BO_read_data(UINT32 addr, UINT32 len, UINT8 *data)
{

	if(addr + len > g_db_length)
	{
		//BO_PRINTF("BO_read_data(): invalid addr!\n");	
		return -1;
	}

	memcpy(data, (char *)g_db_base_addr + addr, len);

	return 0;
	/*
	if(sto_get_data(sto_flash_dev, data, addr+g_db_base_addr, (INT32)len) == (INT32)len)
		return 0;
	else
	{
		BO_PRINTF("BO_read_data(): sto_read error at addr %x\n",addr);
		return -1;
	}
	*/
}

INT32 CDbParser::BO_get_header(UINT32 *head_addr, UINT16 *node_num,UINT32 *free_addr)
{
	UINT32 start_addr= 0;
	UINT32 end_addr = 0;
	UINT32 tmp;
	UINT16 num = 0;
	UINT8 i, flag1;
	UINT32 head_start_flag = BO_HEADER_START;
	UINT32 head_end_flag = BO_HEADER_END;
	UINT32 sec_idx = bo_head_sec_index;

	if(bo_header_addr != 0xFFFFFFFF)
	{
		*head_addr = bo_header_addr;
		BO_read_data(bo_header_addr+4, 2, (UINT8 *)node_num);
		*free_addr = bo_head_free_addr;
		return 0;
	}


	start_addr = (sec_idx <<NODE_ADDR_OFFSET_BIT) + BO_SECTOR_INFO_SIZE;
	end_addr = bo_head_free_addr;

	if(end_addr == start_addr)
	{
		UINT8 empty_head[10];
		memcpy(empty_head, (UINT8 *)&head_start_flag,4);
		memset(&empty_head[4], 0, 2);
		memcpy(&empty_head[6], (UINT8 *)&head_end_flag,4);
		if(BO_flash_write(empty_head, 10, start_addr)!= DB_SUCCES)
			return -1;
		else
		{
			bo_head_free_addr = start_addr + 10;
			*head_addr = start_addr;
			*node_num = 0;
			*free_addr = bo_head_free_addr;
			return DB_SUCCES;
		}

	}

	while(start_addr < end_addr)
	{
		flag1 = 1;
		
		if(BO_read_data(start_addr,4, (UINT8 *)&tmp) != DB_SUCCES)
				return -1;
		for(i = 0;i < 4; i++)			
		{
			if(*((UINT8 *)&tmp + i) != *((UINT8 *)&head_start_flag + i))
			{
				flag1 = 0;
				break;
			}
		}

		if(flag1 == 1)
		{
			if(BO_read_data(start_addr+4, 2, (UINT8 *)&num) != DB_SUCCES)
				return -1;

			if(BO_read_data(start_addr+4+2+num*BO_HEADER_NODE_SIZE, 4, (UINT8 *)&tmp) != DB_SUCCES)
				return -1;

			if(tmp == BO_HEADER_END)
			{
				*head_addr = bo_header_addr = start_addr;
				*node_num = num;
				*free_addr = end_addr;
				return DB_SUCCES;
			}
		
		}
		else 
			start_addr++;
	}

	return -1;
}

UINT8 CDbParser::DO_get_node_type(UINT32 node_id)
{
	if(((node_id&SET_BIT_MASK) != 0) && ((node_id&TP_BIT_MASK) == 0) &&((node_id&PG_BIT_MASK) == 0))
		return TYPE_SAT_NODE;
	if(((node_id&TP_BIT_MASK) != 0) &&((node_id&PG_BIT_MASK) == 0))
		return TYPE_TP_NODE;
	else if(((node_id&TP_BIT_MASK) != 0) &&((node_id&PG_BIT_MASK) != 0))
		return TYPE_PROG_NODE;
	else
		return TYPE_UNKNOWN_NODE;	
}

INT32 CDbParser::DO_t_process_operation(OP_PARAM param, UINT8 *temp_buf)
{
	UINT16 i = 0;
	DB_TABLE *t_attr = (DB_TABLE *)&db_table[0];
	UINT32 node_id = 0;
	UINT8 node_type = TYPE_UNKNOWN_NODE;
	//UINT8 *temp_buf = NULL;//give a block of memory , maybe frame buffer

	/* not compute node length in this function
	INT32 table_node_len = DO_get_table_node_length();
	INT32 del_node_len;
	UINT8 tmp[4];
	UINT32 node_addr = 0;
	UINT8 node_len1, node_len2;
	*/

	memcpy((UINT8 *)&node_id, param.node_id, NODE_ID_SIZE);
	if( node_id == 0 )
		return -1;
	node_type = DO_get_node_type(node_id);
	if(param.valid_flag != OP_VALID_FLAG || node_type == TYPE_UNKNOWN_NODE)
	{
		//DO_PRINTF("DO_t_process_operation():invalid operation or unnknown node type !\n");
		return -1;
	}
	//for add operation
	if(param.op_type == OPERATION_ADD)
	{
		//DO_PRINTF("ADD operation: add node by id %d\n",node_id);
		//if node num to max cnt, rearrange table
		if(t_attr[node_type].node_num >= t_attr[node_type].max_cnt)
			DO_table_rearrange(&t_attr[node_type], temp_buf);
		
		memcpy((UINT8 *)&(t_attr[node_type].table_buf[t_attr[node_type].node_num]), (UINT8 *)&param + 1, BO_HEADER_NODE_SIZE);
		t_attr[node_type].node_num++;
		/* not compute node length here
		MEMCPY((UINT8 *)&node_addr, param.node_addr, NODE_ADDR_SIZE);
		BO_read_data(node_addr,4, tmp);
		table_node_len += (INT32)tmp[NODE_ID_SIZE] + NODE_ID_SIZE;
		*/
	}
	//for edit operation
	else if(param.op_type == OPERATION_EDIT)
	{
		for(i = 0; i < t_attr[node_type].node_num; i++)
		{
			if(0 == memcmp((UINT8 *)&t_attr[node_type].table_buf[i], param.node_id, NODE_ID_SIZE))
				break;
		}
		if(i == t_attr[node_type].node_num)
		{
			//DO_PRINTF("EDIT operation not find node by id %d\n",node_id);
			return -1;	
		}
		/* not compute node length here
		MEMCPY((UINT8 *)&node_addr, t_attr[node_type].table_buf[i].node_addr, NODE_ADDR_SIZE);
		BO_read_data(node_addr, 4, tmp);
		node_len1 = tmp[NODE_ID_SIZE];
		MEMCPY((UINT8 *)&node_addr, param.node_addr, NODE_ADDR_SIZE);							
		BO_read_data(node_addr,4, tmp);
		node_len2 = tmp[NODE_ID_SIZE];		
		table_node_len += (INT32)(node_len2 - node_len1);
		*/
		//DO_PRINTF("EDIT operation: modify node by id %d at pos %d\n",node_id, i);
		memcpy((UINT8 *)&(t_attr[node_type].table_buf[i]), (UINT8 *)&param + 1, BO_HEADER_NODE_SIZE);
		
	}
	//for del operation
	else if(param.op_type == OPERATION_DEL)
	{
		//del a set, first flag its pg id  invalid, then the tp id
		if(node_type == TYPE_SAT_NODE)
		{
			//DO_PRINTF("DEL operation: del a set by id %d\n",node_id);
			//for del operation, the node_addr[3] stores the data length under this node id
			if(param.node_addr[0] != 0 || param.node_addr[1] != 0 || param.node_addr[2] != 0)
			{
				for(i = 0; i < t_attr[TYPE_PROG_NODE].node_num; i++)
				{
					if(param.node_id[NODE_ID_SIZE-1] == t_attr[TYPE_PROG_NODE].table_buf[i].node_id[NODE_ID_SIZE-1]) 
					{	
						t_attr[TYPE_PROG_NODE].table_buf[i].node_id[NODE_ID_SIZE-1] = 0xFF;
						
					}
				}
			
				for(i = 0; i < t_attr[TYPE_TP_NODE].node_num; i++)
				{
					if(param.node_id[NODE_ID_SIZE-1] == t_attr[TYPE_TP_NODE].table_buf[i].node_id[NODE_ID_SIZE-1]) 
					{
						t_attr[TYPE_TP_NODE].table_buf[i].node_id[NODE_ID_SIZE-1] = 0xFF;
						
					}
				}	
			}

		}
		//del a tp, flag its pg id  invalid
		else if(node_type == TYPE_TP_NODE)
		{
			//for del operation, the node_addr[3] stores the data length under this node id
			if(param.node_addr[0] != 0 || param.node_addr[1] != 0 || param.node_addr[2] != 0)
			{
				for(i = 0; i < t_attr[TYPE_PROG_NODE].node_num; i++)
				{
					if((param.node_id[NODE_ID_SIZE-1]==t_attr[TYPE_PROG_NODE].table_buf[i].node_id[NODE_ID_SIZE-1]) &&
						(param.node_id[NODE_ID_SIZE-2]==t_attr[TYPE_PROG_NODE].table_buf[i].node_id[NODE_ID_SIZE-2]))
						{
							t_attr[TYPE_PROG_NODE].table_buf[i].node_id[NODE_ID_SIZE-1] = 0xFF;
						
						}
				}
			}
		}

		for(i = 0; i < t_attr[node_type].node_num; i++)
		{
			if(0 == memcmp((UINT8 *)&t_attr[node_type].table_buf[i], param.node_id, NODE_ID_SIZE))
				break;
		}
		if(i == t_attr[node_type].node_num)
		{
			//DO_PRINTF("DEL operation not find node by id %d\n",node_id);
			return -1;	
		}
		//flag the node itself id invalid
		t_attr[node_type].table_buf[i].node_id[NODE_ID_SIZE-1] = 0xFF;
		/* not compute node length here
		del_node_len = 0;
		MEMCPY((UINT8 *)&del_node_len, t_attr[node_type].table_buf[i].node_addr, NODE_ADDR_SIZE);
		table_node_len -= del_node_len ;
		*/			
	}
	
	return DB_SUCCES;
}

INT32 CDbParser::DO_table_rearrange(DB_TABLE *t, UINT8 *buf)
{
	UINT16 i;
	UINT16 node_num = 0;

	//DO_PRINTF("DO_table_rearrange():before rearrange node num = %d!\n", t->node_num);
	
	for(i = 0; i < t->node_num; i++)
	{
		if(t->table_buf[i].node_id[NODE_ID_SIZE-1] != 0xFF)
		{
			memcpy(buf+node_num*sizeof(NODE_IDX_PARAM), (UINT8 *)&t->table_buf[i],  sizeof(NODE_IDX_PARAM));
			node_num++;
		}

	}
	//DO_PRINTF("after table rearrange ,valid node num = %d!\n", node_num);
	memcpy((UINT8 *)t->table_buf, buf, node_num*sizeof(NODE_IDX_PARAM));
	t->node_num = node_num;

	return DB_SUCCES;

}

INT32 CDbParser::DB_reclaim_write_header()
{
	UINT32 tmp;
	UINT16 node_num = 0;
	UINT16 i;
	DB_TABLE *table = (DB_TABLE *)&db_table[0];
	UINT8 head_sec, tmp_sec;
	INT32 ret = DB_SUCCES;
	UINT32 addr = 0;
	UINT32 old_head_addr, old_free_addr;
	UINT16 old_node_num;
	
	for(i = 0; i < DB_TABLE_NUM; i++)
	{
		node_num += table[i].node_num;

	}
	BO_get_header(&old_head_addr,&old_node_num,&old_free_addr);
	head_sec = BO_get_header_sec();
	tmp_sec = (UINT8)((old_free_addr + node_num * BO_HEADER_NODE_SIZE+ 10)>>NODE_ADDR_OFFSET_BIT);
	if(tmp_sec != head_sec)
	{
		ret = DB_reclaim_operation();
		if(ret != DB_SUCCES)
		{
			//RECLAIM_PRINTF("DB_reclaim_write_header() failed!\n");
			return DBERR_RECLAIM;
		}
		return ret;
	
	}
	else
	{
		//BO_get_header(&old_head_addr,&old_node_num,&old_free_addr);
		addr = old_free_addr;
		BO_set_header_addr(addr);
		tmp = BO_HEADER_START;
		BO_flash_write((UINT8 *)&tmp, 4, addr);
		addr += 4;
		BO_flash_write((UINT8 *)&node_num, 2, addr);
		addr += 2;
		for(i = 0; i < DB_TABLE_NUM; i++)
		{
			BO_flash_write((UINT8 *)table[i].table_buf,  table[i].node_num*sizeof(NODE_IDX_PARAM), addr);
			addr += table[i].node_num*sizeof(NODE_IDX_PARAM);
		}
		tmp = BO_HEADER_END;
		BO_flash_write((UINT8 *)&tmp, 4, addr);
		BO_set_head_freeaddr(addr + 4);

		tmp = 0;
		BO_flash_write((UINT8 *)&tmp, 4, old_head_addr);
		BO_flash_write((UINT8 *)&tmp, 4, old_head_addr+old_node_num*BO_HEADER_NODE_SIZE+6);

		return DB_SUCCES;
	}
}

UINT8 CDbParser::BO_get_header_sec()
{
	return bo_head_sec_index;
}

INT32 CDbParser::DB_reclaim_operation()
{
	struct BO_Sec_Info sec_info;
	UINT8 header_sec, reclaim_sec;
	INT32 ret = DB_SUCCES;
	UINT32 addr;
	UINT32 tmp;
	UINT16 node_num = 0;
	UINT16 i;
	DB_TABLE *table = (DB_TABLE *)&db_table[0];
	

	//get header sector, change its status
	/*
	header_sec = BO_get_header_sec();
	if(header_sec == 0xFF)
	{
		RECLAIM_PRINTF("DB_reclaim_operation(): header sector index invalid!\n");
		return DBERR_RECLAIM;
	}
	*/
	//RECLAIM_PRINTF("DB_reclaim_operation()!\n");
	
	header_sec = BO_get_header_sec();
	BO_read_sec_info(header_sec, &sec_info);
	sec_info.status = BO_SS_SELECT;
	BO_set_sec_list(header_sec, sec_info);
	ret = BO_write_sec_info(header_sec, &sec_info);
	if(ret != DB_SUCCES)
	{
		//RECLAIM_PRINTF("write header sector %d info to SELECT failed!\n",header_sec);
		return -1;
	}

	//find reclaim sector, change its type,status
	if(DBERR_BO_THRESHOLD == BO_get_free_sector(&reclaim_sec))
		reclaim_sec = BO_get_reserve_sec();
	BO_read_sec_info(reclaim_sec, &sec_info);
	sec_info.type = BO_TYPE_HEAD;
	sec_info.status = BO_SS_COPYING;
	BO_set_sec_list(reclaim_sec, sec_info);
	ret = BO_write_sec_info(reclaim_sec, &sec_info);
	if(ret != DB_SUCCES)
	{
		//RECLAIM_PRINTF("write reclaim sector %d info to COPYING failed!\n",reclaim_sec);
		return DBERR_RECLAIM;
	}

	//write table header into flash
	//RECLAIM_PRINTF("begin to write all table header to flash!\n");
	tmp = reclaim_sec;
	addr = (tmp<<NODE_ADDR_OFFSET_BIT) + BO_SECTOR_INFO_SIZE;

	BO_set_header_addr(addr);
	tmp = BO_HEADER_START;
	BO_flash_write((UINT8 *)&tmp, 4, addr);
	addr += 4;
	for(i = 0; i < DB_TABLE_NUM; i++)
	{
		node_num += table[i].node_num;
	}
	BO_flash_write((UINT8 *)&node_num, 2, addr);
	addr += 2;
	
	for(i = 0; i < DB_TABLE_NUM; i++)
	{
		BO_flash_write((UINT8 *)table[i].table_buf,  table[i].node_num*sizeof(NODE_IDX_PARAM), addr);
		addr += table[i].node_num*sizeof(NODE_IDX_PARAM);
	}
	tmp = BO_HEADER_END;
	BO_flash_write((UINT8 *)&tmp, 4, addr);

	//change reclaim sector status VALID
	BO_read_sec_info(reclaim_sec, &sec_info);
	sec_info.status = BO_SS_VALID;
	BO_set_sec_list(reclaim_sec, sec_info);
	BO_write_sec_info(reclaim_sec, &sec_info);
	BO_set_header_sec(reclaim_sec);