/*******************************************************************
 * DMW_ChannelDB.c
 *
 * Interface code to middle ware for DST Module/STB channel DB management
 *   especially about NVRAM.
 *
 * some of DMW_CDB_XXX APIs are implemented in this module.
 *
 * Copyright 2003 Digital STREAM Technology, Inc.
 * All Rights Reserved
 *
 * $Id: DMW_ChannelDB.c,v 1.31  2004 cafrii Exp $
 *
 ********************************************************************/





#include "DMW_Platform.h"

#include "DHL_OSAL.h"
#include "DHL_DBG.h"

#include "DMW_Config.h"

#include "DMW_ChannelAPI.h"
#include "DMW_DebugUtil.h"
#include "dmw_ucm_priv.h"
#include "dmw_nvram_priv.h"

#if !USE_INCLUDED_CRC_CODE
#include "DHL_UTL.h"
#endif

//#include <string.h>
//#include <string.h>


DHL_MODULE("$cdb", 0);


//---------------------------------------------------------
// Configurations..


#undef STATIC
#if 1
	#define STATIC         // for test debugging..
#else
	#define STATIC static  // for release code..
#endif






//---------------------------------------------------------




#if COMMENT
_______Util______(){}
#endif



STATIC UINT32 _m2d(UINT8 *p, int bytesize)  // memory to digit
{
	UINT32 result = 0;
	int i;

	if (bytesize > 4) bytesize = 4;

	for (i=0; i<bytesize; i++)
		result = (result<<8) | p[i];
	
	return result;
}

STATIC STATUS _d2m(UINT8 *p, int bytesize, UINT32 data)  // digit to memory
{
	int i;

	if (bytesize > 4) bytesize = 4; // 'data' is only 4 byte-sized variable at maximum.

	for (i=0; i<bytesize; i++) {
		
		p[bytesize-1-i] = (data & 0xff);  // fill BYTE from rear to front..
		data >>= 8;
	}
	return statusOK;	
}





#if COMMENT
_______CRC______(){}
#endif

#if USE_INCLUDED_CRC_CODE

static UINT32 crc_table[256];

#define DEMUX_CRC_ADDER_MASK 0x04C11DB7

void nvr_init_crc_table()
{
	int i, j;
	UINT32 crc;
	// Initialize CRC table 
	for (i=0; i<256; i++) {
		crc = 0;
		for (j=7; j>=0; j--) {
			if (((i >> j) ^ (crc >> 31)) & 1) {
				crc=(crc<<1)^DEMUX_CRC_ADDER_MASK;
			}
			else {
				crc<<=1;
			}
		}
		crc_table[i] = crc;
	}
}

// cafrii 041109 add
// crc32 를 계산한다.
// 
UINT32 nvr_calc_crc32(UINT32 crc_start, const UINT8 *data, UINT32 len)
{
	UINT32 crc = crc_start; // 0xFFFFFFFF;
	UINT32 i;

	if (crc_table[1] == 0) { // 아직 초기화가 안된 모양이다.
		dprint(2, "..initializing crc table..\n");
		nvr_init_crc_table();
	}

	for (i = 0; i < len; ++i) {
		crc = (crc << 8) ^ crc_table[(crc >> 24) ^ (*data++)];
	}
	return(crc);
}

#else
UINT32 nvr_calc_crc32(UINT32 crc_start, const UINT8 *data, UINT32 len)
{
	return DHL_UTL_CalcCRC32(crc_start, data, len);
}

#endif


#if COMMENT
_______Level_1_______(){}
#endif

STATIC BOOL nvr_is_safe_area(UINT32 offset, UINT32 size)
{
	// NvRAM에 접근하기 전에 이 영역 (offset, size)이 사용가능한 영역인지 체크.
	
	if (offset & 0x80000000)  // device 1. Flash
	{
#if SUPPORT_DMW_FLASH_DB
		// cafrii, 031201 add more check code
		offset &= 0x7fffffff;

		if (offset + size > (UINT32)NvRamGetAvailableSize(1))
			return FALSE;  // over the maximum.

		return TRUE; // cafrii 031112
#else
		return FALSE;
#endif
	}
	else  // device 0. EEPROM.
	{
#if SUPPORT_DMW_EEPROM
		if (offset + size > (UINT32)NvRamGetAvailableSize(0))
			return FALSE;
		else 
			return TRUE;  // safe!! this range is allowed to use.
#else
		return FALSE;
#endif
	}
}


// Level 1 public API.
//   NvRam I/O.
//  


UINT32 DMW_CDB_GetNvRamAvailableSize(int device)
{
	// 해당 NvRAM device의 사용가능한 영역 크기를 리턴.
	//

	if (device == 0)  // EEPROM
		return NvRamGetAvailableSize(0);
	else
		return NvRamGetAvailableSize(1);
}


// cafrii 031201, add one more arguments,
// and save directory number information in NVPARAM area.
//
STATUS DMW_CDB_LowLevelFormatNvRam(void)
{
	int err = statusOK;
	
	// CAUTION!
	//  이 함수는 일반 application 프로그램을 위한 것이 아니고,
	//  양산용 프로그램 또는 검사/수리용 테스트 프로그램을 위한 것임.
	//  제품 생산시 최초 Blank EEPROM 상태에서는 1회 실시 필요함.
	//
	// cafrii 070424 add comment
	//  부팅 중에 NvRam 영역에 문제가 있다고 판단되면 
	//  application 코드에서 format을 할 수 있음.
	

#if SUPPORT_DMW_FLASH_DB
	err = NvRamFormat(); // cafrii 031112
	if (err) return (STATUS)err;
#endif
	
	return statusOK;
}


/*
	DMW_CDB_CheckNvRam:

	NvRam이 제대로 format이 되었는지, 사용 가능한지 체크한다.

*/
STATUS DMW_CDB_CheckNvRam(void)
{
	return NvRamCheckValid();
}

/*
	DMW_CDB_ReadNvRam:

	NvRam 영역을 읽는다.
*/
STATUS DMW_CDB_ReadNvRam(UINT32 address, UINT32 size, UINT8 *buf)
{
	if (!nvr_is_safe_area(address, size))
		return statusNvRamBadAddress;
		
	return NvRamRead(address, size, buf);
}

/*
	DMW_CDB_WriteNvRam:

	NvRam 영역에 데이터를 기록한다.
*/
STATUS DMW_CDB_WriteNvRam(UINT32 address, UINT32 size, UINT8 *buf)
{
	if (!nvr_is_safe_area(address, size))
		return statusNvRamBadAddress;

	return NvRamWrite(address, size, buf);
}


//----------------------------------------------------------
// EEPROM test 함수들..
//

