db_fmgr.c

DVB软件,基于CT216软件的开发源程序.

#include <stdio.h>
#include <string.h>

#include "db_defs.h"
#include "dvb_type.h"

#include "db_dram.h"
#include "dvb_flash.h"
#include "dvb_msg.h"
/*******************************************************************************************/
#if 1
#define FMGR_MSG(p)
#else
#define FMGR_MSG(p)			printf p
#endif

#if 1
#define FMGR_DBG(p)
#else
#define FMGR_DBG(p) 		printf p
#endif

/*******************************************************************************************/       
#define BANK_DEL_FLAG	    0x80

static u8		au8BMT				[DB_TOTAL_BANK_ID];
static bool8	ab8BankDeletedFlag	[DB_TOTAL_BANK_ID];
static u8		au8HitRate			[DB_TOTAL_BANK_ID];

static u8 u8idx, u8temp;

static u8 u8CacheCandidate;
static u8 u8CachedBank;

#ifndef FLASH_BYTE_MODE
static u16 u16temp, u16mask;
#endif
/*******************************************************************************************/       

bool8 _flash_write_byte(u8 u8bank, u16 u16address, u8 u8data)
{
	return DVB_FlashWrite(u8bank, u16address, &u8data, 1);
}
/*******************************************************************************************/       

u8 _flash_read_byte(u8 u8bank, u16 u16address)
{
	u8 u8temp;

	DVB_FlashRead( u8bank, u16address, &u8temp, 1);
	return u8temp;
}
/*******************************************************************************************/       

bool8 _flash_write_word(u8 u8bank, u16 u16address, u16 u16data)
{
	return DVB_FlashWrite(u8bank, u16address, (u8*)&u16data, 2);
}
/*******************************************************************************************/       

u16 _flash_read_word(u8 u8bank, u16 u16address)
{
	u16 u16temp;

	DVB_FlashRead( u8bank, u16address, (u8*)&u16temp, 2);
	return u16temp;
}
/*******************************************************************************************/       

bool8 _flash_write_dw(u8 u8bank, u16 u16address, u32 u32data)
{
	return DVB_FlashWrite(u8bank, u16address, (u8*)&u32data, 4);
}
/*******************************************************************************************/       

u32 _flash_read_dw(u8 u8bank, u16 u16address)
{
	u32 u32temp;

	DVB_FlashRead( u8bank, u16address, (u8*)&u32temp, 4);
	return u32temp;
}
/*******************************************************************************************/       

void _cache_init(void)
{
    u8CacheCandidate = 0xff;
    u8CachedBank = 0xff;
    
	for( u8idx=0; u8idx<DB_TOTAL_BANK_ID; u8idx++ )
	{
		au8HitRate[u8idx]=0;
	}
	return;
}
/*******************************************************************************************/       

void _cache_bank(u8 u8bank_id)
{
	if(u8bank_id==u8CachedBank)
	{
		return;
	}
    FMGR_DBG(("cache bank id %02x\n", u8bank_id));
    
	if( ab8BankDeletedFlag[u8bank_id]==TRUE )
	{
		DVB_DramSet( DB_CACHE_DRAM_START, 0xff, 0x10000);
	}	
	else
	{
		DVB_FlashReadBank(au8BMT[u8bank_id]+u8DVB_DBStartBank, DB_CACHE_DRAM_START);
	}
	u8CachedBank = u8bank_id;
}
/*******************************************************************************************/       

void _cache_statistic(u8 u8bank_id)
{
	au8HitRate[u8bank_id]++;

	if(au8HitRate[u8bank_id] > DB_CACHE_THESHOLD)
	{
		for( u8idx=0; u8idx<DB_TOTAL_BANK_ID; u8idx++ )
		{
			au8HitRate[u8idx]=0;
		}
		// check more condition to prevent cache swap frequently
		if(	u8bank_id==u8CacheCandidate ||
			(u8CachedBank!=u8bank_id && u8CachedBank!=u8CacheCandidate) )
		{
			_cache_bank(u8bank_id);
		}
		else
		{
			u8CacheCandidate = u8bank_id;
		}

	}
}
/*******************************************************************************************/       

