/****************************************************************************
 *_Copyright (c) 2004 DST Technologies Inc.  All Rights Reserved.
 *
 * Module:      dsthalsys.c
 *
 * Description: DST SYSTEM INTERFACE IMPLEMENTATION
 *              
 *
 * notes: jfet20040610
 *
 ***************************************************************************/

#include "dsthalcommon.h"
#include "dsthalsys.h"
#include "dsthalfe.h"
#include "string.h"
#include <sys/utsname.h>
#include "dstddsys.h"
#include "dstversion.h"

#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include <unistd.h>

#ifdef DMALLOC
#include <dmalloc.h>
#endif

/******************************************************************************
 * Global variable declaration
 ******************************************************************************/
DS_U8 DhlSysInfoInit; 
DS_U32 gdhlSysDbgLvl = 2;
DS_U32 gdhlExtDbgLvl = 2;
DHL_SYS_Info DhlSysInfo;
DHL_SYS_CONFIG g_dhlsys;

/******************************************************************************
 * Imported variable declaration
 ******************************************************************************/


/******************************************************************************
 * Imported function declaration
 ******************************************************************************/


/******************************************************************************
 * Local definitions
 ******************************************************************************/
#define	LOCK_SYS_MUTEX()	do { \
		if ( OS_TakeMutex(g_dhlsys.SYSMutex) != OS_OK ) { \
			DHL_DbgPrintf(0,DHLDBG_SYS, "MUTEX ERROR, LINE=%d\n", __LINE__); \
			goto done; \
		} \
	} while (0)

#define	UNLOCK_SYS_MUTEX()	do { \
		if ( OS_GiveMutex(g_dhlsys.SYSMutex) != OS_OK ) { \
			DHL_DbgPrintf(0,DHLDBG_SYS,"MUTEX ERROR, LINE=%d\n", __LINE__); \
		} \
	} while (0)

/******************************************************************************
 * Local typedefs
 ******************************************************************************/


/******************************************************************************
 * Local variables declaration
 ******************************************************************************/
static DS_U32 g_BrdRev, g_BrdDiv;

/******************************************************************************
 * Local function prototypes
 ******************************************************************************/
static void DHL_SYS_InitInfo(void );
static int GetMemoryParam(char *iStream, const char *FindString, DS_U32 *pValue);

/********************************************************************************
FUNCTION:                                                                   
    DHL_SYS_INITITIATE                                               		

Purpose:                                                                    

Arguments:                                                                  	
                                                                            	
Returns:                                                                    
    DHL_RESULT  success - DHL_OK 
    			fail - DHL_FAIL	      			
*********************************************************************************/
DHL_RESULT DHL_SYS_Initiate(void)
{
	DHL_RESULT	dhlResult = DHL_OK;

	dhlResult = DD_SYS_Initiate();
	SysASSERT( dhlResult == DHL_OK );
	
	OS_Init();
	
	g_dhlsys.SYSMutex = OS_CreateMutex( "SYS_Mutex" );
	if ( g_dhlsys.SYSMutex == (OS_MUTEX_ID)0 ) 
	{
		DHL_DbgPrintf(gdhlSysDbgLvl,DHLDBG_SYS," |error|%d\r\n",__LINE__);
		dhlResult = DHL_FAIL_CORE_DRIVER;
		goto done;
	}
    
#if 0
	dhlResult = DD_SYS_CheckDevice();
	if(DHL_ERROR(dhlResult))
	DHL_DbgPrintf(gdhlSysDbgLvl,DHLDBG_SYS, " |Error| %d Fail system Initiate.\r\n",__LINE__);	
#endif	

	// hwatk/060704
	//부팅시 다음라인에서 멈추는 경우가 발생하여 제거.
	//system( "/bin/stty erase ^H" );

    DHL_SYS_GetBoardVersion(&g_BrdRev);

    dhlResult = DHL_AUD_Init();
done:	
    SysENSURE( dhlResult == DHL_OK );

	return dhlResult;
}
/********************************************************************************
FUNCTION:                                                                   
    DHL_SYS_InitInfo                                               		

Purpose:                                                                    
	Get the dsthal,atidrivers,kernel,HW version information.
Arguments:                                                                  	
                                                                            	
Returns:                                                                    
    DHL_RESULT  success - DHL_OK 
    			fail - DHL_FAIL	      			
*********************************************************************************/
static void DHL_SYS_InitInfo(void )
{
	extern DS_U32 DD_FE_GetVersion( void );
	char buf[256], *ptr;
	FILE *fp;

	fp = fopen("/proc/version", "r");
	if ( !fp ) {
		DHL_DbgPrintf(gdhlSysDbgLvl,DHLDBG_SYS, " |Error| %d.\n",__LINE__);
	} else {
		ptr = fgets( buf, 256, fp );
		if ( !ptr ) {
			DHL_DbgPrintf(gdhlSysDbgLvl,DHLDBG_SYS, " |Error| %d.\n",__LINE__);
		} else {
			ptr = strstr( buf, "DST_K" );
			if ( ptr ) 
				strncpy(DhlSysInfo.kernel_version, ptr, 9);
			else
				strncpy(DhlSysInfo.kernel_version, buf, 9);
		}
		DhlSysInfo.kernel_version[9] = '\0';
	}
	
	DhlSysInfo.dsthal_version = DSTHAL_VERSION;
	DHL_SYS_GetBoardVersion( &DhlSysInfo.board_version );
	DhlSysInfo.driver_dst_version = DD_SYS_GetDrvDstVersion();
	DhlSysInfo.driver_ven_version = DD_SYS_GetDrvVenVersion();
	DhlSysInfo.fe_version = DD_FE_GetVersion();
	DhlSysInfo.loader_version = DD_SYS_GetLoaderVer();
	
	DhlSysInfoInit = 1;
}