STATUS DMW_CDB_DumpNvRam(UINT32 start, int size, char *name)
{
	int err;
	UINT8 *buf;
	
	if (size <= 0 || size > 16384) {
		return statusOutOfRange;
	}
	
	buf = DHL_OS_Malloc(size);
	if (buf == NULL) {
		return statusOutOfResource;
	}
	
	DHL_OS_Printf("  NvRam (%x~%x): '%s'\n", start, start+size, name ? name : "");
	
	err = DMW_CDB_ReadNvRam(start, size, (UINT8 *)buf);
	
	if (!err) {	
		memdump2(buf, size, "NvRam", (UINT32)start-(UINT32)buf);
	}
	
	DHL_OS_Free((void**)&buf);
	
	return statusOK;
}


STATUS DMW_CDB_InitNvRam(void)
{
	NvRamInit();

	dprint(0, "Config:EEPROM size %d\n", NvRamGetAvailableSize(0));
	
	return statusOK;
}



//******************************************************************
//
//  Read/Write Channel DB
//
//  NVRAM access API.



#if COMMENT
_______Level_3_______(){}
#endif

STATIC UINT16 g_epgIndex;

UINT16 nvr_generate_epg_index(UINT32 arg)
{
	return ++g_epgIndex;
}

void nvr_reset_epg_index()
{
	g_epgIndex = 0;
}

/*
	Unicode (16bit) string의 길이를 계산.
	String은 Null 문자로 종료되거나 또는 maxlen 에 의해서 종료됨.
	maxlen이 -1일 경우 최대 길이 제한 없음. 오직 Null 종료만 됨.
	
	뒷 부분의 공백문자는 길이에 포함하지 않도록 한다. (todo)
*/
int nvr_uc16len(UINT16 *str, int maxlen)
{
	UINT16 *p = str;
	if (!p) return 0;
	while (*p && p<str+maxlen) p++;
	
	return (int)(p-str);
}


const UINT8 gUcmStoringVersion = 0xA8;  
//
// UCM의 구조가 바뀌면 이 버전을 올려서 꼭 다시 포맷을 할 수 있도록
// 알려줄 수 있어야 한다.
// 기존에 저장된 값 (NVPARAM 영역에 저장되어 있음) 과 다르면 
// DMW_CDB_CheckNvRam 에서 에러가 발생할 것이다.

/********************************************************************************
NvRam UCM version history
Note: this storing UCM format has its own format version.
      the version will be incremented whenever storing UCM format is changed.
      this version info can be found in 'ForbiddenArea' in NvRam.

	A8 : cafrii 100427
		First 32 byte structure is same as A7.
		Next and next-next 32 byte block is as follows.
		
		  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F  
		+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
		| Ext |    Long Channel Name                    |
		+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
		|    Long Channel Name                          |
		+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

		Ext(16): 0xFEFE
		Long Channel Name (16*15): extended channel name, Unicode 16, 15 characters.
		If long channel name extension is not used, this block does not exist at all.

		UCM Storing Version (USV) is stored in UCM Header area.
		UCM Header Area structure is also changed.

	A7 : cafrii 041130, scrambled flag added	     
	
		Flag byte : Unused(1), Sc(1), Hd(1), Bk(1), Vf(1), St(2), Sk(1)
		
			Sc(1) : Scrambled channel  // cafrii 041130 add
			Hd(1) : Hidden channel
			Bk(1) : Blocked channel
			Vf(1) : VctFlag
			St(2) : ServiceType
			Sk(1) : Skipped Channel
	     
	A6 : cafrii 041129 
	     New CSD structure is newly defined. refer 'ChannelCSD.c'

	A5 : cafrii 041109 add
		 UCM[0] is not stored at the first position of DB start address.
	     there are reserved space for management

		
	A4 : PID info will not be stored
	     source ID and frq offset will be stored

        0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F  
      +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
       Mj -- Mn -- Rf Fl N0 -- N1 -- N2 -- N3 -- N4 --  
      +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
       N5 -- N6 -- Freq_offset Sr -- Pn -- Si -- Ei --
	
	A3 : Hidden channel flag added // cafrii 040114
		Flag byte : Unused(2), Hd(1), Bk(1), Vf(1), St(2), Sk(1)
		
			Hd(1) : Hidden channel   // cafrii 040114 add
			Bk(1) : Blocked channel
			Vf(1) : VctFlag
			St(2) : ServiceType
			Sk(1) : Skipped Channel
	
	A2 : Blocked channel flag added
		Flag byte : Unused(3), Bk(1), Vf(1), St(2), Sk(1)
		
			Bk(1) : Blocked channel  // cafrii 031205 add
			Vf(1) : VctFlag
			St(2) : ServiceType
			Sk(1) : Skipped Channel
		
	A1 : EpgIndex added. 
	      vctFlag info is overlapped on Major. vctFlag = (Major != 0)
	      Flags field inserted before ShortName. this include skip_flag, service_type info.
	      Skip_flag, Service_type is moved into Flag.
  	                                                   
        0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F  
      +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
       Mj -- Mn -- Rf Fl N0 -- N1 -- N2 -- N3 -- N4 --  
      +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
       N5 -- N6 -- Pp -- Vp -- Ap -- Pn -- Si -- Ei --
	
	A0 : X-ray version
        0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15  
      +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
       Mj -- Mn -- Rf N0 -- N1 -- N2 -- N3 -- N4 -- N5
      +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
       -- N6 -- Pp -- Vp -- Ap -- Pn -- St Sk Si -- 
*/




// relative offset based on start of each channel DB element.
//
#define OFFSET_Major         0x0
#define OFFSET_Minor         0x2
#define OFFSET_RF            0x4
#define OFFSET_Flag          0x5  // newly inserted in ver A1
#define OFFSET_ShortName     0x6
//#define OFFSET_PcrPid        0x14
//#define OFFSET_VideoPid      0x16
//#define OFFSET_AudioPid      0x18
#define OFFSET_FreqOffset    0x14
#define OFFSET_SourceId      0x18
#define OFFSET_ProgNumber    0x1A
#define OFFSET_SurfIndex     0x1C
#define OFFSET_VideoFormat   0x1D //neverdai add 101019 for saving video resolution
#define OFFSET_EpgIndex      0x1E

#define SIZEOF_UCM_DB_ITEM 0x20   // byte size of one UCM DB item in NvRAM

// byte size of each channel DB element.
//
#define SIZE_Major         2
#define SIZE_Minor         2
#define SIZE_RF            1
#define SIZE_Flag          1
#define SIZE_ShortName     14
#define SIZE_FreqOffset    4
#define SIZE_SourceId      2
//#define SIZE_PcrPid        2
//#define SIZE_VideoPid      2
//#define SIZE_AudioPid      2

#define SIZE_ProgNumber    2
#define SIZE_SurfIndex     1//2
#define SIZE_VideoFormat   1
#define SIZE_EpgIndex      2

// added in ver A8 
#define OFFSET_Ext1      0x20
#define OFFSET_LongName1 0x22
#define OFFSET_Ext2      0x40
#define OFFSET_LongName2 0x42
#define SIZE_Ext       2
#define SIZE_LongName  30
#define UCM_EXT_MARKER 0xFEFE


