/******************************************************************************
 *_Copyright (c) 2009 Digital Stream Technology Inc. All Rights Reserved.
 *
 * Module: dstdd
 *
 * Description
 *
 * @author 
 * @version $Revision: 1.1 $
 *
 ******************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <getopt.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <string.h>
#include <unistd.h>
#ifndef USE_CYGWIN
#include <linux/types.h>
#include <linux/ioctl.h>
#endif

#include "dsthalcommon.h"
#include "dstddsys.h"
#include "dstddgpio.h"
#include "dstddcap.h"
#include "dstdddtv.h"

/******************************************************************************
 * Global variable declaration
 ******************************************************************************/

/******************************************************************************
 * Imported variable declaration
 ******************************************************************************/
extern int gdhlSysDbgLvl;

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

/******************************************************************************
 * Local definitions
 ******************************************************************************/

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

/******************************************************************************
 * Local variables declaration
 ******************************************************************************/
static int s_DebugMode;
static int MAX_GPIO_NUM;
static GPIO_DESC_t *pGPIOConfig;
static GPIO_DESC_t GPIOConfig_R0_1[] = {
	/*	GPIO_NAME			"strPinName"		iPinGroup	iPinNum		iPinDirection	iPinReset */
	{ GPIO_WI_SDI,			"WI_SDI",			GPIO_31_0,	0,			GPIO_INPUT,		2		},
	{ GPIO_WI_SCLK,         "WI_SCLK",          GPIO_31_0,	1,			GPIO_OUTPUT,	2   },
	{ GPIO_WI_SSB,          "WI_SSB",           GPIO_31_0,	2,			GPIO_OUTPUT,	2   },
	{ GPIO_WI_SDO,          "WI_SDO",           GPIO_31_0,	3,			GPIO_OUTPUT,	2   },
	{ GPIO_HW_BIT0,         "HW_BIT0",          GPIO_31_0,	4,			GPIO_INPUT,		2   },
	{ GPIO_HW_BIT1,         "HW_BIT1",          GPIO_31_0,	5,			GPIO_INPUT,		2   },
	{ GPIO_HW_BIT2,		    "HW_BIT2",       	GPIO_31_0,	6,			GPIO_INPUT,		2   },
	{ GPIO_NAND_RDY,        "NAND_RDY",         GPIO_31_0,	7,			GPIO_PWMOUT,	2   },
	{ GPIO_1024_DK,       	"1024_DK",        	GPIO_31_0,	8,			GPIO_OUTPUT,	0   },
	{ GPIO_1024_OE,  		"1024_OE",		 	GPIO_31_0,	9,			GPIO_OUTPUT,	1   },
	{ GPIO_HDMI_TX_RESET,   "HDMI_TX_RESET",    GPIO_31_0,	10,			GPIO_OUTPUT,	1   },
	{ GPIO_HDMI_TX_INT,     "HDMI_TX_INT",      GPIO_31_0,	11,			GPIO_INPUT,		2   },
	{ GPIO_DEMOD_RESETN,    "DEMOD_RESETN",     GPIO_31_0,	12,			GPIO_OUTPUT,	0   },
	{ GPIO_AP_RESETN,       "AP_RESETN",        GPIO_31_0,	13,			GPIO_OUTPUT,	0   },
	{ GPIO_MICOM_INT,       "MICOM_INT",        GPIO_31_0,	14,			GPIO_INPUT,		2   },
	{ GPIO_HDMI_SW_EQ,      "HDMI_SW_EQ",       GPIO_31_0,	15,			GPIO_OUTPUT,	1   },
	{ GPIO_HDMI_S1,		    "HDMI_S1",     	 	GPIO_31_0,	16,			GPIO_OUTPUT,	1   },
	{ GPIO_HDMI_S2,        	"HDMI_S2",         	GPIO_31_0,	17,			GPIO_OUTPUT,	0   },
	{ GPIO_HDMI_HPD,    	"HDMI_HPD",    		GPIO_31_0,	18,			GPIO_OUTPUT,	0   },
	{ GPIO_SPDIF_SEL,       "SPDIF_SEL",        GPIO_31_0,	19,			GPIO_OUTPUT,	1   },
	{ GPIO_EDID_WR_EN,      "EDID_WR_EN",       GPIO_31_0,	20,			GPIO_OUTPUT,	0   },
	{ GPIO_1024_MODE,      	"GPIO_1024_MODE",  	GPIO_31_0,	21,			GPIO_OUTPUT,	0   },
	{ GPIO_CEC_ON,          "GPIO_CEC_ON",  	GPIO_31_0,	22,			GPIO_INPUT,		2   },
};