/********************************************************************************
FUNCTION:                                                                   
    DHL_SYS_GetInfo
Purpose:                                                                    
	Get version information for ati layer, dsthal, board and kernel version .
	Arguments:                                                                  	
	DHL_SYS_Info *
Returns:                                                                    
    DHL_RESULT   if success - DHL_OK fail - DHL_FAIL	 
*********************************************************************************/

void DHL_SYS_GetInfo( pDHL_SYS_Info psys_info)
{
	if(DhlSysInfoInit == 0)
		DHL_SYS_InitInfo();
	*psys_info = DhlSysInfo; 
}

#define	GET_DS_U8_0(x)	(unsigned int)((x>>24)&0xFF)
#define	GET_DS_U8_1(x)	(unsigned int)((x>>16)&0xFF)
#define	GET_DS_U8_2(x)	(unsigned int)((x>>8)&0xFF)
#define	GET_DS_U8_3(x)	(unsigned int)((x)&0xFF)

void DHL_SYS_DumpVersion(void)
{
	if(DhlSysInfoInit == 0)
		DHL_SYS_InitInfo();

	DHL_DbgPrintf( 0, DHLDBG_PSI, "   Kernel Version: %s\n", DhlSysInfo.kernel_version );
	
	DHL_DbgPrintf( 0, DHLDBG_PSI, "   DSTHAL Version: H%x.%x%x%x\n", 
		GET_DS_U8_0(DhlSysInfo.dsthal_version), GET_DS_U8_1(DhlSysInfo.dsthal_version),
		GET_DS_U8_2(DhlSysInfo.dsthal_version), GET_DS_U8_3(DhlSysInfo.dsthal_version) );
	
	DHL_DbgPrintf( 0, DHLDBG_PSI, "   Board Version: 0x%02X\n", (unsigned int)DhlSysInfo.board_version );
	DHL_DbgPrintf( 0, DHLDBG_PSI, "   Driver DST Version: D%x.%x%x%x\n", 
		GET_DS_U8_0(DhlSysInfo.driver_dst_version), GET_DS_U8_1(DhlSysInfo.driver_dst_version),
		GET_DS_U8_2(DhlSysInfo.driver_dst_version), GET_DS_U8_3(DhlSysInfo.driver_dst_version) );
	
	DHL_DbgPrintf( 0, DHLDBG_PSI, "   Driver Vendor Version: Rel %x.%x.%x.%x\n", 
		GET_DS_U8_0(DhlSysInfo.driver_ven_version), GET_DS_U8_1(DhlSysInfo.driver_ven_version),
		GET_DS_U8_2(DhlSysInfo.driver_ven_version), GET_DS_U8_3(DhlSysInfo.driver_ven_version) );
		
	DHL_DbgPrintf( 0, DHLDBG_PSI, "   FE Firmware Version: %x.%x.%x.%x\n", 
		GET_DS_U8_0(DhlSysInfo.fe_version), GET_DS_U8_1(DhlSysInfo.fe_version),
		GET_DS_U8_2(DhlSysInfo.fe_version), GET_DS_U8_3(DhlSysInfo.fe_version) );
	
	DHL_DbgPrintf( 0, DHLDBG_PSI, "   BootLoader Version: %x.%x.%x.%x\n",
		GET_DS_U8_0(DhlSysInfo.loader_version), GET_DS_U8_1(DhlSysInfo.loader_version),
		GET_DS_U8_2(DhlSysInfo.loader_version), GET_DS_U8_3(DhlSysInfo.loader_version) );
}
	

/********************************************************************************
FUNCTION:                                                                   
    DHL_SYS_TERMINATE                                               		
Purpose:                                                                    

Arguments:                                                                  	

Returns:                                                                    
    DHL_RESULT   if success - DHL_OK fail - DHL_FAIL	 
*********************************************************************************/
DHL_RESULT DHL_SYS_Terminate(void)
{
    DHL_RESULT 	dhlResult = DHL_OK;
	dhlResult = DD_SYS_Terminate();
	if(DHL_ERROR(dhlResult))
		DHL_DbgPrintf(gdhlSysDbgLvl,DHLDBG_SYS,
					 " |Error| %d Fail system Terminate \r\n",__LINE__);
	else
		DHL_DbgPrintf(gdhlSysDbgLvl,DHLDBG_SYS," |success|\r\n");
	return dhlResult;	
}
/********************************************************************************
FUNCTION:                                                                   
    DHL_SYS_IsUsbVaild                                              		

Purpose:                                                                    

Arguments:                                                                  	

Returns:                                                                    
	DHL_RESULT	valid - DHL_OK, invaild - DHL_FAIL
Notes:
*********************************************************************************/
DHL_RESULT DHL_SYS_IsUsbValid(void)
{
	return DD_SYS_IsUsbValid();
}
/********************************************************************************
FUNCTION:                                                                   
    DHL_SYS_SetDbgLvl                                              		

Purpose:                                                                    

Arguments:                                                                  	

Returns:                                                                    
	DS_BOOL	
Notes:
*********************************************************************************/
void DHL_SYS_SetDbgLvl(DS_U32 uDbgLvl, DHL_SYS_DBGTYPE DbgType)
{
	switch(DbgType)
	{
		case DHL_SYSDBG_DHLSYS:
			gdhlSysDbgLvl = uDbgLvl;
			break;
		case DHL_SYSDBG_DDSYS:
			DD_SYS_SetDbgLvl(uDbgLvl);
			break;
		case DHL_SYSDBG_END:
		default:
			DHL_DbgPrintf(gdhlSysDbgLvl,DHLDBG_SYS,
					 " |Error| Not avaliable parameter %d\r\n",__LINE__);
			break;
	}	
	DHL_DbgPrintf(0,DHLDBG_SYS,"DHLSys DbgLvl(%d)\r\n",uDbgLvl);
}