// cafrii 040114 add
#define UCM_FLAG_SCRAMBLED  0x40
#define UCM_FLAG_HIDDEN     0x20
#define UCM_FLAG_BLOCKED    0x10
#define UCM_FLAG_VCT        0x08
#define UCM_FLAG_SKIPPED    0x01


UINT32 DMW_CDB_GetUcmItemStoringSize()
{
	// sizeof(UCM_DB_T)와 SIZEOF_UCM_DB_ITEM는 다를 수 있다.
	// application에서 NvRAM에 들어갈 DB 크기 계산을 할 때에는
	// 이 정보를 사용하여야 한다.
	//
	// UCM은 메모리에 있는 상태 그대로 write하지 않는다는 점에 유의한다.
	//
	return SIZEOF_UCM_DB_ITEM;
}


//******************************************************************
//
//  Miscellaneous APIs which query/update individual DB element





/*
	Read one UCM DB element
	
	NVM에서 읽어 낸 flattened UCM 정보를 parsing 하여 UCM_DB_T로 변환.
	NVM UCM의 크기는 EXT Marker 정보에 따라 가변이다. 
	실제로 parsing 된 UCM의 byte size를 리턴한다. 
	caller는 이 정보를 이용하여 다음 NVM UCM offset을 알 수 있다.
*/
int DMW_CDB_ParseOneUcmBlockMode(UINT8 *p, UCM_DB_T *buf, UINT16 *pEpgIndex)
{
	UINT8 flag;
	int this_nvm_ucm_size;

	memset(buf, 0, UcmItemMemorySize()); // cafrii, 030317
	
	buf->Major = _m2d (p + OFFSET_Major, SIZE_Major);
	buf->Minor = _m2d (p + OFFSET_Minor, SIZE_Minor);
	buf->RF    = _m2d (p + OFFSET_RF, SIZE_RF);

	memcpy((UINT8 *)buf->ShortName, p + OFFSET_ShortName, SIZE_ShortName);
	
	buf->freqOffset = _m2d (p + OFFSET_FreqOffset, SIZE_FreqOffset);
	buf->source_id  = _m2d (p + OFFSET_SourceId, SIZE_SourceId);

	buf->Prog_number  = _m2d (p + OFFSET_ProgNumber, SIZE_ProgNumber);
	
	// Fl: Hd(1), Bl(1), Vf(1), St(2), Sk(1)
	flag = _m2d (p + OFFSET_Flag, SIZE_Flag);
	
	buf->scrambled = (flag & UCM_FLAG_SCRAMBLED) ? TRUE : FALSE; // cafrii 041130 add
	buf->hidden = (flag & UCM_FLAG_HIDDEN) ? TRUE : FALSE; // cafrii 040114 add
	buf->blocked = (flag >> 4) & 1;    // cafrii 031205
	buf->VctFlag = (flag >> 3) & 1;
	buf->Service_type = (flag >> 1) & 3;
	buf->Skipped = (flag) & 1;
	
	buf->SurfIndex    = _m2d (p + OFFSET_SurfIndex, SIZE_SurfIndex);
		//neverdai 주의...surf index는 1byte만 기록함..
		//video resolution을 기록할 장소가 없음..surf를 많이 사용하지 않거나
		//surf index가 굳이 필요 없는 경우만 가능
	
	buf->video_format = (tDHL_DispFormat)_m2d (p + OFFSET_VideoFormat, SIZE_VideoFormat);
		//neverdai add 101019 video format 저장을 위함.
	
	// cafrii, 030310
	buf->pEpgDB = NULL;
	if (pEpgIndex)
		*pEpgIndex = _m2d (p + OFFSET_EpgIndex, SIZE_EpgIndex);
		
	buf->Uid = make_new_ucm_uid_counter(); // cafrii, 030317
	
	// cafrii 060630 add
	// 1의 의미는 아직 이 pid 정보를 획득하지 못해서 알 수 없는 상태임을 의미한다.
	// 0의 의미는 해당 elementary stream이 존재하지 않는다는 의미이다.
	//   ex: audio only program의 경우 Video_pid = 0..
	//
	buf->Pcr_pid = DMW_PID_NO_INFO;
	buf->Video_pid = DMW_PID_NO_INFO;
	buf->Audio_pid = DMW_PID_NO_INFO;
	buf->pmt_pid = DMW_PID_NO_INFO;
	
	

	if (_m2d (p + OFFSET_Ext1, SIZE_Ext) != UCM_EXT_MARKER) {
		this_nvm_ucm_size = SIZEOF_UCM_DB_ITEM;
	}
	else if (_m2d (p + OFFSET_Ext2, SIZE_Ext) != UCM_EXT_MARKER) {
		this_nvm_ucm_size = 2*SIZEOF_UCM_DB_ITEM;
		memcpy((UINT8 *)buf->LongName, p + OFFSET_LongName1, SIZE_LongName);
		buf->LongName[SIZE_LongName/2] = 0; // null terminate
	}
	else if (1) {
		this_nvm_ucm_size = 3*SIZEOF_UCM_DB_ITEM;
		memcpy((UINT8 *)(&buf->LongName[SIZE_LongName/2]), p + OFFSET_LongName2, SIZE_LongName);
		//buf->LongName[SIZE_LongName] = 0; // it cannot be null terminated. no space for nullz.
	}

	return this_nvm_ucm_size;

}