/******************************************************************************
 * Local function prototypes
 ******************************************************************************/
DHL_RESULT DD_SYS_InitGPIO(void);

#if 0
___Common_Functions___()
#endif
DHL_RESULT DD_SYS_Initiate(void)
{
	DHL_RESULT dhlResult = DHL_OK;


	//
	// GPIO_SELECT and check HW_BIT
	//
	
    pGPIOConfig = GPIOConfig_R0_1;

	return dhlResult;
}

DHL_RESULT DD_SYS_CheckDevice(void)
{
	return DHL_OK;
}

DHL_RESULT DD_SYS_Terminate(void)
{
	DHL_RESULT dhlResult = DHL_OK;
	
	exit(0);

    SysNEVER_GET_HERE();
	return dhlResult;
}

DHL_RESULT DD_SYS_SetDbgLvl(DS_U32 uDbgLvl)
{
	DHL_RESULT dhlResult = DHL_OK;
	
	return dhlResult;
}

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

DHL_RESULT DD_SYS_SetPWM(int Period, int Duty)
{
	DHL_RESULT dhlResult = DHL_OK;

	return dhlResult;
}

DHL_RESULT DD_SYS_SetADIM(DS_U16 Period)
{
	DHL_RESULT dhlResult = DHL_OK;
	
	return dhlResult;
}

DS_U32 DD_SYS_GetLoaderVer(void)
{
	return OS_GetLoaderVer();
}

DS_U32 DD_SYS_GetDrvVenVersion(void)
{
    /*
     * Shall return Vendor-supplied driver version.
     */

	return 0;
}

DS_U32 DD_SYS_GetDrvDstVersion(void)
{
    /*
     * Shall return DST Tag Number for vendor-supplied driver.
     */
     
	return 0;
}

DHL_RESULT DD_SYS_IsUsbValid(void)
{
	static DHL_RESULT dhlResult = DHL_FAIL;

	return dhlResult;
}

DHL_RESULT DD_SYS_InitGPIO(void)
{
	DHL_RESULT dhlResult = DHL_OK;
	int i;
	
	for (i=0; i<MAX_GPIO_NUM; i++)
	{
		if ( pGPIOConfig[i].iPinDirection == GPIO_OUTPUT && pGPIOConfig[i].iPinReset != 2 ) 
		{
		    /*
		     * Do apply reset value on the Output GPIO.
		     */
		     
		}
		
		switch( pGPIOConfig[i].iPinDirection ) {
			case GPIO_INPUT:  break;
			case GPIO_OUTPUT: break;
			case GPIO_PWMOUT: break;
			default:
				printf("|%s| ERROR: Invalid GPIO mode. LINE=%d (i=%d)\n", __FUNCTION__, __LINE__, i);
				return DHL_FAIL;
		}
		
		/*
		 * Change GPIO direction be pGPIOConfig[i].iPinDirection.
		 */
		 
	}
			
	return dhlResult;
}