/********************************************************************************
FUNCTION:                                                                   
    DHL_SYS_IsSTBYPowerMode                                              		
	DHL_SYS_IsDCRBoard
	
Purpose:                                                                    

Arguments:                                                                  	

Returns:                                                                    
	DHL_SYS_IsSTBYPowerMode : 0 - Powered by host, 1 - Powered by POD.
	DHL_SYS_IsDCRBoard : 1 - Step, 0 - Basic
	
Notes:
*********************************************************************************/
DHL_RESULT DHL_SYS_IsSTBYPowerMode( DS_BOOL *flag )
{
	DHL_RESULT dhlResult = DHL_OK;

	if(DHL_ERROR(dhlResult))
		DHL_DbgPrintf(gdhlSysDbgLvl,DHLDBG_SYS,
					 " |Error| %d Cannot get stby power mode.\r\n",__LINE__);
	
	return dhlResult;
}

DHL_RESULT DHL_SYS_GetBoardVersion(DS_U32 *ver)
{
	DHL_RESULT dhlResult = DHL_OK;
	DS_U8 boardVer = 0;
    
    *ver = boardVer;
    
	return dhlResult; 
}

DHL_RESULT DHL_SYS_Reset(void)
{
	DHL_RESULT dhlResult = DHL_OK;
	
	dhlResult = DD_SYS_Reset();
	SysASSERT( dhlResult == DHL_OK );
	
	return dhlResult;
}

int DHL_SYS_I2cWrite(unsigned char addr, int nSubAddress, int subAddress, unsigned char *buf, int len)
{
	int ret = -1;
	
	if ( !buf && len ) {
		DHL_DbgPrintf( 0, DHLDBG_SYS, "ERROR, LINE=%d\n",  __LINE__);
		return -1;
	}
	
	LOCK_SYS_MUTEX();
	ret = DD_SYS_I2cWrite(0, addr, nSubAddress, subAddress, buf, len);
	UNLOCK_SYS_MUTEX();
	
done:
	return ret;
}

int DHL_SYS_I2cRead(unsigned char addr, int nSubAddress, int subAddress, unsigned char *buf, int len)
{
	int ret = -1;
	
	LOCK_SYS_MUTEX();
	ret = DD_SYS_I2cRead(0, addr, nSubAddress, subAddress, buf, len);
	UNLOCK_SYS_MUTEX();
		
done:
	return ret;
}

int DHL_SYS_MSPWrite(unsigned char WriteAddr,unsigned int addr,unsigned short length,unsigned short data)
{
    int SubAddress;
    
    SubAddress  = WriteAddr;
    SubAddress += (((addr>>8) & 0xFF)<<8);
    SubAddress += (addr & 0xFF)<<16;
    return DHL_SYS_I2cWrite( 0x80, 3, SubAddress, (unsigned char *)&data, 2/*length*/ );
}

int DHL_SYS_MSPRead(unsigned char subAddr, unsigned int addr,unsigned short length,unsigned char *rbuf)
{
    int SubAddress;
    
    SubAddress  = subAddr;
    SubAddress += (((addr>>8) & 0xFF)<<8);
    SubAddress += (addr & 0xFF)<<16;
    
    return DHL_SYS_I2cRead( 0x80, 3, SubAddress, rbuf, /*length*/2 );
}

int DHL_SYS_ANXWrite(unsigned char port, unsigned char regAddr, unsigned char val)
{
	int ret = -1;
	int try_cnt;
	
	if (port == 0)
	{
		
		for (try_cnt = 0; try_cnt < 3; try_cnt++)
		{
			LOCK_SYS_MUTEX();
			ret = DD_SYS_I2cWrite(1, HDMI_TX_PORT0_ADDR, 1, regAddr, &val, 1);
			UNLOCK_SYS_MUTEX();
			if (ret == 2)
			{
				break;
			}	
			OS_mDelay(10);
		}
	}
	else if (port == 1)
	{
		
		for (try_cnt = 0; try_cnt < 3; try_cnt++)
		{
			LOCK_SYS_MUTEX();
			ret = DD_SYS_I2cWrite(1, HDMI_TX_PORT1_ADDR, 1, regAddr, &val, 1);
			UNLOCK_SYS_MUTEX();
			if (ret == 2)
			{
				break;
			}	
			OS_mDelay(10);
		}
	}
		
	if (try_cnt==3) {
	    printf("|%s| ERROR: I2C error is occurred more than 3 times.\n", __FUNCTION__);
	}
				
done:
	return ret;
}