/*
void _clean_bank_del_flag(u8 u8bank_id)
{
	ab8BankDeletedFlag[u8bank_id] = FALSE;
}
*/
void _set_bank_flag(u8 u8bank_id, u8 u8mask)
{
#ifdef FLASH_BYTE_MODE
	ab8BankDeletedFlag[u8bank_id] = TRUE;
	u8temp = _flash_read_byte(au8BMT[u8bank_id]+u8DVB_DBStartBank, BANK_STATUS_ADDRESS);
	u8temp = u8temp&(~u8mask);
	_flash_write_byte(au8BMT[u8bank_id]+u8DVB_DBStartBank, BANK_STATUS_ADDRESS, u8temp);
#else
    u16mask = (u16)u8mask;
	ab8BankDeletedFlag[u8bank_id] = TRUE;
	u16temp = _flash_read_word(au8BMT[u8bank_id]+u8DVB_DBStartBank, BANK_STATUS_ADDRESS);
	u16temp = u16temp&(~(u16mask<<8) );
	_flash_write_word(au8BMT[u8bank_id]+u8DVB_DBStartBank, BANK_STATUS_ADDRESS, u16temp);
#endif
}
/*******************************************************************************************/       

bool8 _get_bank_flag(u8 u8bank_id, u8 u8mask)
{
#ifdef FLASH_BYTE_MODE
	u8temp = _flash_read_byte(au8BMT[u8bank_id]+u8DVB_DBStartBank, BANK_STATUS_ADDRESS);
	if(u8temp&u8mask)
	{
		return FALSE;
	}	
	else
	{
		return TRUE;
	}	
#else
    u16mask = (u16)u8mask;
	u16temp = _flash_read_word(au8BMT[u8bank_id]+u8DVB_DBStartBank, BANK_STATUS_ADDRESS);
	if(u16temp& (u16mask<<8))
	{
		return FALSE;
	}	
	else
	{
		return TRUE;
	}	
#endif
}
/*******************************************************************************************/       

u8 _read_bank_id(u8 u8bank)
{
#ifdef FLASH_BYTE_MODE
    return _flash_read_byte(u8bank, BANK_ID_ADDRESS);
#else
    u16temp = _flash_read_word(u8bank, BANK_STATUS_ADDRESS);
    u8temp = (u8)(u16temp&0x00ff);
    return u8temp;
#endif
}
/*******************************************************************************************/       

void _write_bank_id(u8 u8bank, u8 u8bank_id)
{
#ifdef FLASH_BYTE_MODE
    _flash_write_byte(u8bank, BANK_ID_ADDRESS, u8bank_id);
#else
    u16temp = _flash_read_word(u8bank, BANK_STATUS_ADDRESS);
    u16temp = (u16temp&0xff00)+u8bank_id;
    _flash_write_word(u8bank, BANK_STATUS_ADDRESS, u16temp);
#endif
}
/*******************************************************************************************/       

bool8 _check_integrity(u8 u8bank)
{
    // check magic number and version
    if( BANK_MAGIC != _flash_read_dw(u8bank, BANK_MAGIC_ADDRESS) )
    {
		return FALSE;
    }
    if( DB_VERSION != _flash_read_word(u8bank, BANK_VERSION_ADDRESS) )
    {
		return FALSE;
    }
	if( _read_bank_id(u8bank) >= DB_TOTAL_BANK_ID)
	{
		return FALSE;
	}
	return TRUE;
}
/*******************************************************************************************/       

void _format_flash(u8 u8bank, u8 u8bank_id)
{
    FMGR_DBG(("format bank id %02x...\n", u8bank_id));

	ab8BankDeletedFlag[u8bank_id] = FALSE;

	if(u8bank_id==0)
	{
		_write_bank_id(u8bank, 0);
	}
	else
	{
	    DVB_FlashErase( u8bank );

	    _flash_write_dw(u8bank, BANK_MAGIC_ADDRESS, BANK_MAGIC);
		_flash_write_word(u8bank, BANK_VERSION_ADDRESS, DB_VERSION);
		_write_bank_id(u8bank, u8bank_id);
	}
}
/*******************************************************************************************/       

bool8 FMgr_CheckAvailable(u8 u8bank_id)
{
//	if( _check_integrity( au8BMT[u8bank_id]+u8DVB_DBStartBank )==TRUE )
	if( ab8BankDeletedFlag[u8bank_id]==FALSE )
	{
		return TRUE;
	}
    return FALSE;
}
/*******************************************************************************************/       