DHL_RESULT DD_SYS_SetGPIO( int GpioNum, int Value )
{
	DHL_RESULT dhlResult = DHL_OK;
	int i;

	if ( GpioNum < 0 /*|| GpioNum > (MAX_GPIO_NUM+1)*/ ) {
		DHL_DbgPrintf(gdhlSysDbgLvl,DHLDBG_SYS, "Invalid GPIO Number: tried num=0x%x\n", GpioNum );
		Value = -1;
		goto done;
	}

    /*
     * Find GPIO entry in GPIO Table.
     */
    for (i=0; i<MAX_GPIO_NUM; i++) 
    {
        if ( pGPIOConfig[i].iGpioName == GpioNum )
            break;
    }
    
    if ( i == MAX_GPIO_NUM ) {
        printf("Invalid GPIO Number: tried num=%d\n", GpioNum);
        dhlResult = DHL_FAIL;
        goto done;
    }

    /*
     * Save last value into pGPIOConfig[i].iPinReset field.
     */
    pGPIOConfig[i].iPinReset = Value;

    /*
     * Make Output GPIO be high or low based on the Value argument.
     */
    
done:
	return dhlResult;
}

DHL_RESULT DD_SYS_SetGPIODefault( int GpioNum )
{
    DHL_RESULT dhlResult = DHL_OK;
    int i;
    
	if ( GpioNum < 0 /*|| GpioNum > (MAX_GPIO_NUM+1)*/ ) 
	{
		DHL_DbgPrintf(gdhlSysDbgLvl,DHLDBG_SYS, "Invalid GPIO Number: tried num=0x%x\n", GpioNum );
		goto done;
	}

    /*
     * Find GPIO entry in GPIO Table.
     */
    for (i=0; i<MAX_GPIO_NUM; i++) 
    {
        if ( pGPIOConfig[i].iGpioName == GpioNum )
            break;
    }
    
    if ( i == MAX_GPIO_NUM ) 
    {
        printf("Invalid GPIO Number: tried num=%d\n", GpioNum);
        dhlResult = DHL_FAIL;
        goto done;
    }
    
    DD_SYS_SetGPIO( GpioNum, pGPIOConfig[i].iPinReset );
    
done:
    return dhlResult;
}

int DD_SYS_GetGPIO( int GpioNum )
{
	unsigned char v=0;
	int i;
	
    /*
     * Find GPIO entry in GPIO Table.
     */
    for (i=0; i<MAX_GPIO_NUM; i++) 
    {
        if ( pGPIOConfig[i].iGpioName == GpioNum )
            break;
    }

    if ( i == MAX_GPIO_NUM ) 
    {
        printf("Invalid GPIO Number: tried num=%d\n", GpioNum);
        return -1;
    }
    
    /*
     * Get current value from INPUT-GPIO.
     */

	return (int)v;
}

int DD_SYS_GetGPIOOut(int GpioNum)
{
	int i;
	int Value = 0;
	
    /*
     * Find GPIO entry in GPIO Table.
     */
    for (i=0; i<MAX_GPIO_NUM; i++) 
    {
        if ( pGPIOConfig[i].iGpioName == GpioNum )
            break;
    }

    if ( i == MAX_GPIO_NUM ) 
    {
        printf("Invalid GPIO Number: tried num=%d\n", GpioNum);
        return DHL_FAIL;
    }

    /*
     * Get current value from OUTPUT-GPIO.
     * This is to get the value from Open-Drain output GPIO.
     */

	return Value;
}

char *DD_SYS_GetGPIOName( int GpioNum )
{
	int i;
	char *ptr;

	if ( GpioNum < 0 || GpioNum > (GPIO_MAX) ) 
	{
		DHL_DbgPrintf(gdhlSysDbgLvl,DHLDBG_SYS, "Invalid GPIO Number: tried num=0x%x\n", GpioNum );
		return (char *)0;
	}

    /*
     * Find GPIO entry in GPIO Table.
     */
    for (i=0; i<MAX_GPIO_NUM; i++) 
    {
        if ( pGPIOConfig[i].iGpioName == GpioNum )
            break;
    }

    if ( i == MAX_GPIO_NUM ) {
        printf("Invalid GPIO Number: tried num=%d\n", GpioNum);
        return (char *)0;
    }

	ptr = pGPIOConfig[i].strPinName;	
	return ptr;
}