int DHL_SYS_ANXRead(unsigned char port, unsigned char regAddr, unsigned char *buf)
{
	int ret = -1;
    int try_cnt;
	
	if (port == 0)
	{
		
		for (try_cnt = 0; try_cnt < 3; try_cnt++)
		{
			LOCK_SYS_MUTEX();
			ret = DD_SYS_I2cRead(1, HDMI_TX_PORT0_ADDR, 1, regAddr, buf, 1);
			UNLOCK_SYS_MUTEX();
			if (ret == 1)
			{
				break;
			}	
			OS_mDelay(10);
		}
	}
	else if (port == 1)
	{
		for (try_cnt = 0; try_cnt < 3; try_cnt++)
		{
			LOCK_SYS_MUTEX();
			ret = DD_SYS_I2cRead(1, HDMI_TX_PORT1_ADDR, 1, regAddr, buf, 1);
			UNLOCK_SYS_MUTEX();
			if (ret == 1)
			{
				break;
			}	
			OS_mDelay(10);
		}
	}
	
	if (try_cnt==3) {
	    printf("|%s| ERROR: I2C error is occurred more than 3 times.\n", __FUNCTION__);
	}
		
done:
	return ret;
}

int DHL_SYS_8775Write(unsigned char port, unsigned char regAddr, unsigned char val)
{
	int ret = -1;
	
	if (port == 0)
	{
		int try_cnt;
		
		for (try_cnt = 0; try_cnt < 3; try_cnt++)
		{
			LOCK_SYS_MUTEX();
			ret = DD_SYS_I2cWrite(1, HDMI_RX_PORT0_ADDR, 1, regAddr, &val, 1);
			UNLOCK_SYS_MUTEX();
			if (ret == 2)
			{
				break;
			}	
			OS_mDelay(10);
		}
	}
	else if (port == 1)
	{
		int try_cnt;
		
		for (try_cnt = 0; try_cnt < 3; try_cnt++)
		{
			LOCK_SYS_MUTEX();
			ret = DD_SYS_I2cWrite(1, HDMI_RX_PORT1_ADDR, 1, regAddr, &val, 1);
			UNLOCK_SYS_MUTEX();
			if (ret == 2)
			{
				break;
			}	
			OS_mDelay(10);
		}
	}
		
done:
	return ret;
}

int DHL_SYS_8775Read(unsigned char port, unsigned char regAddr, unsigned char *buf)
{
	int ret = -1;
	
	if (port == 0)
	{
		int try_cnt;
		
		for (try_cnt = 0; try_cnt < 3; try_cnt++)
		{
			LOCK_SYS_MUTEX();
			ret = DD_SYS_I2cRead(1, HDMI_RX_PORT0_ADDR, 1, regAddr, buf, 1);
			UNLOCK_SYS_MUTEX();
			if (ret == 1)
			{
				break;
			}	
			OS_mDelay(10);
		}
	}
	else if (port == 1)
	{
		int try_cnt;
		
		for (try_cnt = 0; try_cnt < 3; try_cnt++)
		{
			LOCK_SYS_MUTEX();
			ret = DD_SYS_I2cRead(1, HDMI_RX_PORT1_ADDR, 1, regAddr, buf, 1);
			UNLOCK_SYS_MUTEX();
			if (ret == 1)
			{
				break;
			}	
			OS_mDelay(10);
		}
	}
		
done:
	return ret;
}

int DHL_SYS_I2cWriteEx(int i2cBus, unsigned char addr, int isSubAddress, int subAddress, unsigned char *buf, int len)
{
	int ret = -1;
	
	if ( !buf && len ) {
		DHL_DbgPrintf( 0, DHLDBG_SYS, "ERROR, LINE=%d\n",  __LINE__);
		return -1;
	}
	
	LOCK_SYS_MUTEX();
	ret = DD_SYS_I2cWrite(i2cBus, addr, isSubAddress, subAddress, buf, len);
	UNLOCK_SYS_MUTEX();
	
done:
	return ret;
}

int DHL_SYS_I2cReadEx(int i2cBus, unsigned char addr, int isSubAddress, int subAddress, unsigned char *buf, int len)
{
	int ret = -1;
	
	LOCK_SYS_MUTEX();
	ret = DD_SYS_I2cRead(i2cBus, addr, isSubAddress, subAddress, buf, len);
	UNLOCK_SYS_MUTEX();
		
done:
	return ret;
}

DHL_RESULT DHL_SYS_SetI2CSpeed(unsigned char bus, unsigned int speed)
{
	return DD_SYS_SetI2CSpeed(bus,speed);
}

//
// DHL_SYS_SetGPIO
//
//	GpioNum:	GPIO_XXX definition number
//	Value:		0 or 1
//
DHL_RESULT DHL_SYS_SetGPIO( int GpioNum, int Value )
{
	return DD_SYS_SetGPIO( GpioNum, Value );
}