/*
	Write one UCM DB element
	메모리 상의 UCM entry 하나를 flatten 시킨다.
	
	UCM의 LongName에 따라서 flatten 되는 길이는 달라질 수 있다.
*/
int DMW_CDB_PrepareOneUcmBlockMode(UINT8 *p, UCM_DB_T *buf, UINT16 *pEpgIndex)
{
	UINT16 epgIndex;
	UINT8 flag;
	int len_ch_name = nvr_uc16len(buf->LongName, sizeof(buf->LongName)/sizeof(buf->LongName[0]));
	int nvm_size_of_this_ucm;
	
	// p is memory pointer.
	_d2m(p + OFFSET_Major, SIZE_Major, buf->Major);
	_d2m(p + OFFSET_Minor, SIZE_Minor, buf->Minor);
	_d2m(p + OFFSET_RF, SIZE_RF, buf->RF);

	memcpy(p + OFFSET_ShortName, (UINT8 *)buf->ShortName, SIZE_ShortName);

	_d2m(p + OFFSET_FreqOffset,  SIZE_FreqOffset,  buf->freqOffset);// cafrii 040812 bugfix from buf->source_id
	_d2m(p + OFFSET_SourceId,    SIZE_SourceId,    buf->source_id);

	_d2m(p + OFFSET_ProgNumber,  SIZE_ProgNumber,  buf->Prog_number);
	
	flag = (buf->Skipped) & 1;
	flag |= ((buf->Service_type) & 3) << 1;
	flag |= ((buf->VctFlag) & 1) << 3;
	flag |= ((buf->blocked ? 1 : 0) << 4);  // cafrii 031205 add
	flag |= (buf->hidden ? UCM_FLAG_HIDDEN : 0); // cafrii 040114 add
	flag |= (buf->scrambled ? UCM_FLAG_SCRAMBLED : 0); // cafrii 041130 add
	
	_d2m(p + OFFSET_Flag,      SIZE_Flag,      flag);
	
	_d2m(p + OFFSET_SurfIndex, SIZE_SurfIndex, buf->SurfIndex);
	
	_d2m(p + OFFSET_VideoFormat, SIZE_VideoFormat, buf->video_format);
	
	// cafrii, 030310
	epgIndex = nvr_generate_epg_index((UINT32)buf->pEpgDB);
	_d2m(p + OFFSET_EpgIndex, SIZE_EpgIndex, epgIndex);
	if (pEpgIndex)
		*pEpgIndex = epgIndex;

	// LongName 의 길이에 따라서 저장 UCM의 크기가 달라진다.
	// LongName 길이가 0 이면 LongName slot은 필요 없고,
	// LongName 길이가 1~15 이면 하나의 32-byte slot이 추가 필요하고,
	// LongName 길이가 16~30 이면, 두개의 32-byte slot이 추가 필요하다.
	
	
	if (len_ch_name == 0) {
		nvm_size_of_this_ucm = SIZEOF_UCM_DB_ITEM;
		// do nothing
	}
	else if (len_ch_name <= 15) {
		nvm_size_of_this_ucm = 2*SIZEOF_UCM_DB_ITEM;
		_d2m(p + OFFSET_Ext1, SIZE_Ext, UCM_EXT_MARKER);
		memcpy(p + OFFSET_LongName1, (UINT8 *)buf->LongName, SIZE_LongName);
	}
	else {
		nvm_size_of_this_ucm = 3*SIZEOF_UCM_DB_ITEM;
		_d2m(p + OFFSET_Ext1, SIZE_Ext, UCM_EXT_MARKER);
		memcpy(p + OFFSET_LongName1, (UINT8 *)buf->LongName, SIZE_LongName);
		_d2m(p + OFFSET_Ext2, SIZE_Ext, UCM_EXT_MARKER);
		memcpy(p + OFFSET_LongName2, ((UINT8 *)buf->LongName)+SIZE_LongName, SIZE_LongName);
	}
	return nvm_size_of_this_ucm;
}





#if COMMENT
_______Level_4_______(){}
#endif

/*

	ucm header syntax 

	Ver 0x02:   defined at 100427 

		+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
		|  Id |nItem| Byte Size |  UCM CRC  |HdCRC|SV|FF|
		+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
		|   UCM DB Description..                        |
		+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

		-------------------------------------------------------
		Id (key + version)   : 0x47 0x02
		Header CRC           : changed from 32 bit to 16 bit.
		SV (Storing Version) : UCM Storing Version (== gUcmStoringVersion)
		FF                   : not used. filled to 0xFF

		Header CRC algorithm is changed also.
		

	Ver 0x01:   defined at 041110 

      +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
      |  Id |nItem| Byte Size |  UCM CRC  | Header CRC|
      +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
      |   UCM DB Description..                        |
      +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

      Name                       offset   size
      -------------------------------------------------------
      Id (key + version)       :    0       2 bytes  0x47 0x01
      Number of UCM item       :    2       2 bytes  
      Byte size of this UCM DB :    4       4 bytes  (unsigned long int)
      CRC32 of entire UCM      :    8       4 bytes  (unsigned long int)
      CRC32 of this header     :   12       4 bytes  (unsigned long int)
      Description of UCM       :   16      16 bytes  (ascii string, should include null-terminator)
	
*/



#define UCM_HEADER_MAGIC_KEY  0x47

UINT16 gUcmHeaderVersion = 0x02;
	// UCM header version이 변경되어도 
	// UcmStoringVersion 값을 upgrade해야 한다.

#define UH_OFFSET_ID          0
#define UH_OFFSET_NITEM       2
#define UH_OFFSET_BYTESIZE    4
#define UH_OFFSET_UCM_CRC     8
#define UH_OFFSET_HDR_CRC     12
#define UH_OFFSET_USV         14
#define UH_OFFSET_RESV        15
#define UH_OFFSET_DESC        16

#define UH_SIZE_ID            2
#define UH_SIZE_NITEM         2
#define UH_SIZE_BYTESIZE      4
#define UH_SIZE_UCM_CRC       4
#define UH_SIZE_HDR_CRC       2  /* 4->2 */
#define UH_SIZE_USV           1
#define UH_SIZE_RESV          1
#define UH_SIZE_DESC          16


#define UH_ID_VALUE ((UCM_HEADER_MAGIC_KEY<<8) | gUcmHeaderVersion)





STATUS nvr_ucm_init(UINT32 db_start_address)
{
	int err = statusOK;
	UINT8 TempUcm[SIZEOF_UCM_DB_ITEM];

	UINT32 crc;
	
	dprint(1, "nvr_ucm_init (0x%x)\n", db_start_address);
	
	
	memset(TempUcm, 0, SIZEOF_UCM_DB_ITEM);
	
	_d2m(TempUcm+UH_OFFSET_ID, UH_SIZE_ID, (UCM_HEADER_MAGIC_KEY << 8) + gUcmHeaderVersion);
	_d2m(TempUcm+UH_OFFSET_UCM_CRC, UH_SIZE_UCM_CRC, 0xFFFFFFFF);
	
	crc = nvr_calc_crc32(0xFFFFFFFF, TempUcm, SIZEOF_UCM_DB_ITEM);
	crc = (crc & 0xffff); /* 하위 16 bit만 추출하여 사용한다 */
	_d2m(TempUcm+UH_OFFSET_HDR_CRC, UH_SIZE_HDR_CRC, crc);
	
	dprint(2, "\t ucm header crc 0x%04x\n", crc);
	
	_d2m(TempUcm+UH_OFFSET_USV, UH_SIZE_USV, gUcmStoringVersion);
	_d2m(TempUcm+UH_OFFSET_USV+1, 1, 0xFF);

	err = NvRamWrite(db_start_address, SIZEOF_UCM_DB_ITEM, TempUcm);
	if (err != statusOK) {
		dprint(0, "!! Err nvr_ucm_init: ucm hdr, NvRamWrite err %d\n", err);
		return (STATUS)err;
	}

	return (STATUS)err;
}



#if COMMENT
	____UCM____(){}
#endif


//---------------------
//  DMW_CDB_InitUCM2
//