int DD_SYS_FindGPIONum( const char *gpioName )
{
	int i;
	
	if ( !gpioName ) {
		DHL_DbgPrintf(gdhlSysDbgLvl,DHLDBG_SYS, "ERROR: argument is null pointer.\n");
		return -1;
	}
	
	for (i=0; i<MAX_GPIO_NUM; i++) {
		if ( strncmp( gpioName, pGPIOConfig[i].strPinName, strlen(gpioName) ) == 0 )
			break;
	}
	
	if ( i==MAX_GPIO_NUM )
		return -1;
		
	return i;
}

void *DD_SYS_PhyMemAlloc(int size)
{
	return malloc(size);
}

void DD_SYS_PhyMemFree(void *addr)
{
	free(addr);
}

void DD_SYS_SetDebugMode(int bOnOff)
{
	s_DebugMode = bOnOff;
}

int DD_SYS_IsDebugMode(void)
{
	return s_DebugMode;
}

void hdumpgpio(void)
{
	int i;

	printf( "|Idx|       Name      |Pin#| DIR |ResetValue|\n");
	for(i=GPIO_MIN; i<=GPIO_MAX; i++) 
	{
	    if ( DD_SYS_GetGPIOName(i) == (char *)0 )
	        continue;
		printf( "|%3d| %-15s | %2d | %-3s |         %d|\n", i, DD_SYS_GetGPIOName(i), pGPIOConfig[i].iPinNum, pGPIOConfig[i].iPinDirection == GPIO_PWMOUT ? "PWM" : pGPIOConfig[i].iPinDirection == GPIO_OUTPUT ? "OUT" : "IN", pGPIOConfig[i].iPinReset);
    }
}

static int isI2cM_Init = 0;
int DD_SYS_I2cInit(void)
{
	int ret = 0;
	
	if ( isI2cM_Init == 1 ) 
	{
	    printf("|%s| This function is called twice or more.\n", __FUNCTION__);
		return ret;
	}

    /*
     * Call the vendor-supplied I2C initialization driver APIs here.
     */
    
    
	isI2cM_Init = 1; 
	
	return ret;
}

int DD_SYS_I2cWrite(int i2cBus, unsigned char addr, int nSubAddress, int subAddress, unsigned char *buf, int len)
{
	unsigned char sub[4];
	int ret;
	
	if ( isI2cM_Init == 0 ) 
	{
		ret = DD_SYS_I2cInit();
		if ( ret < 0 )
			return -1;
	}
	
	if ( i2cBus != 0 && i2cBus != 1 ) 
	{
		printf("|%s| INVALID PARAM, i2cBus = %d\n", __FUNCTION__, i2cBus);
		return -1;
	}

    switch (nSubAddress)
    {
        case 0:
            /* Without SubAddress */
            break;
        
        case 1:
            /* 8-bit SubAddress */
            sub[0] = subAddress & 0xFF;
            break;
        
        case 2:
            /* 16-bit SubAddress */
            sub[0] = subAddress & 0xFF;
            sub[1] = (subAddress>>8) & 0xFF;
            break;
        
        case 3:
            /* 24-bit SubAddress */
            sub[0] = subAddress & 0xFF;
            sub[1] = (subAddress>>8) & 0xFF;
            sub[2] = (subAddress>>16) & 0xFF;
            break;
        
        default:
            break;
    }
	
	/*
	 * Call the lower I2C drivers.
	 */
	ret = len;
	
	return ret;
}

int DD_SYS_I2cRead(int i2cBus, unsigned char addr, int isSubAddress, int subAddress, unsigned char *buf, int len)
{
	//unsigned char sub[4];
	int ret = 0;
	
	if ( isI2cM_Init == 0 ) 
	{
		ret = DD_SYS_I2cInit();
		if ( ret < 0 )
			return -1;
	}
	
	if ( i2cBus != 0 && i2cBus != 1 ) 
	{
		printf("|%s| INVALID PARAM, i2cBus = %d\n", __FUNCTION__, i2cBus);
		return -1;
	}
	
	/*
	 * Call the lower I2C drivers.
	 */
	ret = len;
	
    return ret;
}