//
// DHL_SYS_GetGPIO
//
//	GpioNum:	GPIO_XXX definition number
//
int DHL_SYS_GetGPIO( int GpioNum )
{
	return DD_SYS_GetGPIO( GpioNum );
}

int DHL_SYS_FindGPIONum( const char *gpioName )
{
	return DD_SYS_FindGPIONum( gpioName );
}

char *DHL_SYS_GetGPIOName( int GpioNum )
{
	return DD_SYS_GetGPIOName( GpioNum );
}

DS_U32 DHL_SYS_ReadRegister( DS_U32 Address )
{
	return OS_ReadRegister( Address );
}

DS_U32 DHL_SYS_WriteRegister( DS_U32 Address, DS_U32 Value )
{
	return OS_WriteRegister(Address, Value);
}

DS_U32 DHL_SYS_GetCurrentTick(void)
{
	return OS_GetTickCount();
}

/****************************************************************************


 ****************************************************************************/
DHL_RESULT DHL_SYS_IsSystemAlive(DS_U8 *pErrorCode)
{
	DHL_RESULT dhlResult=DHL_OK;
	
	//dhlResult=DD_SYS_IsSystemAlive(pErrorCode);
	
	return dhlResult;
}

char *DHL_SYS_GetSystemErrorCode(DS_U8 ErrorCode)
{
	char *ptr;
	
	ptr=DD_SYS_GetSystemErrorCode(ErrorCode);
	
	return ptr;
}

int DHL_SYS_GetCECSwitchStatus(void)
{
	DHL_RESULT dhlResult = DHL_OK;
	DS_U32 boardver = 0;
	int tmp;
	
	dhlResult = DHL_SYS_GetBoardVersion(&boardver);
	
	if(dhlResult != DHL_OK){
		DHL_DbgPrintf( 0, DHLDBG_SYS, "Board Version Reading Fail\n");
		return -1;
	}
	
	if(boardver < 40){
		DHL_DbgPrintf( 0, DHLDBG_SYS, "Your Board don't have CECSwitchStatus GPIO\n");
		return -1;
	}
	tmp = DHL_SYS_GetGPIO(GPIO_CEC_ON);
	DHL_DbgPrintf( 0, DHLDBG_SYS, "Input is %d\n",tmp);
	return tmp;
}

DHL_RESULT DHL_SYS_SetBoardRev(DS_U32 BrdDiv, DS_U32 BrdRev)
{
	DHL_RESULT dhlResult = DHL_OK;
	
	g_BrdDiv = BrdDiv;
	g_BrdRev = BrdRev;
	
	return dhlResult;
}

DS_U32 DHL_SYS_GetBoardRev(void)
{
	return g_BrdRev;
}

DS_U32 DHL_SYS_GetBoardDiv(void)
{
	return g_BrdDiv;
}

int DHL_SYS_GetHDMISwMux(void)
{
	int port1, port2;
	int mux = 0;

	port1 = DD_SYS_GetGPIOOut(GPIO_HDMI_S1);
	port2 = DD_SYS_GetGPIOOut(GPIO_HDMI_S2);

	if (port1 == 1 && port2 == 1)
	{
		mux = 0;
	}
	else if (port1 == 0 && port2 == 1)
	{
		mux = 1;
	}
	else if (port1 == 0 && port2 == 0)
	{
		mux = 2;
	}
	else if (port1 == 1 && port2 == 0)
	{
		mux = 3;
	}
	else
	{
		mux = -1;
	}

	return mux;
}

int DHL_SYS_SetHDMISwMux(int mux)
{
	int ret = 0;
	
	switch (mux)
	{
		case 0:
			DHL_SYS_SetGPIO(GPIO_HDMI_S1, 1);
			DHL_SYS_SetGPIO(GPIO_HDMI_S2, 1);
			break;
		case 1:
			DHL_SYS_SetGPIO(GPIO_HDMI_S1, 0);
			DHL_SYS_SetGPIO(GPIO_HDMI_S2, 1);
			break;
		case 2:
			DHL_SYS_SetGPIO(GPIO_HDMI_S1, 0);
			DHL_SYS_SetGPIO(GPIO_HDMI_S2, 0);
			break;
		case 3:
			DHL_SYS_SetGPIO(GPIO_HDMI_S1, 1);
			DHL_SYS_SetGPIO(GPIO_HDMI_S2, 0);
			break;
		default:
			ret = -1;
			break;
	}
	// wait hdmi rx switch's switching time. spec is max 15ns	
	OS_mDelay(1);
	
	return ret;
}

int DHL_SYS_SetHDMI_EDID_WREn(int onoff)
{
	int ret = 0;
	
	if (onoff == 0)
	{
		ret = DHL_SYS_SetGPIO(GPIO_EDID_WR_EN, 0);		
	}
	else if (onoff == 1)
	{
		ret = DHL_SYS_SetGPIO(GPIO_EDID_WR_EN, 1);		
	}
	else
	{
		ret = -1;
	}
	
	return ret;
}

int DHL_SYS_GenHDMI_HPD(void)
{
	DHL_SYS_SetGPIO(GPIO_HDMI_HPD, 1);
	OS_mDelay(100);
	DHL_SYS_SetGPIO(GPIO_HDMI_HPD, 0);
	
	return 0;
}