/*
void FMgr_Format(u8 u8bank_id)
{
#if (DB_BACKUP_BANK==1)
	//swap physical bank of u8bank_id and backup bank(0)
	u8temp = au8BMT[u8bank_id];
	au8BMT[u8bank_id] = au8BMT[0];
	au8BMT[0] = u8temp;

    _format_flash( au8BMT[u8bank_id]+u8DVB_DBStartBank, u8bank_id );

	_write_bank_id(au8BMT[0]+u8DVB_DBStartBank, 0);
#else
    _format_flash( au8BMT[u8bank_id]+u8DVB_DBStartBank, u8bank_id );
#endif
	// set dram image
}
*/
/*******************************************************************************************/       

bool8 FMgr_Init(void)
{
	bool8 b8FlashIntegrity=TRUE;

	// build BMT, check bank integrity
    for(u8idx=0; u8idx<DB_TOTAL_BANK_ID; u8idx++)	// for each bank_id
    {
        au8BMT[u8idx] = 0xff;
    }
    
    for(u8idx=0; u8idx<DB_TOTAL_BANK; u8idx++)	// for each bank
    {
        FMGR_DBG(("check bank %02x integrity...", u8idx+u8DVB_DBStartBank));
        if( _check_integrity(u8idx+u8DVB_DBStartBank)==TRUE )
        {
            au8BMT[ _read_bank_id(u8idx+u8DVB_DBStartBank) ] = u8idx;
            FMGR_DBG(("ok\n"));
        }
        else
        {
            FMGR_DBG(("fail\n"));
        }
    }
    
    for(u8idx=1; u8idx<DB_TOTAL_BANK_ID; u8idx++)	// for each bank_id
    {
        if( au8BMT[u8idx]==0xff )
        {
            // format all
            for(u8idx=DB_START_BANK_ID; u8idx<DB_TOTAL_BANK_ID; u8idx++)	// for each bank_id
            {
                au8BMT[u8idx] = u8idx-DB_START_BANK_ID;
                _format_flash(au8BMT[u8idx]+u8DVB_DBStartBank, u8idx);
            }
			b8FlashIntegrity = FALSE;
            break;
        }
    }
    
#if (DB_BACKUP_BANK==1)
    if( au8BMT[0]==0xff)
    {
        for(u8idx=0; u8idx<DB_TOTAL_BANK; u8idx++)	// for each bank
		{
			for(u8temp=1; u8temp<DB_TOTAL_BANK_ID; u8temp++)	// check which bank_id uses it
			{
				if( au8BMT[u8temp]==u8idx )
				{
					break;
				}	
			}

			if(u8temp==DB_TOTAL_BANK_ID)
			{
				au8BMT[0]=u8idx;
//				_format_flash(au8BMT[0]+u8DVB_DBStartBank, 0);
				break;
			}
		}
    }
#endif

	for(u8idx=DB_START_BANK_ID; u8idx<DB_TOTAL_BANK_ID; u8idx++)	// for each bank_id
	{
		ab8BankDeletedFlag[u8idx] = _get_bank_flag(u8idx, BANK_DEL_FLAG);
        FMGR_DBG(("BMT[%02x]=%02x, del=%02x\n", u8idx, au8BMT[u8idx], ab8BankDeletedFlag[u8idx]));
	}

	// build dram image
#if (DB_DRAM_IMAGE==0)
	_cache_init();
//	_cache_bank(1);
#else
	for( u8idx=1; u8idx<DB_TOTAL_BANK_ID; u8idx++ )
	{
		if( ab8BankDeletedFlag[u8idx]==TRUE )
		{
			DVB_DramSet( DB_CACHE_DRAM_START+(u8idx-1)*0x10000, 0xff, 0x10000);
		}
		else
		{
			DVB_FlashReadBank(au8BMT[u8idx]+u8DVB_DBStartBank, DB_CACHE_DRAM_START+(0x10000*(u8idx-1)) );
		}
	}
#endif

	return b8FlashIntegrity;
}
/*******************************************************************************************/       

void FMgr_DeleteAll(void)
{
    for(u8idx=1; u8idx<DB_TOTAL_BANK_ID; u8idx++)
    {
        _set_bank_flag(u8idx, BANK_DEL_FLAG);
    }

    FMgr_Init();
}
/*******************************************************************************************/       

void FMgr_Write(u8 u8bank_id, u16 u16address, u8* pu8buffer, u16 u16buffer_size)
{
	if(u8bank_id==0)
	{
		return;
	}
#if (DB_DRAM_IMAGE==0)
	if(u8CachedBank==u8bank_id)
	{
		DVB_DramWrite(DB_CACHE_DRAM_START+u16address, pu8buffer, u16buffer_size);
	}
#else
	DVB_DramWrite(DB_CACHE_DRAM_START+(u8bank_id-1)*0x10000+u16address, pu8buffer, u16buffer_size);
#endif
	DVB_FlashWrite(au8BMT[u8bank_id]+u8DVB_DBStartBank, u16address, pu8buffer, u16buffer_size);
}
/*******************************************************************************************/       