DHL_RESULT DD_SYS_SetI2CSpeed(unsigned char bus, unsigned int speed)
{
	DHL_RESULT dhlResult = DHL_OK;
	
	if ( bus != 0 && bus != 1 ) {
		printf("|%s| INVALID PARAM, i2cBus = %d\n", __FUNCTION__, bus);
		return -1;
	}
	
	/*
	 * Call the lower I2C drivers.
	 */
	
	return dhlResult;
}

char *DD_SYS_GetSystemErrorCode(DS_U8 ErrCode)
{
	return "NOT_IMPLEMENTED";
}

void DD_SYS_SetRegister8(DS_U32 Addr, DS_U8 Value)
{
	OS_WriteRegisterByte(Addr, Value);
}

void DD_SYS_SetRegister16(DS_U32 Addr, DS_U16 Value)
{
	DS_U32 regAddr;
	
	if ( Addr & 1 ) 
	{
		printf("|%s| Address is not aligned: 0x%08lX\n", __FUNCTION__, Addr );
		return;
	}

    regAddr = Addr;
    
	OS_WriteRegisterWord(regAddr, Value);
}

void DD_SYS_SetRegister32(DS_U32 Addr, DS_U32 Value)
{
	DS_U32 regAddr = Addr;
	
	if ( Addr & 3 ) 
	{
		printf("|%s| Address is not aligned: 0x%08lX\n", __FUNCTION__, Addr );
		return;
	}

	OS_WriteRegister(regAddr, Value);
}

DS_U8 DD_SYS_GetRegister8(DS_U32 Addr)
{
	return OS_ReadRegisterByte(Addr);
}

DS_U16 DD_SYS_GetRegister16(DS_U32 Addr)
{
	DS_U32 regAddr;
	
	if ( Addr & 1 ) 
	{
		printf("|%s| Address is not aligned: 0x%08lX\n", __FUNCTION__, Addr );
		return (DS_U16)-1;
	}

#if 0
	regAddr = Addr & (~2);
	regAddr += (~(Addr & 2)) & 2;
#else
    regAddr = Addr;
#endif

	return OS_ReadRegisterWord(regAddr);
}

DS_U32 DD_SYS_GetRegister32(DS_U32 Addr)
{
	DS_U32 regAddr = Addr;
	
	if ( Addr & 3 ) 
	{
		printf("|%s| Address is not aligned: 0x%08lX\n", __FUNCTION__, Addr );
		return (DS_U32)-1;
	}

	return OS_ReadRegister(regAddr);
}

typedef struct tagTaskStruct {
	int pid;
	char comm[16];
	char state;
	int ppid, pgrp, session;
	int flags;
	unsigned int esp, eip; 
	int priority;
} TaskStruct;

TaskStruct task;
static char stat_buffer[256];
int print_stat(int pid)
{
	int fd;
	char pathname[256];
	int n;
	int dummy;
	
	sprintf(pathname, "/proc/%d/stat", pid);
	fd = open(pathname, O_RDONLY);
	if ( fd < 0 ) {
		printf("ERROR: open() = -1\n");
		return -1;
	}
	
	n = read(fd, stat_buffer, 256);
	if ( n <= 0 )
		return -1;
	
	
	
	
	
	sscanf(stat_buffer,"%d %s %c %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d\n", 
		&task.pid,
		task.comm,
		&task.state,
		&task.ppid,
		&task.pgrp,
		&dummy,
		&dummy,
		&dummy,
		&dummy,
		&dummy,
		&dummy,
		&dummy,
		&dummy,
		&dummy,
		&dummy,
		&dummy,
		&dummy,
		&task.priority,
		&dummy,
		&dummy,
		&dummy,
		&dummy,
		&dummy,
		&dummy,
		&dummy,
		&dummy,
		&dummy,
		&dummy,
		&task.esp,
		&task.eip,
		&dummy,
		&dummy,
		&dummy,
		&dummy,
		&dummy,
		&dummy,
		&dummy,
		&dummy,
		&dummy);

	printf("Task: %s (%d) (%c), Priority:%d, SP:0x%08lX, IP:0x%08lX, PPID: %d\n", task.comm, task.pid, task.state, task.priority, (unsigned long)task.esp, (unsigned long)task.eip, task.ppid);

	return 0;
}