#if 0
___DEBUG_APIs___()
#endif
void DHL_SYS_DumpRegister(DS_U32 Address, DS_U32 cnt)
{
	DS_U32 i;
	
	if ( Address < 0xA0000000 || Address > 0xBFFFFFFF || 
	    (Address+cnt) < 0xA0000000 || (Address+cnt) > 0xBFFFFFFF ||
	    cnt <= 0 ) {
		printf("ERROR: Invalid arguments: Address = 0x%08lX, cnt = 0x%08lX\n", Address, cnt );
		return;
	}
	
	if ( Address & 3 ) {
		printf("ERROR: Address shall be aligned to 4.\n");
		return;
	}
	
	for (i=0; i<cnt; i+=4) {
		if ( !(i%16) ) 
			printf("\n%08lX  ", Address+i);
		
		printf("%08lX ", DHL_SYS_ReadRegister(Address+i));
	}
	
	printf("\n");
}

void DHL_SYS_DumpRegisterWord(DS_U32 Address, DS_U32 cnt)
{
	DS_U32 i;
	
	if ( Address < 0xA0000000 || Address > 0xBFFFFFFF || 
	    (Address+cnt) < 0xA0000000 || (Address+cnt) > 0xBFFFFFFF ||
	    cnt <= 0 ) {
		printf("ERROR: Invalid arguments: Address = 0x%08lX, cnt = 0x%08lX\n", Address, cnt );
		return;
	}
	
	if ( Address & 1 ) {
		printf("ERROR: Address shall be aligned to 4.\n");
		return;
	}
	
	for (i=0; i<cnt; i+=2) {
		if ( !(i%16) ) 
			printf("\n%08lX  ", Address+i);
		
		printf("%04lX ", OS_ReadRegisterWord(Address+i));
	}
	
	printf("\n");
}

void DHL_SYS_DumpMemory(DS_U32 Address, DS_U32 cnt)
{
	DS_U32 i;
	
	if ( Address & 3 ) {
		printf("ERROR: Address shall be aligned to 4.\n");
		return;
	}
	
	for (i=0; i<cnt; i+=4) {
		if ( !(i%16) ) 
			printf("\n%08lX  ", Address+i);
		
		printf("%08lX ", *(DS_U32 *)(Address+i));
	}
	
	printf("\n");
}

DS_U32 DHL_SYS_PrintFreeMem(const char *pfunc, int line)
{
	DS_U32 totalMem, usedMem, freeMem, buffer, cached;
	
	if ( DHL_SYS_GetSysinfo( &totalMem, &usedMem, &freeMem, &buffer, &cached ) == DHL_OK ) {
		DHL_DbgPrintf(0,DHLDBG_SYS,"|%s:%d| TotalMem: %ld K, UsedMem: %ld K, FreeMem: %ld K\n", pfunc ? pfunc : "Unknown", line, totalMem, usedMem, freeMem+buffer+cached);
		DHL_DbgPrintf(0,DHLDBG_SYS, "|%s:%d| FreeMemory: %ld K  (Free:%ld K + Buffer:%ld K + Cached:%ld K)\n", pfunc ? pfunc : "Unknown", line, freeMem+buffer+cached, freeMem, buffer, cached);
		
		return (freeMem+buffer+cached);
	} else {
		return -1;
	}
}

static char sysinfoBuffer[1024];
static int GetMemoryParam(char *iStream, const char *FindString, DS_U32 *pValue)
{
	int ret = 0;
	int n;
	char *ptr;
	
	ptr = strstr(iStream, FindString);
	if ( !ptr ) {
		DHL_DbgPrintf(0,DHLDBG_SYS, "ERROR: cannot find \"Mem:\" string from /proc/meminfo\n");
		ret = -1;
		goto done;
	}

	ptr += strlen(FindString);
	n=sscanf(ptr, "%ld", pValue);
	if ( n != 1 ) {
		DHL_DbgPrintf(0,DHLDBG_SYS, "ERROR: cannot get inform from /proc/meminfo.\n");
		ret = -1;
		goto done;
	}

done:
	return ret;
}

