#include "osdef.h" //joshua check
#include "pq.h"
#include "pq_hw.h"
#include "pq_ioctl.h"
#include <linux/version.h>
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35)
#include <drv_dev.h>
#include <drv_platform.h>
#endif
#include "drv_types.h"


//PQ_CONTEXT PQContext;

extern UINT8 utempSharpnesscValue;

#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,0,8)
LONG sispq_ioctl(struct file *filp,UINT32 cmd,ULONG arg);
#else
ssize_t sispq_ioctl(struct inode *inode,struct file *filp,UINT32 cmd,ULONG arg);
#endif
INT32 sispq_init(void);
void sispq_exit(void);


static struct file_operations fops = {

#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,0,8)
	unlocked_ioctl: sispq_ioctl,
#else
	ioctl:		sispq_ioctl,
#endif
	owner:		THIS_MODULE,
};


static struct cdev cdev_sispq = {
	.kobj    = {.name = "sispq", },
	.owner  = THIS_MODULE,
	.ops      = &fops,
};





void PQ_Initialization(void)
{

	PQ_InitialTable();

}



#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,0,8)
LONG sispq_ioctl(struct file *filp,UINT32 cmd,ULONG arg){
#else
ssize_t sispq_ioctl(struct inode *inode,struct file *filp,UINT32 cmd,ULONG arg){
#endif



	switch(cmd){
#ifdef DYNAMIC_BACKLIGHT
		case PQ_IOCTL_SWITCH_DYNAMIC_BACKLIGHT:
			{
        			PQ_DynamicBacklight DynamicBacklight;
        			copy_from_user(&DynamicBacklight, (PQ_DynamicBacklight*)arg, sizeof(PQ_DynamicBacklight));
        			PQ_EnableDynamicBackLight(DynamicBacklight.ucLevel, DynamicBacklight.uiBacklightValue);
			}
			break;
		case PQ_IOCTL_SWITCH_DYNAMIC_BACKLIGHT_MAP:
			{
        			PQ_DynamicBacklight DynamicBacklight;
        			copy_from_user(&DynamicBacklight, (PQ_DynamicBacklight*)arg, sizeof(PQ_DynamicBacklight));
        			PQ_DynamicBackLightAP(DynamicBacklight.ucLevel, DynamicBacklight.uiBacklightValue);
			}
			break;
		case PQ_IOCTL_DYNCBACKLIGHT:
			{
				PQ_BacklightParameter BackLightPara;
				copy_from_user(&BackLightPara, (PQ_BacklightParameter*)arg, sizeof(PQ_BacklightParameter));
				PQ_SetBacklightParameter(BackLightPara.ucTop,BackLightPara.ucBot,BackLightPara.ucTh_low,BackLightPara.ucTh_High);
			}
			break;
#endif
        case PQ_IOCTL_FADE_IN_OUT:
            {
                PQ_FadeInOut FadeInOut;
                copy_from_user(&FadeInOut, (PQ_FadeInOut*)arg, sizeof(PQ_FadeInOut));
                PQ_SetFadeValue(1, FadeInOut.ucStartValue, FadeInOut.ucEndValue, FadeInOut.ucIncValue);
            }
            break;
	}
	return 0;
}


PQ_EXPORT void PQ_WatchDemo_DynamicContrast_AvgY(INT32* demoMin, INT32* demoMax,INT32* demoCurValue)
{

}


void PQ_EventGammaPattern(UINT8 ucGrayLevel)
{
	PQ_GammaCorrect(ucGrayLevel);
}

PQ_EXPORT void PQ_ChangeBackLight(UINT32 dwLightTarget, INT32 nSpeed)
{
#ifdef DYNAMIC_BACKLIGHT
	PQ_KICDebugPrint("%s:dwLightTarget = %ld(%#lx), nSpeed = %d\n",__FUNCTION__, dwLightTarget, dwLightTarget, nSpeed);
	dwLightTarget &= ~(0x80000000); //clear the setting bit
	//PQ_GetOrderedBackLight(&dwLightTarget);
	PQ_PresetBackLight(TRUE, dwLightTarget, nSpeed);
#endif
}



PQ_EXPORT void PQ_SetColorStyleSaturation(UINT8 ucType)
{
	PQ_ColorStyleSaturation(ucType);
}

PQ_EXPORT void PQ_EventSetFunction(UINT8 ucFunID, INT32 iValue, INT32 iUserMin, INT32 iUserMax)
{
	UINT8 ucUserSource;
	UINT8 ucSubSource;
	INT32 iRealValue= iValue;

      VIP_GetSource(&ucUserSource, &ucSubSource);


	KICDebugPrint("%s 1: ucFunID=%d  iUserMin=%d iUserMax=%d iValue=%d iRealValue=%d\n",__FUNCTION__, ucFunID, iUserMin, iUserMax, iValue, iRealValue);
	KICDebugPrint("%s 2: ucFunID=%d  iUserMin=%d iUserMax=%d iValue=%d iRealValue=%d\n",__FUNCTION__, ucFunID, iUserMin, iUserMax, iValue, iRealValue);

	PQ_SetMenuValue(ucFunID,iRealValue);
	switch(ucFunID)
	{
		case PQ_BRIGHTNESS:
			PQ_Brightness(TRUE, iRealValue);
			break;
		case PQ_CONTRAST:
			if(PQ_IsFadeEn())
            {
                PQ_SetCurrContrastValue(iRealValue);
            }
            else
            {
			    PQ_Contrast(TRUE, iRealValue);
            }
			break;
		case PQ_SHARPNESS:
			utempSharpnesscValue = iRealValue;
			PQ_Sharpness(TRUE, iRealValue);
			break;
		case PQ_SATURATION:
			PQ_Saturation(iRealValue);
			break;
		case PQ_HUE:
			PQ_Hue(iRealValue);
			break;
		case PQ_CT_R_GAIN:	// color temp
			PQ_ColorTempGain(PQ_CT_GAIN_R, iRealValue);
			break;
		case PQ_CT_G_GAIN:
			PQ_ColorTempGain(PQ_CT_GAIN_G, iRealValue);
			break;
		case PQ_CT_B_GAIN:
			PQ_ColorTempGain(PQ_CT_GAIN_B, iRealValue);
			break;
		case PQ_CT_R_BIAS:
			PQ_ColorTempBias(PQ_CT_BIAS_R, iRealValue);
			break;
		case PQ_CT_G_BIAS:
			PQ_ColorTempBias(PQ_CT_BIAS_G, iRealValue);
			break;
		case PQ_CT_B_BIAS:
			PQ_ColorTempBias(PQ_CT_BIAS_B, iRealValue);
			break;
		case PQ_DIGITAL_NR:
            PQ_3DNoiseReductoin(iValue, iUserMin, iUserMax);
            PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNR);
            PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNR_SNR);
            PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNR_C);
            PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNRZ);
            PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNRZ_C);
            PQ_Set_NR_SLR_SNR(NR_SNR_BEFORE_SCALER);
            PQ_Set_NR_SLR_SNR(NR_SNR_AFTER_SCALER);
			break;
		case PQ_MPEG_NOISE_FILTER:
           PQ_MPEGNoiseReductoin(iValue, iUserMin, iUserMax);
			break;
		case PQ_GAMMA:
			/*
			if (iValue < 2)
				PQ_SetupGammaTable(ENABLE, iValue);
			else
				PQ_SetupGammaTable(DISABLE,iValue);
			*/
			break;
		case PQ_GAMMATABLE:
			
	#ifdef CONFIG_PANEL_LM201WE3_TLF5_1680X1050__S2TEK_IS_DEFAULT
	#else
			if( iValue==0xff )
				PQ_SetupGammaTable(DISABLE, 0xff);
			else
				PQ_SetupGammaTable(ENABLE, iValue);
	#endif
			break;
		case PQ_DYNAMIC_CONTRAST:
            break;
		case PQ_COLOR_SPACE_MODE:
			PQ_ColorSpaceMode(iValue, ucUserSource);
			break;
		case PQ_GAMMA_CORRECT:
			PQ_EventGammaPattern((UINT8)iValue);
			break;
		case PQ_SET_COLOR_PROCESSER:
			PQ_ColorProcesser(iValue);
			break;
		case PQ_DYNAMIC_BACKLIGHT:
#ifdef DYNAMIC_BACKLIGHT
			PQ_EnableDynamicBackLight(iValue, iUserMax);
#endif
			break;
		case PQ_DEMOMODE:
			//PQ_DemoModeEnable(iValue);
			PQ_DPYDemoModeEnable(iValue);
			break;
		case PQ_STATIC_GAMMA:
			PQ_StaticGammaSetup(iValue);
			break;
             case PQ_DITHERING:
                   PQ_SetDithering(iValue);
                   break;
		case PQ_DITHERING_LEVEL:
                   PQ_DitheringLevel(iValue);
			break;
            case PQ_DITHERING_ALGO:
                   PQ_DitheringAlgo(iValue);
                   break;
		case PQ_FLESHTONE_COMPENSATION:
			PQ_FlDetLevel(iValue);
			break;
		case PQ_ADAPTIVE_MAX_BACKLIGHT:
#ifdef DYNAMIC_BACKLIGHT
			PQ_KICDebugPrint("%s, PQ_LIGHT_SENSOR_BACKLIGHT: light sensor = %d, index = %d\n",__FUNCTION__,iValue,iUserMin);
			PQ_GetLightSensorInfo(iValue, iUserMin, iUserMax);
			break;
		case PQ_DYNAMIC_BACKLIGHT_TYPE:
			PQ_SetDynamicBLType(iValue);
			break;
		case PQ_DYNAMIC_BACKLIGHT_HISTMINRATE:
			PQ_SetBacklightHistMin(iValue);
			break;
		case PQ_DYNAMIC_BACKLIGHT_PWMMAX:
			PQ_SetMaxPWM(iValue);
			break;