void FMgr_Read(u8 u8bank_id, u16 u16address, u8* pu8buffer, u16 u16buffer_size)
{
	if(u8bank_id==0)
	{
		return;
	}	
	if( ab8BankDeletedFlag[u8bank_id]==TRUE )
	{
		memset(pu8buffer, 0xff, u16buffer_size);
		return ;
	}

#if (DB_DRAM_IMAGE==0)
	_cache_statistic(u8bank_id);

	if(u8CachedBank==u8bank_id)
	{
		DVB_DramRead(DB_CACHE_DRAM_START+u16address, pu8buffer, u16buffer_size);
	}	
	else
	{
		DVB_FlashRead(au8BMT[u8bank_id]+u8DVB_DBStartBank, u16address, pu8buffer, u16buffer_size);
	}	
#else
	DVB_DramRead(DB_CACHE_DRAM_START+(u8bank_id-1)*0x10000+u16address, pu8buffer, u16buffer_size);
#endif
}
/*******************************************************************************************/       

void FMgr_WriteBank(u8 u8bank_id)
{
	if(u8bank_id==0)
	{
		return;
	}
	FMGR_DBG(("write bank id %02x...\n", u8bank_id));
	ab8BankDeletedFlag[u8bank_id] = FALSE;

#if (DB_BACKUP_BANK==1)
	//swap physical bank of u8bank_id and backup bank(0)
	u8temp = au8BMT[u8bank_id];
	au8BMT[u8bank_id] = au8BMT[0];
	au8BMT[0] = u8temp;
#endif

#if (DB_DRAM_IMAGE==0)
	DVB_FlashWriteBank(au8BMT[u8bank_id]+u8DVB_DBStartBank, 
		DB_CACHE_DRAM_START);
#else
	DVB_FlashWriteBank(au8BMT[u8bank_id]+u8DVB_DBStartBank, 
		DB_CACHE_DRAM_START+(u8bank_id-1)*0x10000);
#endif

	_flash_write_dw(au8BMT[u8bank_id]+u8DVB_DBStartBank, BANK_MAGIC_ADDRESS, BANK_MAGIC);
	_flash_write_word(au8BMT[u8bank_id]+u8DVB_DBStartBank, BANK_VERSION_ADDRESS, DB_VERSION);
	_write_bank_id(au8BMT[u8bank_id]+u8DVB_DBStartBank, u8bank_id);

#if (DB_BACKUP_BANK==1)
	_write_bank_id(au8BMT[0]+u8DVB_DBStartBank, 0);
#endif

}
/*******************************************************************************************/       

void FMgr_ReadBank(u8 u8bank_id)
{
	if(u8bank_id==0)
	{
		return;
	}
	
#if (DB_DRAM_IMAGE==0)
	_cache_bank(u8bank_id);
#else
	if( ab8BankDeletedFlag[u8bank_id]==TRUE )
	{
		DVB_DramSet( DB_CACHE_DRAM_START+(u8bank_id-1)*0x10000, 0xff, 0x10000);
	}	
	else
	{
		DVB_FlashReadBank(au8BMT[u8bank_id]+u8DVB_DBStartBank, DB_CACHE_DRAM_START+(u8bank_id-1)*0x10000);
	}	
#endif
}
/*******************************************************************************************/       

u16 FMgr_Search(u8 u8bank_id, u16 u16address, u8 u8item_size, u16 u16item_num, u32 u32mask, u32 u32mach)
{
	if(u8bank_id==0)
	{
		return u16item_num;
	}	
	if( ab8BankDeletedFlag[u8bank_id]==TRUE )
	{
		return u16item_num;
	}
#if (DB_DRAM_IMAGE==0)
	_cache_bank(u8bank_id);
	return DVB_DramSearch(DB_CACHE_DRAM_START+u16address, u8item_size, u16item_num, u32mask, u32mach, TRUE);
#else
	return DVB_DramSearch(DB_CACHE_DRAM_START+(u8bank_id-1)*0x10000+u16address, u8item_size, u16item_num, u32mask, u32mach, TRUE);
#endif
}
/*******************************************************************************************/