DHL_RESULT DHL_SYS_GetSysinfo(DS_U32 *pTotalMem, DS_U32 *pUsedMem, DS_U32 *pFreeMem, DS_U32 *pBuffer, DS_U32 *pCached)
{
	int fd = -1;
	int n;
	DHL_RESULT dhlResult = DHL_OK;
	DS_U32 totalMem, usedMem, freeMem, shared, buffer, cached;
//	char *ptr;
	
	fd = open("/proc/meminfo", S_IRUSR | S_IRGRP | S_IROTH );
	if ( fd < 0 ) {
		DHL_DbgPrintf(0,DHLDBG_SYS, "ERROR: cannot open /proc/meminfo\n");
		dhlResult = DHL_FAIL;
		goto done2;
	}
	
	n = read(fd, sysinfoBuffer, 1024);
	if ( n <= 0 ) {
		DHL_DbgPrintf(0,DHLDBG_SYS, "ERROR: cannot read from /proc/meminfo\n");
		dhlResult = DHL_FAIL;
		goto done;
	}

	totalMem=usedMem=freeMem=shared=buffer=cached=0;
#if 0	
	ptr = strstr(sysinfoBuffer, "Mem:");
	if ( !ptr ) {
		DHL_DbgPrintf(0,DHLDBG_SYS, "ERROR: cannot find \"Mem:\" string from /proc/meminfo\n");
		dhlResult = DHL_FAIL;
		goto done;
	}
	
	ptr += strlen("Mem:");
	n=sscanf(ptr, "%ld%ld%ld%ld%ld%ld", &totalMem, &usedMem, &freeMem, &shared, &buffer, &cached);
	if ( n != 6 ) {
		DHL_DbgPrintf(0,DHLDBG_SYS, "ERROR: cannot get inform from /proc/meminfo.\n");
		dhlResult = DHL_FAIL;
		goto done;
	}
#else
	n=GetMemoryParam(sysinfoBuffer, "MemTotal:", &totalMem);
	if ( n<0) {
		DHL_DbgPrintf(0,DHLDBG_SYS, "ERROR: cannot get MemTotal from /proc/meminfo.\n");
		dhlResult = DHL_FAIL;
		goto done;
	}

	n=GetMemoryParam(sysinfoBuffer, "MemFree:", &freeMem);
	if ( n<0) {
		DHL_DbgPrintf(0,DHLDBG_SYS, "ERROR: cannot get MemFree from /proc/meminfo.\n");
		dhlResult = DHL_FAIL;
		goto done;
	}

	n=GetMemoryParam(sysinfoBuffer, "Buffers:", &buffer);
	if ( n<0) {
		DHL_DbgPrintf(0,DHLDBG_SYS, "ERROR: cannot get Buffers from /proc/meminfo.\n");
		dhlResult = DHL_FAIL;
		goto done;
	}

	n=GetMemoryParam(sysinfoBuffer, "Cached:", &cached);
	if ( n<0) {
		DHL_DbgPrintf(0,DHLDBG_SYS, "ERROR: cannot get Cached from /proc/meminfo.\n");
		dhlResult = DHL_FAIL;
		goto done;
	}

	usedMem = totalMem - freeMem - buffer - cached;
#endif
	
	if (pTotalMem) *pTotalMem = totalMem;
	if (pUsedMem) *pUsedMem = usedMem;
	if (pFreeMem) *pFreeMem = freeMem;
	if (pBuffer) *pBuffer = buffer;
	if (pCached) *pCached = cached;

done:
	close(fd);
	
done2:
	return dhlResult;
}

#if 0
___Small_Commands___()
#endif
void rr(DS_U32 Address)
{
	if ( (Address & 3) || Address < 0xA0000000 || Address > 0xBFFFFFFF ) {
		printf("Invalid address: 0x%08lX\n", Address);
		return;
	}
	
	printf("0x%08lX: %08lX\n", Address, DHL_SYS_ReadRegister( Address ) );
}

void rw(DS_U32 Address, DS_U32 Value)
{
	if ( (Address & 3) || Address < 0xA0000000 || Address > 0xBFFFFFFF ) {
		printf("Invalid address: 0x%08lX\n", Address);
		return;
	}
	
	printf("[Before] 0x%08lX: %08lX\n", Address, DHL_SYS_ReadRegister( Address ) );
	DHL_SYS_WriteRegister( Address, Value );
	printf("[After ] 0x%08lX: %08lX\n", Address, DHL_SYS_ReadRegister( Address ) );
}


void rrw(DS_U32 Address)
{
	if ( (Address & 1) || Address < 0xA0000000 || Address > 0xBFFFFFFF ) {
		printf("Invalid address: 0x%08lX\n", Address);
		return;
	}
	
	printf("0x%08lX: %08lX\n", Address, OS_ReadRegisterWord( Address ) );
}

void rww(DS_U32 Address, DS_U32 Value)
{
	if ( (Address & 1) || Address < 0xA0000000 || Address > 0xBFFFFFFF ) {
		printf("Invalid address: 0x%08lX\n", Address);
		return;
	}
	
	printf("[Before] 0x%08lX: %08lX\n", Address, OS_ReadRegisterWord( Address ) );
	OS_WriteRegisterWord( Address, Value );
	printf("[After ] 0x%08lX: %08lX\n", Address, OS_ReadRegisterWord( Address ) );
}


void rrb(DS_U32 Address)
{
	if ( Address < 0xA0000000 || Address > 0xBFFFFFFF ) {
		printf("Invalid address: 0x%08lX\n", Address);
		return;
	}
	
	printf("0x%08lX: %08lX\n", Address, OS_ReadRegisterByte( Address ) );
}

void rwb(DS_U32 Address, DS_U32 Value)
{
	if ( Address < 0xA0000000 || Address > 0xBFFFFFFF ) {
		printf("Invalid address: 0x%08lX\n", Address);
		return;
	}
	
	printf("[Before] 0x%08lX: %08lX\n", Address, OS_ReadRegisterByte( Address ) );
	OS_WriteRegisterByte( Address, Value );
	printf("[After ] 0x%08lX: %08lX\n", Address, OS_ReadRegisterByte( Address ) );
}

void MallocAndFill(int size)
{
	char *ptr;
	int i;
	
	ptr = malloc(size);
	for (i=0; i<size; i++)
		ptr[i] = (char)i;
		
	printf("Malloc at 0x%08lX, size=%d\n", (unsigned long)ptr, size);
}