//  새 UCM DB 구조에는 UCM DB Header 영역이라는게 생겼기 때문에 Format을 한 다음에 이 영역을
//  초기화 해 줄 필요가 있다.
//
//  먼저 LowLevelFormat을 수행하고 UCM DB인 경우에는 이 API를 불러서 Header 영역을 초기화 해준다.
//

STATUS DMW_CDB_InitUCM2(UINT32 *pAddrs, int nDB, BOOL bSyncNow)
{
	int i, err = statusOK;
	UINT32 address;
	BOOL bSyncRequired = FALSE;
		
	dprint(1, "DMW_CDB_InitUCM2(%d DB, sync %d)\n", nDB, bSyncNow);

	for (i=0; i<nDB; i++)
	{
		address = pAddrs[i];
		err = nvr_ucm_init(address);
		
		if (address >= 0x80000000 && bSyncNow)
			bSyncRequired = TRUE;
	}
	
	if (bSyncRequired)
		err = NvRamSync(0x80000000, NULL);
	
	return (STATUS)err;
}
	
	

//---------------------
//  DMW_CDB_WriteUCM2
//
//  g_UCM 의 내용을 해당 위치의 NvRam 에 저장한다.
// 
//  start address는 API 인자로 직접 지정한다.
// 
//  WriteUCM 과 다른점:
//    일단 WriteUCM 은 Level 2 API (Section Directory) 를 이용한다.
// 
//    WriteUCM API는 caller가 directory 설정을 모두 책임지고 관리하는 경우에 사용하는 API.
//    DB의 최대 크기, overflow 체크 (필요한 경우 UCM 뒤쪽 일부를 버리기도 함) 등의 일을 caller가 담당.
//    caller가 UCM 갯수에 맞춰서 DB size를 미리 조정해 놓으면 WriteUCM은 그 크기 내에서만 저장한다.
//
//    WriteUCM2 API는 Low level driver 함수만 사용하여 동작하게 된다.
//    따라서 UCM의 최대 갯수가 넘치는지의 여부는 체크하지 않으며, 주의해서 사용해야 한다.
//    예: 다른 DB와 겹침 등은 이 API에서 체크할 수 없음.
// 
//    Updated by Chjeon 2007.9.13
//    실제 data가 Flash에 저장되려면 Caller에서 NvRamSync을 호출해 주어야 함
STATUS DMW_CDB_WriteUCM2(UINT32 db_start_address, int max_db_size, const char *description)
{
	STATUS returnStatus = statusOK;
	int i, k, err;
	
	UCM_DB_T *pUcmToWrite;   // temporary ucm pointer
	int nUcmToWrite;         // number of ucm entry to write

	UINT8 TempUcm[SIZEOF_UCM_DB_ITEM*3];

	char org_desc[UH_SIZE_DESC];
	UINT32 offset; // db_start_address를 기준으로 하는 offset.

	UINT32 crc, ucm_crc;

	int nvm_size_of_this_ucm; // 한번에 기록할 ucm의 nvm 점유 크기.
	int len_ch_name;
	
	int num_ucm_writed=0; //실제 저장된 사이즈 크기, disabled는 counting에서 제외됨
	
	dprint(1, "%s (addr 0x%x, '%s')\n", __func__, db_start_address, description ? description : "NoInfo");
	
	// cafrii 070424 add, UCM 없는 상태에서 기록하면 모두 지우는 것으로 함.
#if 0
	if (g_UCM == NULL) {
		dprint(0, "!! UCM DB NULL\n");
		return statusError;  // cafrii 030712, no ucm err.
	}
#endif

	DMW_MSC_LockUcm();  // ----------------------
	nvr_reset_epg_index();

	if (1) {
		pUcmToWrite = g_UCM ? &g_UCM[0] : NULL;
		nUcmToWrite = g_UCM_number;
	}

	if (! nvr_is_safe_area(db_start_address, SIZEOF_UCM_DB_ITEM)) {
		returnStatus = statusOutOfRange;
		goto end_write_ucm;
	}

	// 먼저 header 정보를 읽어들인다.
	//
	err = NvRamRead(db_start_address, SIZEOF_UCM_DB_ITEM, TempUcm);
	if (err) {
		dprint(0, "!! %s: read ucm header err %d\n", __func__, err);
		//return err;   // cafrii 041209, bugfix!!
		returnStatus = (STATUS)err;
		goto end_write_ucm;
	}

	memset(org_desc, 0, sizeof(org_desc));
	
	if (_m2d(TempUcm+UH_OFFSET_ID, UH_SIZE_ID) == UH_ID_VALUE) {
		memcpy(org_desc, TempUcm+UH_OFFSET_DESC, UH_SIZE_DESC);
		org_desc[UH_SIZE_DESC-1] = 0;
		dprint(2, "\t prev DB desc: '%s'\n", org_desc);
	}

	offset = SIZEOF_UCM_DB_ITEM; // UCM header 크기는 skip.
	crc = 0xFFFFFFFF;
	//
	// 한번에 하나의 UCM을 저장하는 방식.
	//
	dprint(1, "\t UCM writing, %d entries being written..\n", nUcmToWrite);

	for (i=0; i<nUcmToWrite; i++) 
	{
		// 현재 UCM entry의 NVM size와 상관 없이 항상 최대 크기의 nvm size 공간이 있는 경우에만
		// write를 진행하도록 한다.
		if (! nvr_is_safe_area(db_start_address+offset, 3*SIZEOF_UCM_DB_ITEM)) {
			dprint(0, "!! ucm[%d] cannot be stored. unsafe area! (offset 0x%x, total ucm %d)\n", 
				i, offset, nUcmToWrite);
			break;
		}
		if (db_start_address + 3*SIZEOF_UCM_DB_ITEM > db_start_address + max_db_size) {
			dprint(0, "!! ucm[%d] cannot be stored. exceed max sz 0x%x! (offset 0x%x, total ucm %d)\n", 
				i, max_db_size, offset, nUcmToWrite);
			break;
		}
		
		if(pUcmToWrite[i].disabled) continue; //disabled는 기록하지 않는다.

		// prepare memory UCM copy.	
		// LongName 에 따라서 flatten 되는 TempUcm의 크기는 달라진다.
		nvm_size_of_this_ucm = DMW_CDB_PrepareOneUcmBlockMode(TempUcm, &pUcmToWrite[i], NULL);
				
		err = NvRamWrite(db_start_address+offset, nvm_size_of_this_ucm, TempUcm);
		
		if (err != statusOK) {
			dprint(0, "!! %s: ucm[%d], NvRamWrite err %d\n", __func__, i, err);
			returnStatus = (STATUS)err;
			goto end_write_ucm;
		}
		crc = nvr_calc_crc32(crc, TempUcm, nvm_size_of_this_ucm);

		dprint(3, "  (%d) write offset %x, size %d, crc 0x%08x\n", i, offset, nvm_size_of_this_ucm, crc);

		offset += nvm_size_of_this_ucm;
		
		num_ucm_writed++;
	}

	if (i < nUcmToWrite) {
		dprint(0, "!! only %d ucms saved among %d, total %d bytes\n", i, nUcmToWrite, offset);
			// UCM[i] 가 저장되지 못하다고 판정이 난 상태이므로 
			// UCM[0] 부터 UCM[i-1] 까지 저장 가능하며, 이는 총 'i' 개의 UCM이 저장 되었다.
			// 
		nUcmToWrite = i;
	}
	else
		dprint(2, "\t total %d ucms entries, %d bytes saved..\n", nUcmToWrite, offset);
	
	nUcmToWrite=num_ucm_writed;
	
	// DB 제일 앞 부분에 특별한 정보 기록..
	//
	ucm_crc = crc;
	memset(TempUcm, 0, SIZEOF_UCM_DB_ITEM);
	
	_d2m(TempUcm+UH_OFFSET_ID,       UH_SIZE_ID,       UH_ID_VALUE);
	_d2m(TempUcm+UH_OFFSET_NITEM,    UH_SIZE_NITEM,    nUcmToWrite);
	_d2m(TempUcm+UH_OFFSET_BYTESIZE, UH_SIZE_BYTESIZE, offset);
	_d2m(TempUcm+UH_OFFSET_UCM_CRC,  UH_SIZE_UCM_CRC,  ucm_crc);
	_d2m(TempUcm+UH_OFFSET_HDR_CRC,  UH_SIZE_HDR_CRC,  0); // 먼저 0을 기록하고 crc 계산 부터 한다.
	_d2m(TempUcm+UH_OFFSET_USV,      UH_SIZE_USV,      gUcmStoringVersion);
	_d2m(TempUcm+UH_OFFSET_RESV,     UH_SIZE_RESV,     0xFF);
	
	if (description) {
		strncpy((char *)TempUcm+UH_OFFSET_DESC, description, UH_SIZE_DESC-1);
		TempUcm[UH_OFFSET_DESC+UH_SIZE_DESC-1] = 0;
	}
	else {
		memcpy(TempUcm+UH_OFFSET_DESC, org_desc, UH_SIZE_DESC);  // 기존 DB desc 정보를 유지..
	}
	// UCM header 부분의 CRC를 계산.
	crc = nvr_calc_crc32(0xFFFFFFFF, TempUcm, SIZEOF_UCM_DB_ITEM);
	crc = crc & 0xffff;  // 하위 16 bit 만..
	_d2m(TempUcm+UH_OFFSET_HDR_CRC,  UH_SIZE_HDR_CRC, crc);
	
	dprint(2, "\t nUcm %d, byte size %d, ucm crc 0x%08x, header crc 0x%04x\n", 
			nUcmToWrite, offset, ucm_crc, crc);

	err = NvRamWrite(db_start_address, SIZEOF_UCM_DB_ITEM, TempUcm);
	if (err != statusOK) {
		dprint(0, "!! %s: ucm hdr, NvRamWrite err %d\n", __func__, err);
		returnStatus = (STATUS)err;
		goto end_write_ucm;
	}

end_write_ucm:

	DMW_MSC_UnlockUcm(); // ----------------------

	/*
	Caller 쪽으로 이동 
	err = NvRamSync(db_start_address, NULL);
	if (err) 
		return err;
	*/
	
	return returnStatus; 
}





