[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / misc / mediatek / hdmi / Sii8348 / hdmi_drv.c

#if defined(CONFIG_MTK_HDMI_SUPPORT)
#include <linux/kernel.h>

#include <linux/xlog.h>

#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/delay.h>
#include <linux/kthread.h>

#include <mtk_kpd.h>        /* custom file */
#include "si_timing_defs.h"

#include "hdmi_drv.h"
#include "smartbook.h"

#include "hdmi_cust.h"
/**
* MHL TX Chip Driver User Layer Interface
*/
extern struct mhl_dev_context *si_dev_context;
extern void ForceSwitchToD3( struct mhl_dev_context *dev_context);
extern void	ForceNotSwitchToD3();
extern int si_mhl_tx_post_initialize(struct mhl_dev_context *dev_context, bool bootup);
extern void siHdmiTx_VideoSel (int vmode);
extern void siHdmiTx_AudioSel (int AduioMode);
extern void set_platform_bitwidth(int bitWidth);
extern bool si_mhl_tx_set_path_en_I(struct mhl_dev_context *dev_context);
extern bool packed_pixel_available(struct mhl_dev_context *dev_context);
extern void configure_and_send_audio_info(struct mhl_dev_context *dev_context, int audio_format);

//Should align to mhl_linux_tx.h
#define	MHL_TX_EVENT_DISCONNECTION	0x01
#define	MHL_TX_EVENT_CONNECTION		0x02
#define MHL_TX_EVENT_SMB_DATA		0x40
#define MHL_TX_EVENT_HPD_CLEAR 		0x41
#define MHL_TX_EVENT_HPD_GOT 		0x42
#define MHL_TX_EVENT_DEV_CAP_UPDATE 0x43
#define MHL_TX_EVENT_EDID_UPDATE 	0x44
#define MHL_TX_EVENT_EDID_DONE 		0x45
#define MHL_TX_EVENT_CALLBACK 		0x46

/**
* Platform Related Layer Interface
*/
extern int HalOpenI2cDevice(char const *DeviceName, char const *DriverName);
extern Mask_MHL_Intr(void);
extern Unmask_MHL_Intr(void);
extern int32_t sii_8348_tx_init(void);    //Should  move to MHL TX Chip user layer
/**
* LOG For MHL TX Chip HAL
*/
static size_t hdmi_log_on = true;
static int txInitFlag = 0;

#define HDMI_LOG(fmt, arg...)  \
	do { \
		if (hdmi_log_on) printk("[HDMI_Chip_HAL]%s,%d,", __func__, __LINE__); printk(fmt, ##arg); \
	}while (0)

#define HDMI_FUNC()    \
	do { \
		if(hdmi_log_on) printk("[HDMI_Chip_HAL] %s\n", __func__); \
	}while (0)

void hdmi_drv_log_enable(bool enable)
{
	hdmi_log_on = enable;
}

static int not_switch_to_d3 = 0;
static int audio_enable = 0;

void hdmi_drv_force_on(int from_uart_drv )
{
    HDMI_LOG("hdmi_drv_force_on %d\n", from_uart_drv);
    if(from_uart_drv == 0)
        ForceNotSwitchToD3();
    not_switch_to_d3 = 1;
//gpio:uart
    cust_hdmi_i2s_gpio_on(2);
}
 
/************************** Upper Layer To HAL*********************************/
static HDMI_UTIL_FUNCS hdmi_util = {0};
static void hdmi_drv_set_util_funcs(const HDMI_UTIL_FUNCS *util)
{
	memcpy(&hdmi_util, util, sizeof(HDMI_UTIL_FUNCS));
}

static char* cable_type_print(unsigned short type)
{
	switch(type)
	{
		case HDMI_CABLE:
			return "HDMI_CABLE";
		case MHL_CABLE:
			return "MHL_CABLE";
		case MHL_SMB_CABLE:
			return "MHL_SMB_CABLE";
		case MHL_2_CABLE:
			return "MHL_2_CABLE";
		default:
			HDMI_LOG("Unknow MHL Cable Type\n");
			return "Unknow MHL Cable Type\n";
	}	
}

static HDMI_CABLE_TYPE MHL_Connect_type = MHL_CABLE;
static bool HDCP_Supported_Info = false;
static void hdmi_drv_get_params(HDMI_PARAMS *params)
{
	memset(params, 0, sizeof(HDMI_PARAMS));
    params->init_config.vformat         = HDMI_VIDEO_1280x720p_60Hz;
    params->init_config.aformat         = HDMI_AUDIO_44K_2CH;

	params->clk_pol           			= HDMI_POLARITY_FALLING;
	params->de_pol            			= HDMI_POLARITY_RISING;
	params->vsync_pol         			= HDMI_POLARITY_RISING;
	params->hsync_pol        		    = HDMI_POLARITY_RISING;

	params->hsync_front_porch 			= 110;
	params->hsync_pulse_width 			= 40;
	params->hsync_back_porch  			= 220;

	params->vsync_front_porch 			= 5;
	params->vsync_pulse_width 			= 5;
	params->vsync_back_porch  			= 20;

	params->rgb_order         			= HDMI_COLOR_ORDER_RGB;

	params->io_driving_current 			= IO_DRIVING_CURRENT_2MA;
	params->intermediat_buffer_num 		= 4;
    params->scaling_factor 				= 0;
    params->cabletype 					= MHL_Connect_type;
	params->HDCPSupported 				= HDCP_Supported_Info;

    HDMI_LOG("type %s\n", cable_type_print(params->cabletype));
	return ;
}

void hdmi_drv_suspend(void) {return ;}
void hdmi_drv_resume(void)  {return ;}
static int hdmi_drv_audio_config(HDMI_AUDIO_FORMAT aformat, int bitWidth)
{
	set_platform_bitwidth(bitWidth);
	siHdmiTx_AudioSel(aformat);
	configure_and_send_audio_info(si_dev_context, aformat);
	
	return 0;
}
static int hdmi_drv_video_enable(bool enable) 
{
    return 0;
}

static int hdmi_drv_audio_enable(bool enable)  
{
    printk("[EXTD]Set_I2S_Pin, enable = %d\n", enable);            
    //gpio:uart
    if(not_switch_to_d3 == 1)
        cust_hdmi_i2s_gpio_on(2);
    else
        cust_hdmi_i2s_gpio_on(enable);

    audio_enable = enable;
    return 0;
}

static int hdmi_drv_enter(void)  {return 0;}
static int hdmi_drv_exit(void)  {return 0;}

static int hdmi_drv_video_config(HDMI_VIDEO_RESOLUTION vformat, HDMI_VIDEO_INPUT_FORMAT vin, HDMI_VIDEO_OUTPUT_FORMAT vout)
{
	if(vformat == HDMI_VIDEO_720x480p_60Hz)
	{
		HDMI_LOG("[hdmi_drv]480p\n");
		siHdmiTx_VideoSel(HDMI_480P60_4X3);
	}
	else if(vformat == HDMI_VIDEO_1280x720p_60Hz)
	{
		HDMI_LOG("[hdmi_drv]720p\n");
		siHdmiTx_VideoSel(HDMI_720P60);
	}
	else if(vformat == HDMI_VIDEO_1920x1080p_30Hz)
	{
		HDMI_LOG("[hdmi_drv]1080p_30 %p\n", si_dev_context);
		siHdmiTx_VideoSel(HDMI_1080P30);
	}
	else if(vformat == HDMI_VIDEO_1920x1080p_60Hz)
	{
		HDMI_LOG("[hdmi_drv]1080p_60 %p\n", si_dev_context);
		siHdmiTx_VideoSel(HDMI_1080P60);
	}
	else
	{
		HDMI_LOG("%s, video format not support now\n", __func__);
	}
	
    if(si_dev_context)
    	si_mhl_tx_set_path_en_I(si_dev_context);
    return 0;
}

static unsigned int sii_mhl_connected = 0;
static uint8_t ReadConnectionStatus(void)
{
    return (sii_mhl_connected == MHL_TX_EVENT_CALLBACK)? 1 : 0;
}
HDMI_STATE hdmi_drv_get_state(void)
{
	int ret = ReadConnectionStatus();
	HDMI_LOG("ret: %d\n", ret);
	
	if(ret == 1)
		return HDMI_STATE_ACTIVE;
	else
		return HDMI_STATE_NO_DEVICE;
}

bool chip_inited = false;
static int hdmi_drv_init(void)
{
    HDMI_LOG("hdmi_drv_init +\n" );

	Mask_MHL_Intr();
	cust_hdmi_power_on(true);
	if(not_switch_to_d3 == 0)
    {
        HalOpenI2cDevice("Sil_MHL", "sii8348drv");
	}
	
	txInitFlag = 0;
	chip_inited = false;
    HDMI_LOG("hdmi_drv_init -\n" );
    return 0;
}

//Should be enhanced
int	chip_device_id = 0;
bool need_reset_usb_switch = true;
int hdmi_drv_power_on(void)
{
    int ret = 1;
	HDMI_FUNC();

    if(not_switch_to_d3 > 0)
    {
        HDMI_LOG("hdmi_drv_power_on direct to exit for forceon(%d_\n", not_switch_to_d3 );
        return ;
    }
    
	cust_hdmi_power_on(true);	
	cust_hdmi_dpi_gpio_on(true);    
    //cust_hdmi_i2s_gpio_on(true);   
    
	if(txInitFlag == 0)
	{
		///sii_8348_tx_init(); 
		txInitFlag = 1;
	}
	
	goto power_on_exit;

/*
	MHL_Power(true);
	Mask_MHL_Intr();

	if(chip_inited == false)
	{
		if(txInitFlag == 0)
		{
			sii_8348_tx_init();
			txInitFlag = 1;
		}
		else
		{
			si_mhl_tx_post_initialize(si_dev_context, false);  
		}

		chip_inited = true;
	}
*/
power_on_exit:

    if(chip_device_id >0)
        ret = 0;
	
	///Unmask_MHL_Intr();
    HDMI_LOG("status %d, chipid: %x, ret: %d--%d\n", ReadConnectionStatus() , chip_device_id, ret, need_reset_usb_switch);        

    return ret;
}

void hdmi_drv_power_off(void)
{

	HDMI_FUNC();
	
    if(not_switch_to_d3 > 0)
    {
        HDMI_LOG("hdmi_drv_power_off direct to exit for forceon(%d_\n", not_switch_to_d3 );
        return ;
    }

    cust_hdmi_dpi_gpio_on(false);
    if(audio_enable == 0)
	    cust_hdmi_i2s_gpio_on(false);

  	return ;
	
	Mask_MHL_Intr();

    if(ReadConnectionStatus()==1){
        need_reset_usb_switch = true;
    	 ForceSwitchToD3(si_dev_context);
    }
    else
        need_reset_usb_switch = false;

	cust_hdmi_power_on(false);
	chip_inited = false;
    return ;

}


static unsigned int pal_resulution = 0;
void update_av_info_edid(bool audio_video, unsigned int param1, unsigned int param2)
{
    if(audio_video)///video infor
    {
        switch(param1)
    	{
    	    case 0x22:
    	    case 0x14:
            	pal_resulution |= SINK_1080P30;
            	break;
            case 0x10:
            	if(packed_pixel_available(si_dev_context))
                	pal_resulution |= SINK_1080P60;
            	break;
            case 0x4:
            	pal_resulution |= SINK_720P60;
            	break;
            case 0x3:
            case 0x2:
            	pal_resulution |= SINK_480P;
            	break;
			default:
				HDMI_LOG("param1: %d\n", param1);
    	}
	}	

	return ;
}
unsigned int si_mhl_get_av_info()
{
    unsigned int temp = SINK_1080P30;
    
    if(pal_resulution&SINK_1080P60)
        pal_resulution &= (~temp);
        
    return pal_resulution;
}
void reset_av_info()
{
    pal_resulution = 0;
}
void hdmi_GetEdidInfo(void *pv_get_info)
{
    HDMI_EDID_INFO_T *ptr = (HDMI_EDID_INFO_T *)pv_get_info;
    if(ptr)
    {
        ptr->ui4_ntsc_resolution = 0;
		ptr->ui4_pal_resolution = si_mhl_get_av_info();
		if(ptr->ui4_pal_resolution == 0)
		{
			HDMI_LOG("MHL edid parse error \n");
			
	        if(si_dev_context && packed_pixel_available(si_dev_context))
	            ptr->ui4_pal_resolution = SINK_720P60 | SINK_1080P60 | SINK_480P;
	        else
	            ptr->ui4_pal_resolution = SINK_720P60 | SINK_1080P30 | SINK_480P;
		}
    }

    if(si_dev_context)
    {
        HDMI_LOG("MHL hdmi_GetEdidInfo ntsc 0x%x,pal: 0x%x, packed: %d, parsed 0x%x\n", ptr->ui4_ntsc_resolution  , 
        	ptr->ui4_pal_resolution, packed_pixel_available(si_dev_context), si_mhl_get_av_info());
    }
}


extern uint8_t  Cap_MAX_channel;
extern uint16_t Cap_SampleRate;
extern uint8_t  Cap_Samplebit;

int hdmi_drv_get_external_device_capablity(void)
{
	HDMI_LOG("Cap_MAX_channel: %d, Cap_Samplebit: %d, Cap_SampleRate: %d\n", Cap_MAX_channel, Cap_Samplebit, Cap_SampleRate);
	int capablity = Cap_MAX_channel << 3 | Cap_SampleRate << 7 | Cap_Samplebit << 10;

	if(capablity == 0)
	{
		capablity = HDMI_CHANNEL_2 << 3 | HDMI_SAMPLERATE_44 << 7 |  HDMI_BITWIDTH_16 << 10;
	}

	return capablity;
}

const HDMI_DRIVER* HDMI_GetDriver(void)
{
	static const HDMI_DRIVER HDMI_DRV =
	{
		.set_util_funcs = hdmi_drv_set_util_funcs,
		.get_params     = hdmi_drv_get_params,
		.init           = hdmi_drv_init,
        .enter          = hdmi_drv_enter,
        .exit           = hdmi_drv_exit,
		.suspend        = hdmi_drv_suspend,
		.resume         = hdmi_drv_resume,
        .video_config   = hdmi_drv_video_config,
        .audio_config   = hdmi_drv_audio_config,
        .video_enable   = hdmi_drv_video_enable,
        .audio_enable   = hdmi_drv_audio_enable,
        .power_on       = hdmi_drv_power_on,
        .power_off      = hdmi_drv_power_off,
        .get_state      = hdmi_drv_get_state,
        .log_enable     = hdmi_drv_log_enable,
        .getedid        = hdmi_GetEdidInfo,
        .get_external_device_capablity = hdmi_drv_get_external_device_capablity,
        .force_on = hdmi_drv_force_on,
	};

    HDMI_FUNC();
	return &HDMI_DRV;
}
/************************** ****************************************************/

/************************** HAL To SmartBook****************************************/
static void SMB_Init(void)
{
#ifdef CONFIG_MTK_SMARTBOOK_SUPPORT
	//SMARTBOOK:  HID init
	if(MHL_Connect_type == MHL_SMB_CABLE)
	{
		SiiHidSuspend(1);
	}
#endif
	return ;
}
static void SMB_Denit(void)
{
#ifdef CONFIG_MTK_SMARTBOOK_SUPPORT
	if(MHL_Connect_type == MHL_SMB_CABLE)
	{
		SiiHidSuspend(0);
	}
#endif
	return ;
}
static void SMB_Write_Data(uint8_t *data)
{
#ifdef CONFIG_MTK_SMARTBOOK_SUPPORT
	if(MHL_Connect_type == MHL_SMB_CABLE)
	{
		SiiHidWrite(data);
	}
#endif
	return ;
}
static void SMB_HandShake_Init(void)
{
#ifdef CONFIG_MTK_SMARTBOOK_SUPPORT
	if(MHL_Connect_type == MHL_SMB_CABLE)
	{
		SiiHandshakeCommand(Init);
	}
#endif
	return ;
}
/************************** *****************************************************/

/************************** MHL TX Chip User Layer To HAL*******************************/
static char* MHL_TX_Event_Print(unsigned int event)
{
	switch(event)
	{
		case MHL_TX_EVENT_CONNECTION:
			return "MHL_TX_EVENT_CONNECTION";
		case MHL_TX_EVENT_DISCONNECTION:
			return "MHL_TX_EVENT_DISCONNECTION";
		case MHL_TX_EVENT_HPD_CLEAR:
			return "MHL_TX_EVENT_HPD_CLEAR";
		case MHL_TX_EVENT_HPD_GOT:
			return "MHL_TX_EVENT_HPD_GOT";
		case MHL_TX_EVENT_DEV_CAP_UPDATE:
			return "MHL_TX_EVENT_DEV_CAP_UPDATE";
		case MHL_TX_EVENT_EDID_UPDATE:
			return "MHL_TX_EVENT_EDID_UPDATE";
		case MHL_TX_EVENT_EDID_DONE:
			return "MHL_TX_EVENT_EDID_DONE";
		case MHL_TX_EVENT_SMB_DATA:
			return "MHL_TX_EVENT_SMB_DATA";
		default:
			HDMI_LOG("Unknow MHL TX Event Type\n");
			return "Unknow MHL TX Event Type\n";
	}	
}

extern void hdmi_state_callback(HDMI_STATE state);
void Notify_AP_MHL_TX_Event(unsigned int event, unsigned int event_param, void *param)
{
	if(event != MHL_TX_EVENT_SMB_DATA)
		HDMI_LOG("%s, event_param: %d\n", MHL_TX_Event_Print(event), event_param);
	switch(event)
	{
		case MHL_TX_EVENT_CONNECTION:
			break;
		case MHL_TX_EVENT_DISCONNECTION:
		{
			sii_mhl_connected = MHL_TX_EVENT_DISCONNECTION;
			hdmi_state_callback(HDMI_STATE_NO_DEVICE);
			reset_av_info();
			SMB_Denit();
			MHL_Connect_type = MHL_CABLE;
		}
			break;
		case MHL_TX_EVENT_HPD_CLEAR:
		{
			sii_mhl_connected= MHL_TX_EVENT_DISCONNECTION;
			hdmi_state_callback(HDMI_STATE_NO_DEVICE);
		}
			break;
		case MHL_TX_EVENT_HPD_GOT:
			break;
		case MHL_TX_EVENT_DEV_CAP_UPDATE:
		{
			MHL_Connect_type = MHL_SMB_CABLE;			
		}
			break;
		case MHL_TX_EVENT_EDID_UPDATE:
		{
			update_av_info_edid(true, event_param, 0);
		}
			break;
		case MHL_TX_EVENT_EDID_DONE:
		{
#ifdef HDCP_ENABLE
			HDCP_Supported_Info = true;
#endif
			sii_mhl_connected = MHL_TX_EVENT_CALLBACK;
			hdmi_state_callback(HDMI_STATE_ACTIVE);
			SMB_Init();
			SMB_HandShake_Init();
		}
			break;
		case MHL_TX_EVENT_SMB_DATA:
		{
			//SMARTBOOK: get write burst command
			SMB_Write_Data((uint8_t *)param);
		}
			break;
		default:
			return ;
	}

	return ;
}
/************************** ****************************************************/
#endif
Commit	Line	Data
6fa3eb70 S	1	#if defined(CONFIG_MTK_HDMI_SUPPORT)
	2	#include <linux/kernel.h>
	3
	4	#include <linux/xlog.h>
	5
	6	#include <linux/module.h>
	7	#include <linux/init.h>
	8	#include <linux/fs.h>
	9	#include <linux/cdev.h>
	10	#include <linux/device.h>
	11	#include <linux/delay.h>
	12	#include <linux/kthread.h>
	13
	14	#include <mtk_kpd.h> /* custom file */
	15	#include "si_timing_defs.h"
	16
	17	#include "hdmi_drv.h"
	18	#include "smartbook.h"
	19
	20	#include "hdmi_cust.h"
	21	/**
	22	* MHL TX Chip Driver User Layer Interface
	23	*/
	24	extern struct mhl_dev_context *si_dev_context;
	25	extern void ForceSwitchToD3( struct mhl_dev_context *dev_context);
	26	extern void ForceNotSwitchToD3();
	27	extern int si_mhl_tx_post_initialize(struct mhl_dev_context *dev_context, bool bootup);
	28	extern void siHdmiTx_VideoSel (int vmode);
	29	extern void siHdmiTx_AudioSel (int AduioMode);
	30	extern void set_platform_bitwidth(int bitWidth);
	31	extern bool si_mhl_tx_set_path_en_I(struct mhl_dev_context *dev_context);
	32	extern bool packed_pixel_available(struct mhl_dev_context *dev_context);
	33	extern void configure_and_send_audio_info(struct mhl_dev_context *dev_context, int audio_format);
	34
	35	//Should align to mhl_linux_tx.h
	36	#define MHL_TX_EVENT_DISCONNECTION 0x01
	37	#define MHL_TX_EVENT_CONNECTION 0x02
	38	#define MHL_TX_EVENT_SMB_DATA 0x40
	39	#define MHL_TX_EVENT_HPD_CLEAR 0x41
	40	#define MHL_TX_EVENT_HPD_GOT 0x42
	41	#define MHL_TX_EVENT_DEV_CAP_UPDATE 0x43
	42	#define MHL_TX_EVENT_EDID_UPDATE 0x44
	43	#define MHL_TX_EVENT_EDID_DONE 0x45
	44	#define MHL_TX_EVENT_CALLBACK 0x46
	45
	46	/**
	47	* Platform Related Layer Interface
	48	*/
	49	extern int HalOpenI2cDevice(char const DeviceName, char const DriverName);
	50	extern Mask_MHL_Intr(void);
	51	extern Unmask_MHL_Intr(void);
	52	extern int32_t sii_8348_tx_init(void); //Should move to MHL TX Chip user layer
	53	/**
	54	* LOG For MHL TX Chip HAL
	55	*/
	56	static size_t hdmi_log_on = true;
	57	static int txInitFlag = 0;
	58
	59	#define HDMI_LOG(fmt, arg...) \
	60	do { \
	61	if (hdmi_log_on) printk("[HDMI_Chip_HAL]%s,%d,", __func__, __LINE__); printk(fmt, ##arg); \
	62	}while (0)
	63
	64	#define HDMI_FUNC() \
65	do { \
66	if(hdmi_log_on) printk("[HDMI_Chip_HAL] %s\n", __func__); \
67	}while (0)
68
69	void hdmi_drv_log_enable(bool enable)
70	{
71	hdmi_log_on = enable;
72	}
73
74	static int not_switch_to_d3 = 0;
75	static int audio_enable = 0;
76
77	void hdmi_drv_force_on(int from_uart_drv )
78	{
79	HDMI_LOG("hdmi_drv_force_on %d\n", from_uart_drv);
80	if(from_uart_drv == 0)
81	ForceNotSwitchToD3();
82	not_switch_to_d3 = 1;
83	//gpio:uart
84	cust_hdmi_i2s_gpio_on(2);
85	}
86
87	/************************ Upper Layer To HAL*******************************/
88	static HDMI_UTIL_FUNCS hdmi_util = {0};
89	static void hdmi_drv_set_util_funcs(const HDMI_UTIL_FUNCS *util)
90	{
91	memcpy(&hdmi_util, util, sizeof(HDMI_UTIL_FUNCS));
92	}
93
94	static char* cable_type_print(unsigned short type)
95	{
96	switch(type)
97	{
98	case HDMI_CABLE:
99	return "HDMI_CABLE";
100	case MHL_CABLE:
101	return "MHL_CABLE";
102	case MHL_SMB_CABLE:
103	return "MHL_SMB_CABLE";
104	case MHL_2_CABLE:
105	return "MHL_2_CABLE";
106	default:
107	HDMI_LOG("Unknow MHL Cable Type\n");
108	return "Unknow MHL Cable Type\n";
109	}
110	}
111
112	static HDMI_CABLE_TYPE MHL_Connect_type = MHL_CABLE;
113	static bool HDCP_Supported_Info = false;
114	static void hdmi_drv_get_params(HDMI_PARAMS *params)
115	{
116	memset(params, 0, sizeof(HDMI_PARAMS));
117	params->init_config.vformat = HDMI_VIDEO_1280x720p_60Hz;
118	params->init_config.aformat = HDMI_AUDIO_44K_2CH;
119
120	params->clk_pol = HDMI_POLARITY_FALLING;
121	params->de_pol = HDMI_POLARITY_RISING;
122	params->vsync_pol = HDMI_POLARITY_RISING;
123	params->hsync_pol = HDMI_POLARITY_RISING;
124
125	params->hsync_front_porch = 110;
126	params->hsync_pulse_width = 40;
127	params->hsync_back_porch = 220;
128
129	params->vsync_front_porch = 5;
130	params->vsync_pulse_width = 5;
131	params->vsync_back_porch = 20;
132
133	params->rgb_order = HDMI_COLOR_ORDER_RGB;
134
135	params->io_driving_current = IO_DRIVING_CURRENT_2MA;
136	params->intermediat_buffer_num = 4;
137	params->scaling_factor = 0;
138	params->cabletype = MHL_Connect_type;
139	params->HDCPSupported = HDCP_Supported_Info;
140
141	HDMI_LOG("type %s\n", cable_type_print(params->cabletype));
142	return ;
143	}
144
145	void hdmi_drv_suspend(void) {return ;}
146	void hdmi_drv_resume(void) {return ;}
147	static int hdmi_drv_audio_config(HDMI_AUDIO_FORMAT aformat, int bitWidth)
148	{
149	set_platform_bitwidth(bitWidth);
150	siHdmiTx_AudioSel(aformat);
151	configure_and_send_audio_info(si_dev_context, aformat);
152
153	return 0;
154	}
155	static int hdmi_drv_video_enable(bool enable)
156	{
157	return 0;
158	}
159
160	static int hdmi_drv_audio_enable(bool enable)
161	{
162	printk("[EXTD]Set_I2S_Pin, enable = %d\n", enable);
163	//gpio:uart
164	if(not_switch_to_d3 == 1)
165	cust_hdmi_i2s_gpio_on(2);
166	else
167	cust_hdmi_i2s_gpio_on(enable);
168
169	audio_enable = enable;
170	return 0;
171	}
172
173	static int hdmi_drv_enter(void) {return 0;}
174	static int hdmi_drv_exit(void) {return 0;}
175
176	static int hdmi_drv_video_config(HDMI_VIDEO_RESOLUTION vformat, HDMI_VIDEO_INPUT_FORMAT vin, HDMI_VIDEO_OUTPUT_FORMAT vout)
177	{
178	if(vformat == HDMI_VIDEO_720x480p_60Hz)
179	{
180	HDMI_LOG("[hdmi_drv]480p\n");
181	siHdmiTx_VideoSel(HDMI_480P60_4X3);
182	}
183	else if(vformat == HDMI_VIDEO_1280x720p_60Hz)
184	{
185	HDMI_LOG("[hdmi_drv]720p\n");
186	siHdmiTx_VideoSel(HDMI_720P60);
187	}
188	else if(vformat == HDMI_VIDEO_1920x1080p_30Hz)
189	{
190	HDMI_LOG("[hdmi_drv]1080p_30 %p\n", si_dev_context);
191	siHdmiTx_VideoSel(HDMI_1080P30);
192	}
193	else if(vformat == HDMI_VIDEO_1920x1080p_60Hz)
194	{
195	HDMI_LOG("[hdmi_drv]1080p_60 %p\n", si_dev_context);
196	siHdmiTx_VideoSel(HDMI_1080P60);
197	}
198	else
199	{
200	HDMI_LOG("%s, video format not support now\n", __func__);
201	}
202
203	if(si_dev_context)
204	si_mhl_tx_set_path_en_I(si_dev_context);
205	return 0;
206	}
207
208	static unsigned int sii_mhl_connected = 0;
209	static uint8_t ReadConnectionStatus(void)
210	{
211	return (sii_mhl_connected == MHL_TX_EVENT_CALLBACK)? 1 : 0;
212	}
213	HDMI_STATE hdmi_drv_get_state(void)
214	{
215	int ret = ReadConnectionStatus();
216	HDMI_LOG("ret: %d\n", ret);
217
218	if(ret == 1)
219	return HDMI_STATE_ACTIVE;
220	else
221	return HDMI_STATE_NO_DEVICE;
222	}
223
224	bool chip_inited = false;
225	static int hdmi_drv_init(void)
226	{
227	HDMI_LOG("hdmi_drv_init +\n" );
228
229	Mask_MHL_Intr();
230	cust_hdmi_power_on(true);
231	if(not_switch_to_d3 == 0)
232	{
233	HalOpenI2cDevice("Sil_MHL", "sii8348drv");
234	}
235
236	txInitFlag = 0;
237	chip_inited = false;
238	HDMI_LOG("hdmi_drv_init -\n" );
239	return 0;
240	}
241
242	//Should be enhanced
243	int chip_device_id = 0;
244	bool need_reset_usb_switch = true;
245	int hdmi_drv_power_on(void)
246	{
247	int ret = 1;
248	HDMI_FUNC();
249
250	if(not_switch_to_d3 > 0)
251	{
252	HDMI_LOG("hdmi_drv_power_on direct to exit for forceon(%d_\n", not_switch_to_d3 );
253	return ;
254	}
255
256	cust_hdmi_power_on(true);
257	cust_hdmi_dpi_gpio_on(true);
258	//cust_hdmi_i2s_gpio_on(true);
259
260	if(txInitFlag == 0)
261	{
262	///sii_8348_tx_init();
263	txInitFlag = 1;
264	}
265
266	goto power_on_exit;
267
268	/*
269	MHL_Power(true);
270	Mask_MHL_Intr();
271
272	if(chip_inited == false)
273	{
274	if(txInitFlag == 0)
275	{
276	sii_8348_tx_init();
277	txInitFlag = 1;
278	}
279	else
280	{
281	si_mhl_tx_post_initialize(si_dev_context, false);
282	}
283
284	chip_inited = true;
285	}
286	*/
287	power_on_exit:
288
289	if(chip_device_id >0)
290	ret = 0;
291
292	///Unmask_MHL_Intr();
293	HDMI_LOG("status %d, chipid: %x, ret: %d--%d\n", ReadConnectionStatus() , chip_device_id, ret, need_reset_usb_switch);
294
295	return ret;
296	}
297
298	void hdmi_drv_power_off(void)
299	{
300
301	HDMI_FUNC();
302
303	if(not_switch_to_d3 > 0)
304	{
305	HDMI_LOG("hdmi_drv_power_off direct to exit for forceon(%d_\n", not_switch_to_d3 );
306	return ;
307	}
308
309	cust_hdmi_dpi_gpio_on(false);
310	if(audio_enable == 0)
311	cust_hdmi_i2s_gpio_on(false);
312
313	return ;
314
315	Mask_MHL_Intr();
316
317	if(ReadConnectionStatus()==1){
318	need_reset_usb_switch = true;
319	ForceSwitchToD3(si_dev_context);
320	}
321	else
322	need_reset_usb_switch = false;
323
324	cust_hdmi_power_on(false);
325	chip_inited = false;
326	return ;
327
328	}
329
330
331	static unsigned int pal_resulution = 0;
332	void update_av_info_edid(bool audio_video, unsigned int param1, unsigned int param2)
333	{
334	if(audio_video)///video infor
335	{
336	switch(param1)
337	{
338	case 0x22:
339	case 0x14:
340	pal_resulution \|= SINK_1080P30;
341	break;
342	case 0x10:
343	if(packed_pixel_available(si_dev_context))
344	pal_resulution \|= SINK_1080P60;
345	break;
346	case 0x4:
347	pal_resulution \|= SINK_720P60;
348	break;
349	case 0x3:
350	case 0x2:
351	pal_resulution \|= SINK_480P;
352	break;
353	default:
354	HDMI_LOG("param1: %d\n", param1);
355	}
356	}
357
358	return ;
359	}
360	unsigned int si_mhl_get_av_info()
361	{
362	unsigned int temp = SINK_1080P30;
363
364	if(pal_resulution&SINK_1080P60)
365	pal_resulution &= (~temp);
366
367	return pal_resulution;
368	}
369	void reset_av_info()
370	{
371	pal_resulution = 0;
372	}
373	void hdmi_GetEdidInfo(void *pv_get_info)
374	{
375	HDMI_EDID_INFO_T ptr = (HDMI_EDID_INFO_T )pv_get_info;
376	if(ptr)
377	{
378	ptr->ui4_ntsc_resolution = 0;
379	ptr->ui4_pal_resolution = si_mhl_get_av_info();
380	if(ptr->ui4_pal_resolution == 0)
381	{
382	HDMI_LOG("MHL edid parse error \n");
383
384	if(si_dev_context && packed_pixel_available(si_dev_context))
385	ptr->ui4_pal_resolution = SINK_720P60 \| SINK_1080P60 \| SINK_480P;
386	else
387	ptr->ui4_pal_resolution = SINK_720P60 \| SINK_1080P30 \| SINK_480P;
388	}
389	}
390
391	if(si_dev_context)
392	{
393	HDMI_LOG("MHL hdmi_GetEdidInfo ntsc 0x%x,pal: 0x%x, packed: %d, parsed 0x%x\n", ptr->ui4_ntsc_resolution ,
394	ptr->ui4_pal_resolution, packed_pixel_available(si_dev_context), si_mhl_get_av_info());
395	}
396	}
397
398
399	extern uint8_t Cap_MAX_channel;
400	extern uint16_t Cap_SampleRate;
401	extern uint8_t Cap_Samplebit;
402
403	int hdmi_drv_get_external_device_capablity(void)
404	{
405	HDMI_LOG("Cap_MAX_channel: %d, Cap_Samplebit: %d, Cap_SampleRate: %d\n", Cap_MAX_channel, Cap_Samplebit, Cap_SampleRate);
406	int capablity = Cap_MAX_channel << 3 \| Cap_SampleRate << 7 \| Cap_Samplebit << 10;
407
408	if(capablity == 0)
409	{
410	capablity = HDMI_CHANNEL_2 << 3 \| HDMI_SAMPLERATE_44 << 7 \| HDMI_BITWIDTH_16 << 10;
411	}
412
413	return capablity;
414	}
415
416	const HDMI_DRIVER* HDMI_GetDriver(void)
417	{
418	static const HDMI_DRIVER HDMI_DRV =
419	{
420	.set_util_funcs = hdmi_drv_set_util_funcs,
421	.get_params = hdmi_drv_get_params,
422	.init = hdmi_drv_init,
423	.enter = hdmi_drv_enter,
424	.exit = hdmi_drv_exit,
425	.suspend = hdmi_drv_suspend,
426	.resume = hdmi_drv_resume,
427	.video_config = hdmi_drv_video_config,
428	.audio_config = hdmi_drv_audio_config,
429	.video_enable = hdmi_drv_video_enable,
430	.audio_enable = hdmi_drv_audio_enable,
431	.power_on = hdmi_drv_power_on,
432	.power_off = hdmi_drv_power_off,
433	.get_state = hdmi_drv_get_state,
434	.log_enable = hdmi_drv_log_enable,
435	.getedid = hdmi_GetEdidInfo,
436	.get_external_device_capablity = hdmi_drv_get_external_device_capablity,
437	.force_on = hdmi_drv_force_on,
438	};
439
440	HDMI_FUNC();
441	return &HDMI_DRV;
442	}
443	/************************ **************************************************/
444
445	/************************ HAL To SmartBook**************************************/
446	static void SMB_Init(void)
447	{
448	#ifdef CONFIG_MTK_SMARTBOOK_SUPPORT
449	//SMARTBOOK: HID init
450	if(MHL_Connect_type == MHL_SMB_CABLE)
451	{
452	SiiHidSuspend(1);
453	}
454	#endif
455	return ;
456	}
457	static void SMB_Denit(void)
458	{
459	#ifdef CONFIG_MTK_SMARTBOOK_SUPPORT
460	if(MHL_Connect_type == MHL_SMB_CABLE)
461	{
462	SiiHidSuspend(0);
463	}
464	#endif
465	return ;
466	}
467	static void SMB_Write_Data(uint8_t *data)
468	{
469	#ifdef CONFIG_MTK_SMARTBOOK_SUPPORT
470	if(MHL_Connect_type == MHL_SMB_CABLE)
471	{
472	SiiHidWrite(data);
473	}
474	#endif
475	return ;
476	}
477	static void SMB_HandShake_Init(void)
478	{
479	#ifdef CONFIG_MTK_SMARTBOOK_SUPPORT
480	if(MHL_Connect_type == MHL_SMB_CABLE)
481	{
482	SiiHandshakeCommand(Init);
483	}
484	#endif
485	return ;
486	}
487	/************************ ***************************************************/
488
489	/************************ MHL TX Chip User Layer To HAL*****************************/
490	static char* MHL_TX_Event_Print(unsigned int event)
491	{
492	switch(event)
493	{
494	case MHL_TX_EVENT_CONNECTION:
495	return "MHL_TX_EVENT_CONNECTION";
496	case MHL_TX_EVENT_DISCONNECTION:
497	return "MHL_TX_EVENT_DISCONNECTION";
498	case MHL_TX_EVENT_HPD_CLEAR:
499	return "MHL_TX_EVENT_HPD_CLEAR";
500	case MHL_TX_EVENT_HPD_GOT:
501	return "MHL_TX_EVENT_HPD_GOT";
502	case MHL_TX_EVENT_DEV_CAP_UPDATE:
503	return "MHL_TX_EVENT_DEV_CAP_UPDATE";
504	case MHL_TX_EVENT_EDID_UPDATE:
505	return "MHL_TX_EVENT_EDID_UPDATE";
506	case MHL_TX_EVENT_EDID_DONE:
507	return "MHL_TX_EVENT_EDID_DONE";
508	case MHL_TX_EVENT_SMB_DATA:
509	return "MHL_TX_EVENT_SMB_DATA";
510	default:
511	HDMI_LOG("Unknow MHL TX Event Type\n");
512	return "Unknow MHL TX Event Type\n";
513	}
514	}
515
516	extern void hdmi_state_callback(HDMI_STATE state);
517	void Notify_AP_MHL_TX_Event(unsigned int event, unsigned int event_param, void *param)
518	{
519	if(event != MHL_TX_EVENT_SMB_DATA)
520	HDMI_LOG("%s, event_param: %d\n", MHL_TX_Event_Print(event), event_param);
521	switch(event)
522	{
523	case MHL_TX_EVENT_CONNECTION:
524	break;
525	case MHL_TX_EVENT_DISCONNECTION:
526	{
527	sii_mhl_connected = MHL_TX_EVENT_DISCONNECTION;
528	hdmi_state_callback(HDMI_STATE_NO_DEVICE);
529	reset_av_info();
530	SMB_Denit();
531	MHL_Connect_type = MHL_CABLE;
532	}
533	break;
534	case MHL_TX_EVENT_HPD_CLEAR:
535	{
536	sii_mhl_connected= MHL_TX_EVENT_DISCONNECTION;
537	hdmi_state_callback(HDMI_STATE_NO_DEVICE);
538	}
539	break;
540	case MHL_TX_EVENT_HPD_GOT:
541	break;
542	case MHL_TX_EVENT_DEV_CAP_UPDATE:
543	{
544	MHL_Connect_type = MHL_SMB_CABLE;
545	}
546	break;
547	case MHL_TX_EVENT_EDID_UPDATE:
548	{
549	update_av_info_edid(true, event_param, 0);
550	}
551	break;
552	case MHL_TX_EVENT_EDID_DONE:
553	{
554	#ifdef HDCP_ENABLE
555	HDCP_Supported_Info = true;
556	#endif
557	sii_mhl_connected = MHL_TX_EVENT_CALLBACK;
558	hdmi_state_callback(HDMI_STATE_ACTIVE);
559	SMB_Init();
560	SMB_HandShake_Init();
561	}
562	break;
563	case MHL_TX_EVENT_SMB_DATA:
564	{
565	//SMARTBOOK: get write burst command
566	SMB_Write_Data((uint8_t *)param);
567	}
568	break;
569	default:
570	return ;
571	}
572
573	return ;
574	}
575	/************************ **************************************************/
576	#endif