void Fill(int addr, int data, int size)
{
	char *ptr;
	int i;
	
	ptr = (char *)addr;
	for (i=0; i<size; i++)
		ptr[i] = (char)data;
		
	printf("Fill at 0x%08lX, size=%d\n", (unsigned long)ptr, size);
}

void RegFill(int addr, int data, int size)
{
	int i;

	for (i=0; i<size; i+=4)
		DD_SYS_SetRegister32( addr+i, data );
		
	printf("Fill at 0x%08lX, size=%d\n", (unsigned long)addr, size);
}

void Fill32(int addr, int data, int size)
{
	DS_U32 *ptr;
	int i;
	
	ptr = (DS_U32 *)addr;
	for (i=0; i<size; i++)
		ptr[i] = (DS_U32)data;
		
	printf("Fill at 0x%08lX, size=%d\n", (unsigned long)ptr, size);
}

void dumpFreeMemory(void)
{
	system("cat /proc/meminfo");
}

void hdumpver(void)
{
	DHL_SYS_DumpVersion();
}

void get_i2c(int bus, int addr, int subAddr)
{
	int n=0;
	unsigned char buf[256];
	
	n = DHL_SYS_I2cReadEx(bus, addr, 1, subAddr, buf, 2);
	if ( n <= 0 ) {
		printf("|%s| ERROR, LINE=%d\n", __FUNCTION__, __LINE__);
	}
	
	printf("I2C-BUS%d: DEVADDR[0x%02X] ADDR[0x%02X] => 0x%02X-0x%02X\n", bus, addr, subAddr, buf[0], buf[1]);
}

void get_i2c_byte(int bus, int addr, int subAddr)
{
	int n=0;
	unsigned char buf[256];
	
	n = DHL_SYS_I2cReadEx(bus, addr, 1, subAddr, buf, 1);
	if ( n <= 0 ) {
		printf("|%s| ERROR, LINE=%d\n", __FUNCTION__, __LINE__);
	}
	
	printf("I2C-BUS%d: DEVADDR[0x%02X] ADDR[0x%02X] => 0x%02X\n", bus, addr, subAddr, buf[0]);
}

void write_i2c_byte(int bus, int addr, int subAddr, int data)
{
	int n=0;
	unsigned char buf[256];
	
	buf[0] = data;
	n = DHL_SYS_I2cWriteEx(bus, addr, 1, subAddr, buf, 1);
	if ( n <= 0 ) {
		printf("|%s| ERROR, LINE=%d\n", __FUNCTION__, __LINE__);
	}
	
	printf("I2C-BUS%d: DEVADDR[0x%02X] ADDR[0x%02X] <= 0x%02X\n", bus, addr, subAddr, buf[0]);
}

void ifconfig(int x, int y, int z, int w)
{
	char buf[256];
	
	sprintf(buf, "ifconfig eth0 %d.%d.%d.%d\n", x, y, z, w);
	system(buf);
}

void shcmd(void)
{
	system("/bin/busybox sh");
}

static int bIdleStart = 0;
typedef void (cbFunc_t)(DS_U32 tick);
static cbFunc_t *cbTickFunc = (cbFunc_t *)0;

void tIdleTask(DS_U32 arg)
{
	volatile DS_U32 oldTick=0, elapsedTick;
	register int loop_cnt;
	static int cnt;
	
	loop_cnt = 0;
	while (1) {
		if (bIdleStart == 0) {
			break;
		}
#if 1
		elapsedTick = OS_GetTickCount()-oldTick;
		if ( elapsedTick > 100 && OS_GetTickCount() != oldTick ) {
			oldTick = OS_GetTickCount();
			printf("|%ld.%02ld| Counts per sec: %ld\n", oldTick/100, oldTick%100, (cnt * 100)/elapsedTick );
			cnt = 0;

			DHL_SYS_PrintFreeMem(0, 0);
			
			if ( cbTickFunc )
				cbTickFunc(oldTick);
			//if ( loop_cnt++ > 1000 )
				//break;
		}
#else
		oldTick = OS_GetTickCount();
		for(i=0; i<arg; i++)
			;
		curTick = OS_GetTickCount();
		elapsedTick = curTick-oldTick;
		if (elapsedTick<0) {
			printf("ElapsedTick: %d (%ld-%ld)\n", elapsedTick, curTick, oldTick);
			printf("Prev TV: %ld.%ld, Cur TV:%ld.%ld\n", prevTv.tv_sec, prevTv.tv_usec, curTv.tv_sec, curTv.tv_usec);
		}
#endif
		cnt++;
	}
	printf("|%s| IDLE task terminated.\n", __FUNCTION__);
	
	OS_DeleteTask(0);
}

void start_idle_task(int prio, int arg)
{
	printf("Start IDLE task with prio=%d, arg=%d\n", prio, arg);
	
	bIdleStart = 1;
	OS_SpawnTask( tIdleTask, "tAgingTask", prio, 4096, (DS_U32)arg); 
}

void set_tick_cbfunc(cbFunc_t *cbFunc)
{
	cbTickFunc = cbFunc;
}

void stop_idle_task(void)
{
	printf("Stop IDLE task.\n");
	
	bIdleStart = 0;
}

void print_pid()
{
    printf("PID: %d\n", (int)getpid());
}