//---------------------
//  DMW_CDB_ReadUCM2
//
//
STATUS DMW_CDB_ReadUCM2(UINT32 db_start_address)
{
	STATUS returnStatus = statusOK;
	unsigned int i;
	int err;

	UCM_DB_T *pUcm;   // temporary ucm pointer

	UINT8 TempUcm[SIZEOF_UCM_DB_ITEM*3];

	UINT32 offset; // db_start_address를 기준으로 하는 offset.
	UINT32 nUcmToRead, nDbByteSize;
	
	UINT32 crc, ucm_crc, hdr_crc;
	UINT16 idHeader;
	UINT8  usv;
	int    nvm_size_of_this_ucm; // 한번에 기록할 ucm의 nvm 점유 크기.


	dprint(1, "%s (addr 0x%x)\n", __func__, db_start_address);


	// ucm header 의 정보를 읽어온다. 첫번째 entry가 바로 그 영역이다.
	//
	// ucm db header 영역을 읽을 수 있는지 검사..
	if (! nvr_is_safe_area(db_start_address, SIZEOF_UCM_DB_ITEM))
		return statusOutOfRange;
		
	//DHL_OS_Printf("before nvramread address(0x%x), size(%d), buf(0x%x)\n",
	//	db_start_address, SIZEOF_UCM_DB_ITEM, TempUcm);

	err = NvRamRead(db_start_address, SIZEOF_UCM_DB_ITEM, TempUcm);
	if (err) {
		dprint(0, "!! %s: Read ucm header err %d\n", __func__, err);
		return (STATUS)err;
	}
	
	idHeader    = _m2d (TempUcm+UH_OFFSET_ID,       UH_SIZE_ID);
	nUcmToRead  = _m2d (TempUcm+UH_OFFSET_NITEM,    UH_SIZE_NITEM);
	nDbByteSize = _m2d (TempUcm+UH_OFFSET_BYTESIZE, UH_SIZE_BYTESIZE);
	ucm_crc     = _m2d (TempUcm+UH_OFFSET_UCM_CRC,  UH_SIZE_UCM_CRC);
	hdr_crc     = _m2d (TempUcm+UH_OFFSET_HDR_CRC,  UH_SIZE_HDR_CRC);
	usv         = _m2d (TempUcm+UH_OFFSET_USV,      UH_SIZE_USV);
	
	//dprint(0, "\n");
	//memdump(TempUcm, SIZEOF_UCM_DB_ITEM, 0);
	//dprint(0, "\n");
	
	_d2m(&TempUcm[UH_OFFSET_HDR_CRC], 2, 0);
	crc = nvr_calc_crc32(0xFFFFFFFF, TempUcm, SIZEOF_UCM_DB_ITEM);
	crc = crc & 0xffff;
	
	// Header 영역이 유효한지 validity check..
	//
	if (idHeader != UH_ID_VALUE) {
		dprint(0, "!! %s: ucm header id 0x%x invalid\n", __func__, idHeader);
		//return statusNvRamNotFormatted;
		nUcmToRead = 0;
	}
	else if (usv != gUcmStoringVersion) {
		dprint(0, "!! %s: usv mismatch. nvm %02x != sw %02x\n", usv, gUcmStoringVersion);
		nUcmToRead = 0;
	}
	else if (crc == hdr_crc) {
		dprint(2, "\t nUcm %d, Bytesize %d, ucm crc 0x%08x, hdr crc 0x%04x\n", 
					nUcmToRead, nDbByteSize, ucm_crc, hdr_crc);
		// NVM ucm의 크기가 더 이상 특정 크기의 multiple이 아니므로 아래 체크는 불가능.
	#if 0
		if (nDbByteSize != nUcmToRead * SIZEOF_UCM_DB_ITEM) {
			nUcmToRead = nDbByteSize / SIZEOF_UCM_DB_ITEM;
			dprint(0, "!! db size is not multiple of nUcm. adjust to %d\n", nUcmToRead);
		}
	#endif
		
		if (TempUcm[UH_OFFSET_DESC]) 
			dprint(2, "\t ucm description: '%s'\n", &TempUcm[UH_OFFSET_DESC]);
	}
	else {
		dprint(0, "!! header crc mismatch: calc 0x%08x != saved 0x%08x\n", crc, hdr_crc);
		nUcmToRead = 0;
	}

	// 몇 개의 ucm을 읽어 들일 수 있는지 미리 알 수 없다.
	// 읽다가 overflow 되면 멈추는 방식으로 진행한다.
	dprint(2, "\t total %d ucms entries can be read..\n", nUcmToRead);
	
	DMW_MSC_LockUcm();  // ----------------------

	DMW_CDB_ClearAll();
	
	// 위에서 DB를 모두 Clear를 해도 효율을 위해 메모리 영역은 남겨두도록 되어 있다.
	// 그러나 새로 DB를 읽어들일때에는 적절한 크기 계산을 해서 재할당을 하기 때문에
	// 메모리를 모두 해제시켜버리는 것이 낫다.
	//
	if (g_UCM) {
		DHL_OS_Free((void**)&g_UCM);
		g_UCM_max = 0;
	}
	
	g_UCM_max = nUcmToRead + 8;
		// 실제 메모리상에 있을 UCM 크기이다.
		//
		// '8' is additional space for manual channel add.
		// if this space is run out, we will re-alloc memory later.

	g_UCM = DHL_OS_Malloc(g_UCM_max * UcmItemMemorySize());
	if (g_UCM == NULL) 
	{
		g_UCM_number = g_UCM_max = 0;
		returnStatus = statusOutOfMemory;
		goto end_read_ucm;
	}

	reset_ucm_uid_counter();
	pUcm = &g_UCM[0];
	g_UCM_number = 0;
	
	crc = 0xFFFFFFFF;
	offset = SIZEOF_UCM_DB_ITEM; // UCM header 영역 skip.
	
	for (i=0; i<nUcmToRead; i++)
	{
		// 제대로 저장이 된 거라면 이런 경우는 발생할 수 없음.
		// 단 맨 마지막 UCM 하나는 문제가 될 수 있음. 이러한 경우 고려 필요함.
		if (! nvr_is_safe_area(db_start_address+offset, 3*SIZEOF_UCM_DB_ITEM))
			break;
	
		err = NvRamRead(db_start_address + offset, 3*SIZEOF_UCM_DB_ITEM, TempUcm);
		if (err) {
			dprint(0, "!! %s: Read UCM #%d from NvRam err!\n", __func__, i);
			returnStatus = (STATUS)err;
			goto end_read_ucm;
		}
		
		// 정확한 NVM UCM 크기는 parsing을 해 봐야 알 수 있다.
		nvm_size_of_this_ucm = DMW_CDB_ParseOneUcmBlockMode(TempUcm, &pUcm[i], NULL);
		
		// CRC 역시 정확한 NVM UCM 부분에 대해서만 계산해야 한다.
		crc = nvr_calc_crc32(crc, TempUcm, nvm_size_of_this_ucm);
		dprint(3, "  (%d) read offset %x, size %d, crc 0x%08x\n", i, offset, nvm_size_of_this_ucm, crc);
		
		offset += nvm_size_of_this_ucm;
		g_UCM_number++;
	}

	if (i < nUcmToRead) {
		dprint(0, "!! only %d ucms read among %d\n", i, nUcmToRead);
		// 아마도 이런 상황이 되면 crc도 mismatch가 나서 fail 될 것임. 별도 에러 처리 안함.
	}
	if (crc != ucm_crc) {
		dprint(0, "!! calculated crc 0x%08x != nvram crc 0x%08x\n", crc, ucm_crc);
		g_UCM_number = 0;
		returnStatus = statusError;
	}

end_read_ucm:

	DMW_MSC_UnlockUcm(); // ----------------------
	
	return returnStatus;
}