#endif
		case PQ_DYNAMIC_CONTRAST_ENABLE:
			PQ_SW_DynamicContrast_Enable(iValue);
			break;
		case PQ_CONTRAST_LEVEL:
			PQ_SW_DynamicContrast_Y_Level(iValue);
			break;
		case PQ_CHROMA_LEVEL:
			PQ_SW_DynamicContrast_C_Level(iValue);
			break;
		case PQ_ALPHA_MODE1:
			PQ_SW_DynamicContrast_Alpha_Mode(0,iValue);
			break;
		case PQ_ALPHA_MODE2:
			PQ_SW_DynamicContrast_Alpha_Mode(1,iValue);
			break;
		case PQ_ALPHA_MODE3:
			PQ_SW_DynamicContrast_Alpha_Mode(2,iValue);
			break;
		case PQ_ALPHA_MODE4:
			PQ_SW_DynamicContrast_Alpha_Mode(3,iValue);
			break;
		case PQ_DVDSoruce:
			VIP_EventDVDSourceSelect(iValue);
			break;
		case PQ_PWMFREQ:
			PQ_SETPWMFreq(iValue);
			break;

		default:
			break;
	}
}

INT32 sispq_init(void)
{
    INT32 err, devno;
#ifndef LOGO_PROLONG
   PQ_Initialization();
#endif
    devno=MKDEV(CDEV_PQ_MAJOR,0);
    cdev_init(&cdev_sispq, &fops);
    cdev_sispq.owner = THIS_MODULE;
    cdev_sispq.ops = &fops;
    err = cdev_add (&cdev_sispq, devno, 1);
    if (err)
    {
    	PQDebugPrint( "Error");
    }

    return 0;
}

void sispq_exit(void)
{
    cdev_del(&cdev_sispq);
}

#ifndef INIT_BY_KMF
module_init(sispq_init);
module_exit(sispq_exit);
#endif

MODULE_LICENSE("Dual BSD/GPL");