//---------------------
//  DMW_CDB_WriteRawDB2
//
//  Raw DB Access API 의 새 버전
//  
//  Directory index를 사용하지 않고 직접 caller가 DB NvRam address를 지정한다
//  DB의 크기도 직접 지정하므로, DB 의 최대 크기를 넘지 않도록 caller가 주의하여야 한다.
//
//  Updated by chjeon 2007.09.12
//  기존의 이 함수는 Sync 작업도 포함이 되어 있었지만 현재는 분리 상태임 
//  실제 Flash에 저장하려면 Caller에서 NvRamSync를 호출해주어야 함  
STATUS DMW_CDB_WriteRawDB2(UINT32 address, UINT8 *buf, int newsize)
{
	int err;

	dprint(1, "DMW_CDB_WriteRawDB2 (0x%x, size %d)\n", address, newsize);
	
	if (! nvr_is_safe_area(address, newsize))
		return statusOutOfRange;

	err = NvRamWrite(address, newsize, buf);
		
	if (err != statusOK) {
		dprint(0, "!! Err DMW_CDB_WriteRawDB2: NvRam Write err %d\n", err);
		return (STATUS)err;
	}

	// Updated by Chjeon 2007.09.11
	// - 데이터가 저장되길 원하면 Caller에서 NvRamSync 함수를 호출해 주어야 한다. 
	/*
	err = NvRamSync(address, NULL);
	if (err) 
		return err;
	*/

	return statusOK;	
}


//---------------------
//  DMW_CDB_ReadRawDB2
//
//  Raw DB Access API 의 새 버전
//  
//
//
STATUS DMW_CDB_ReadRawDB2(UINT32 address, UINT8 *buf, int newsize)
{
	int err;
	
	dprint(1, "DMW_CDB_ReadRawDB2 (0x%x, size %d)\n", address, newsize);
	
	if (! nvr_is_safe_area(address, newsize))
		return statusOutOfRange;

	err = NvRamRead(address, newsize, buf);
	if (err) {
		dprint(0, "!! DMW_CDB_ReadRawDB2: NvRam Read err %d\n", err);
		return (STATUS)err;
	}
	
	return statusOK;
}



#if COMMENT
_______Util_______(){}
#endif


STATUS DMW_CDB_SyncNvRam(UINT32 address)
{
	STATUS err;
	err = NvRamSync(address, NULL);
	return err;
}

UINT32 DMW_CDB_CalcCRC32(UINT32 crc_start, const UINT8 *data, UINT32 len)
{
	return nvr_calc_crc32(crc_start, data, len);
}

// cafrii 060802 add
BOOL DMW_CDB_IsNvRamSyncWorking(void)
{
	BOOL bNvRamFree = NvRamIsSyncEnd();

	return bNvRamFree ? FALSE : TRUE;
}

void DMW_CDB_WaitForNvRamSyncDone()
{
	NvRamWaitForSyncEnd();
	dprint(2, "NvRam Sync Completed..\n");
}


void DMW_CDB_InvalidateNvRamCache()
{
	NvRamInvalidateCache();
}




#if COMMENT
_______Debug_______(){}
#endif



void DMW_CDB_MakeTestUcm(int nItem)
{
	int i, k, r, idx;
	
	if (nItem == 0)
		nItem = 100;
		
	dprint(1, "DMW_CDB_MakeTestUcm: make temp %d UCM items..\n", nItem);

	DMW_CDB_ClearAll();  // 먼저 모든 Ucm을 삭제한다.
		
	DMW_MSC_LockUcm();
	
	r = prepare_ucm_space(32);
	if (r) {
		dprint(0, "!! out of memory for ucm\n");
		return;
	}

	srand(DHL_OS_GetMsCount());
	
	for (i=0; i<nItem; i++) {
		
	#if 0
		
		// 직접 UCM 배열에 접근해서 추가하기.. 권장되지 않음!!
		memset(&g_UCM[i], 0, UcmItemMemorySize());
		
		g_UCM[i].Major = i+5;
		g_UCM[i].Minor = 1;
		g_UCM[i].RF = i+9;
		g_UCM[i].VctFlag = i%2;
		g_UCM[i].Skipped = 0;
		g_UCM[i].Service_type = i % 5 == 0 ? 0 : 1;
		g_UCM[i].Uid = make_new_ucm_uid_counter();
		
	#else
	
		int major, minor, rf, vf, st;
		
		rf = i+6;
		vf = rand()%10 > 2 ? 1 : 0;  // 70% possibility
		major = vf ? rand() % 128 + 2 : rf;
		minor = rand() % 8 + 1;
		st = 1;  // VSB only
		
		idx = DMW_CDB_MakeNewUcm(major, minor, rf, vf, st);
		
		g_UCM[idx].Skipped = rand() % 10 > 2 ? 0 : 1;
		g_UCM[idx].Prog_number = rand()%5 + 1;
		g_UCM[idx].Pcr_pid = rand()%10 + 100;
		g_UCM[idx].Video_pid = g_UCM[idx].Pcr_pid;
		g_UCM[idx].Audio_pid = g_UCM[idx].Pcr_pid + rand()%5 + 3;
		g_UCM[idx].source_id = rand()%5 + 1;
		
		for (k=0; k<rand()%9+4; k++) {
			g_UCM[idx].ShortName[k] = rand()%27 + '@';
		}
		
		if (idx < 0) {
			dprint(0, "!! out of memory for new ucm.. only %d items are added..\n", i);
			break;
		}
		#if 0
			for (k=0; g_UCM && k<g_UCM_number; k++) {
				dprint(2, " %c(%02d) %2d,%d %2d %c[%03d]  %s\n",
					g_UCM[k].Skipped ? ' ' : '+',         // enabled channel.
					k, g_UCM[k].Major, g_UCM[k].Minor, g_UCM[k].RF,
					g_UCM[k].VctFlag ? 'v' : ' ',
					g_UCM[k].Uid, ServiceTypeString(g_UCM[i].Service_type));
			}
		#endif
		
		if (i%100 == 0)
			DHL_OS_Printf(".");
		
		//OS_Delay(1);
	
	#endif
	
	}
	
	DMW_MSC_UnlockUcm();
	
	dprint(2, "Test UCM is made..\n");
}





#if COMMENT
______DebugSymbol____(){}
#endif




#if DMW_REGISTER_DEBUG_SYMBOL

static DHL_SymbolTable ChannelNvRamSymbols[] =
{
	//---- functions
	DHL_FNC_SYM_ENTRY(DMW_CDB_GetNvRamAvailableSize),
	DHL_FNC_SYM_ENTRY(DMW_CDB_CheckNvRam),
	DHL_FNC_SYM_ENTRY(DMW_CDB_MakeTestUcm),

	DHL_FNC_SYM_ENTRY(DMW_CDB_IsNvRamSyncWorking),
	
	//---- variables
	//DHL_VAR_SYM_ENTRY(g_Trace_ChannelDB),
	
};

#endif // DMW_REGISTER_DEBUG_SYMBOL


void DMW_CDB_RegisterChannelNvRamSymbols()
{
#if DMW_REGISTER_DEBUG_SYMBOL
	DHL_DBG_RegisterSymbols(ChannelNvRamSymbols, DHL_NUMSYMBOLS(ChannelNvRamSymbols));
	
	NvRamRegisterDebugSymbol();
#endif
}



/********************************************************************
 *
 * $Log: DMW_ChannelDB.c,v $

	1.40 2004/12/17 DMW_CDB_WriteUCM2: nUcmToWrite가 0일때도 기록
	1.39 2004/12/09 DMW_CDB_WriteUCM2: 에러발생시 UCM unlock 안하는 버그수정

	1.38 2004/11/30 persistent scrambled flag, ucm ver->A7
	                
	1.37 2004/11/29 UcmStrongVersion -> A6
	                DMW_CDB_WriteUCM2 에 max_db_size 인자 추가
	                DMW_CDB_CalcCRC32 추가

	1.36 2004/11/10 Level 4 API 추가
	1.35 2004/11/03 DMW_CDB_ReadUCM 에서 db size가 0일때 garbage 리턴되는 버그 수정
	
	1.34 2004/9/20 DMW_Config 도입, config 사항 이동
	1.33 2004/8/12 UCM write할때 freqOffset 저장안되던 버그 수정 (from miyu)
	1.32 2004/7/26 add debug print level
	1.31 2004/6/7  DMW_EEPROM.h include (platform dependent flag 포함)

	1.3 2004/05/25 new eeprom에 맞춰서 SetDirItem을 한번에 8바이트 기록하도록 수정
	              lowlevel format시 eeprom 에러가 나면 flash는 skip
	
	1.2 2004/04/07 Add error check code in Level 2 directory API
	
	1.12 2004/01/14 add persistant hidden flag, UCM version up
	1.11 2004/01/02 minor bug fix in FlashSync in WriteUCM
	1.10 2003/12/31 
	ND field added in SYS_PARAM 
	
	Flash DB support, GenerateTestUcm, 2003/11/13 cafrii
	
	Read/WritEncryptedDtcpCertAndKey() change, 2003/8/3 cafrii 
	NvRam Sema4 add, 2003/7/11 cafrii

 * Revision 1.01  2003/02/17  cafrii
 * NVRAM strategy is changed.
 * AirUCM/CableUCM code-share...
 *
 * Revision 1.0  2003/01/13  cafrii
 * Initial coding from ground, based on M/W API document
 *
 ********************************************************************/