void Set_DPI_Pin(bool enable)
{
unsigned int dpi_pin_start = 0;
if(enable)
{
#ifdef GPIO_EXT_DISP_DPI0_PIN
for(dpi_pin_start = GPIO_EXT_DISP_DPI0_PIN; dpi_pin_start < GPIO_EXT_DISP_DPI0_PIN + 16; dpi_pin_start++)
{
mt_set_gpio_mode(dpi_pin_start, GPIO_MODE_01);
}
HDMI_LOG("%s, %d GPIO_EXT_DISP_DPI0_PIN is defined+ %x\n", __func__, __LINE__, GPIO_EXT_DISP_DPI0_PIN);
#else
HDMI_LOG("%s,%d Error: GPIO_EXT_DISP_DPI0_PIN is not defined\n", __func__, __LINE__);
#endif
}
else
{
#ifdef GPIO_EXT_DISP_DPI0_PIN
for(dpi_pin_start = GPIO_EXT_DISP_DPI0_PIN; dpi_pin_start < GPIO_EXT_DISP_DPI0_PIN + 16; dpi_pin_start++)
{
mt_set_gpio_mode(dpi_pin_start, GPIO_MODE_00);
mt_set_gpio_dir(dpi_pin_start, GPIO_DIR_IN);
mt_set_gpio_pull_enable(dpi_pin_start, GPIO_PULL_ENABLE);
mt_set_gpio_pull_select(dpi_pin_start, GPIO_PULL_DOWN);
}
printk("%s, %d GPIO_EXT_DISP_DPI0_PIN is defined- %x\n", __func__, __LINE__, GPIO_EXT_DISP_DPI0_PIN);
#endif
}
return ;
}
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;
}
int hdmi_dst_display_path_config(bool enable)
{
HDMI_FUNC();
if (enable)
{
//FIXME: now nothing can be seen on TV if output UYVY from WDMA0
unsigned int hdmiSourceAddr = hdmi_mva_r;// + p->hdmi_width * p->hdmi_height * hdmi_bpp * hdmi_buffer_read_id;
struct disp_path_config_struct config = {0};
// Config RDMA->DPI1
config.srcWidth = 1280;
config.srcHeight = 720;
config.srcModule = DISP_MODULE_RDMA1;
config.inFormat = RDMA_INPUT_FORMAT_ARGB;
config.outFormat = RDMA_OUTPUT_FORMAT_ARGB;
config.addr = hdmiSourceAddr;
config.pitch = config.srcWidth * 4;
config.dstModule = DISP_MODULE_DPI0;
//if(-1 == dp_mutex_dst)
// dp_mutex_dst = disp_lock_mutex();
dp_mutex_dst = 2;
disp_dump_reg(DISP_MODULE_RDMA0);
disp_dump_reg(DISP_MODULE_RDMA1);
disp_dump_reg(DISP_MODULE_CONFIG);
HDMI_LOG("Get mutex ID %d for RDMA1>DPI1\n", dp_mutex_dst);
disp_path_get_mutex_(dp_mutex_dst);
disp_path_config_(&config, dp_mutex_dst);
disp_path_release_mutex_(dp_mutex_dst);
disp_dump_reg(DISP_MODULE_CONFIG);
disp_dump_reg(DISP_MODULE_RDMA0);
disp_dump_reg(DISP_MODULE_RDMA1);
}
else
{
if (-1 != dp_mutex_dst)
{
//FIXME: release mutex timeout
HDMI_LOG("Stop RDMA1>DPI1\n");
disp_path_get_mutex_(dp_mutex_dst);
DISP_REG_SET_FIELD(1 << dp_mutex_src , DISP_REG_CONFIG_MUTEX_INTEN, 1);
RDMAStop(1);
RDMAReset(1);
disp_path_release_mutex_(dp_mutex_dst);
//disp_unlock_mutex(dp_mutex_dst);
dp_mutex_dst = -1;
}
}
return 0;
}
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;
}
/************************** 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";
}
}
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 ;
}
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;
}
void MHL_Power(bool enable)
{
if(enable)
{
#ifdef PMIC_APP_MHL_POWER_LDO1
if(chip_power_on == false)
{
hwPowerOn(PMIC_APP_MHL_POWER_LDO1, VOL_1200,"MHL");
chip_power_on = true;
}
#else
HDMI_LOG("Error: PMIC_APP_MHL_POWER_LDO1 not defined -\n" );
#endif
}
else
{
#ifdef PMIC_APP_MHL_POWER_LDO1
if(chip_power_on == true)
{
hwPowerDown(PMIC_APP_MHL_POWER_LDO1, "MHL");
chip_power_on = false;
}
#endif
}
return ;
}
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 ;
}
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 ;
}
void Set_I2S_Pin(bool enable)
{
if (I2S_Enable)
{
if(enable == true)
{
#ifdef GPIO_MHL_I2S_OUT_WS_PIN
mt_set_gpio_mode(GPIO_MHL_I2S_OUT_WS_PIN, GPIO_MODE_01);
mt_set_gpio_mode(GPIO_MHL_I2S_OUT_CK_PIN, GPIO_MODE_01);
mt_set_gpio_mode(GPIO_MHL_I2S_OUT_DAT_PIN, GPIO_MODE_01);
mt_set_gpio_dir(GPIO_MHL_I2S_OUT_WS_PIN, GPIO_DIR_OUT);
#else
HDMI_LOG("%s,%d. GPIO_MHL_I2S_OUT_WS_PIN is not defined\n", __func__, __LINE__);
#endif
}
else
{
#ifdef GPIO_MHL_I2S_OUT_WS_PIN
mt_set_gpio_mode(GPIO_MHL_I2S_OUT_WS_PIN, GPIO_MODE_02);
mt_set_gpio_mode(GPIO_MHL_I2S_OUT_CK_PIN, GPIO_MODE_01);
mt_set_gpio_mode(GPIO_MHL_I2S_OUT_DAT_PIN, GPIO_MODE_02);
mt_set_gpio_dir(GPIO_MHL_I2S_OUT_WS_PIN, GPIO_DIR_IN);
#endif
}
}
return ;
}
void Set_Rst_Pin(void)
{
#ifndef GPIO_MHL_RST_B_PIN
HDMI_LOG("%s,%d Error: GPIO_MHL_RST_B_PIN is not defined\n", __func__, __LINE__);
#endif
return ;
}
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 ;
}
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);
}
int hdmi_unregister_cable_insert_callback(CABLE_INSERT_CALLBACK cb)
{
int i;
for (i=0; i<HDMI_MAX_INSERT_CALLBACK; i++)
{
if (hdmi_callback_table[i] == cb)
{
HDMI_LOG("unregister cable insert callback: %p, i: %d\n", hdmi_callback_table[i], i);
hdmi_callback_table[i] = NULL;
break;
}
}
if (i == HDMI_MAX_INSERT_CALLBACK)
{
HDMI_LOG("Try to unregister callback function 0x%lx which was not registered\n",(unsigned long int)cb);
return -1;
}
return 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;
}
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
{
HDMI_LOG("%s, video format not support now\n", __func__);
}
return 0;
}
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;
}
int hdmi_allocate_hdmi_buffer(void)
{
M4U_PORT_STRUCT m4uport;
int hdmiPixelSize = p->hdmi_width * p->hdmi_height;
int hdmiDataSize = hdmiPixelSize * hdmi_bpp;
int hdmiBufferSize = hdmiDataSize * 4;
HDMI_FUNC();
hdmi_va = (unsigned int) vmalloc(hdmiBufferSize);
if (((void *) hdmi_va) == NULL)
{
HDMI_LOG("vmalloc %dbytes fail!!!\n", hdmiBufferSize);
return -1;
}
memset((void *) hdmi_va, 0x80, hdmiBufferSize);
//RDMA1
if (m4u_alloc_mva(M4U_CLNTMOD_RDMA, hdmi_va, hdmiBufferSize, 0, 0, &hdmi_mva_r))
{
HDMI_LOG("m4u_alloc_mva for hdmi_mva_r fail\n");
return -1;
}
memset((void *) &m4uport, 0, sizeof(M4U_PORT_STRUCT));
m4uport.ePortID = M4U_PORT_RDMA1;
m4uport.Virtuality = 1;
m4uport.domain = 0;
m4uport.Security = 0;
m4uport.Distance = 1;
m4uport.Direction = 0;
m4u_config_port(&m4uport);
HDMI_LOG("hdmi_va=0x%08x, hdmi_mva_r=0x%08x, hdmi_mva_w=0x%08x\n", hdmi_va, hdmi_mva_r, hdmi_mva_w);
return 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;
}
#ifdef MHL_RESOLUTION_LIMIT_720P_60
ptr->ui4_pal_resolution &= (~SINK_1080P60);
ptr->ui4_pal_resolution &= (~SINK_1080P30);
#endif
#ifdef MHL_RESOLUTION_LIMIT_1080P_30
if(ptr->ui4_pal_resolution & SINK_1080P60)
{
ptr->ui4_pal_resolution &= (~SINK_1080P60);
ptr->ui4_pal_resolution |= SINK_1080P30;
}
#endif
}
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());
}
}
int hdmi_register_cable_insert_callback(CABLE_INSERT_CALLBACK cb)
{
int i = 0;
for (i = 0; i < HDMI_MAX_INSERT_CALLBACK; i++) {
if (hdmi_callback_table[i] == cb)
break;
}
if (i < HDMI_MAX_INSERT_CALLBACK)
return 0;
for (i = 0; i < HDMI_MAX_INSERT_CALLBACK; i++) {
if (hdmi_callback_table[i] == NULL)
break;
}
if (i == HDMI_MAX_INSERT_CALLBACK) {
HDMI_LOG("not enough mhl callback entries for module\n");
return -1;
}
hdmi_callback_table[i] = cb;
HDMI_LOG("callback: %p,i: %d\n", hdmi_callback_table[i], i);
return 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());
}
}
void hdmi_invoke_cable_callbacks(HDMI_STATE state)
{
int i = 0, j = 0;
for (i=0; i<HDMI_MAX_INSERT_CALLBACK; i++) // 0 is for external display
{
if(hdmi_callback_table[i])
{
j = i;
}
}
if (hdmi_callback_table[j])
{
HDMI_LOG("callback: %p, state: %d, j: %d\n", hdmi_callback_table[j], state, j);
hdmi_callback_table[j](state);
}
}
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";
}
}
void hdmi_update_impl(void)
{
HDMI_LOG("hdmi_update_impl\n");
int t = 0;
//int ret = 0;
//MdpkBitbltConfig pmdp;
//int lcm_physical_rotation = 0;
int pixelSize = p->hdmi_width * p->hdmi_height;
int dataSize = pixelSize * hdmi_bpp;
RET_VOID_IF_NOLOG(p->output_mode == HDMI_OUTPUT_MODE_DPI_BYPASS);
if(pixelSize == 0)
{
HDMI_LOG("ignored[resolution is null]\n");
return;
}
//HDMI_FUNC();
if(down_interruptible(&hdmi_update_mutex))
{
HDMI_LOG("[HDMI] can't get semaphore in\n");
return;
}
if (IS_HDMI_NOT_ON())
{
goto done;
}
if(IS_HDMI_IN_VIDEO_MODE())
{
goto done;
}
DBG_OnTriggerHDMI();
//LCD_WaitForNotBusy();
if(temp_va != 0 && hdmi_va != 0)
{
DdpkBitbltConfig pddp;
int dstOffset;
memset((void*)&pddp, 0, sizeof(DdpkBitbltConfig));
pddp.srcX = pddp.srcY = 0;
pddp.srcW = p->lcm_width;
pddp.srcH = p->lcm_height;
pddp.srcWStride = p->lcm_width;
pddp.srcHStride = p->lcm_height;
pddp.srcAddr[0] = temp_va;
pddp.srcFormat = eRGB888_K;
pddp.srcBufferSize[0] = p->lcm_width*p->lcm_height*3;
pddp.srcPlaneNum = 1;
pddp.dstX = 0;
pddp.dstY = 0;
pddp.dstFormat = eARGB8888_K;
pddp.pitch = p->hdmi_width;
pddp.dstWStride = p->hdmi_width;
pddp.dstHStride = p->hdmi_height;
pddp.dstPlaneNum = 1;
pddp.orientation = 0;
switch(pddp.orientation)
{
case 90:
case 270:
#if 1
{
pddp.dstW = ALIGN_TO(p->lcm_height * p->hdmi_height / p->lcm_width * 95 / 100, 4);
pddp.dstH = ALIGN_TO(p->hdmi_height * 95 /100, 4);
break;
}
#endif // fall through now
case 0:
case 180:
{
pddp.dstW = ALIGN_TO(p->hdmi_width * 95 / 100, 4);
pddp.dstH = ALIGN_TO(p->hdmi_height * 95 /100, 4);
break;
}
default:
HDMI_LOG("Unknown orientation %d\n", pddp.orientation);
return;
}
dstOffset = (p->hdmi_height - pddp.dstH ) / 2 * p->hdmi_width * hdmi_bpp +
(p->hdmi_width - pddp.dstW) / 2 * hdmi_bpp;
pddp.dstAddr[0] = hdmi_va;// + hdmi_buffer_write_id * p->hdmi_width * p->hdmi_height * hdmi_bpp + dstOffset;
pddp.dstBufferSize[0] = p->hdmi_width*p->hdmi_height*hdmi_bpp;
t = get_current_time_us();
DDPK_Bitblt_Config(DDPK_CH_HDMI_0, &pddp);
DDPK_Bitblt(DDPK_CH_HDMI_0);
}
//HDMI_LOG("dstw=%d, dsth=%d, ori=%d\n", p.dstW, p.dstH, p.orientation);
DBG_OnHDMIDone();
HDMI_LOG("cost %d us\n", get_current_time_us() - t);
//hdmi_buffer_read_id = hdmi_buffer_write_id;
//hdmi_buffer_write_id = (hdmi_buffer_write_id+1) % hdmi_params->intermediat_buffer_num;
done:
up(&hdmi_update_mutex);
return;
}
/* Will only be used in hdmi_drv_init(), this means that will only be use in ioctl(MTK_HDMI_AUDIO_VIDEO_ENABLE) */
/*static*/ void hdmi_dpi_config_clock(void)
{
int ret = 0;
RET_VOID_IF(p->output_mode == HDMI_OUTPUT_MODE_DPI_BYPASS);
ret = enable_pll(TVDPLL, "HDMI");
if(ret)
{
HDMI_LOG("enable_pll fail!!\n");
}
printk("[hdmi]720p 60Hz\n");
//ret = pll_fsel(TVDPLL, 0x800B6C4E);
OUTREG32(TVDPLL_CON1, 0x800B6C4E); //148.5MHz
OUTREG32(TVDPLL_CON0, 0x80000081);
//OUTREG32(TVDPLL_CON0, 0x80000081);
//OUTREG32(DISPSYS_BASE+0x038, 0x1); // rdma0_out_sel, 2 for DPI0
//OUTREG32(DISPSYS_BASE+0x05c, 0x1); // DPI0_SEL, 0 is from rdma0
ASSERT(!ret);
clk_pol = HDMI_POLARITY_FALLING;
de_pol = HDMI_POLARITY_RISING;
hsync_pol = HDMI_POLARITY_RISING;
vsync_pol = HDMI_POLARITY_RISING;;
hsync_front_porch = 110;
hsync_pulse_width = 40;
hsync_back_porch = 220;
vsync_front_porch = 5;
vsync_pulse_width = 5;
vsync_back_porch = 20;
dpi_clk_div = 2;
dpi_clk_duty = 1;
rgb_order = hdmi_params->rgb_order;
intermediat_buffer_num = 4;
// dpi clock configuration using MIPITX
//if(hdmi_params->dpi_port == HDMI_DPI_OUTPUT_PORT_0)
{
DPI_CHECK_RET(DPI_Init(FALSE));
DPI_CHECK_RET(DPI_ConfigPixelClk(clk_pol, dpi_clk_div, dpi_clk_duty));
DPI_CHECK_RET(DPI_ConfigDataEnable(de_pol));
DPI_CHECK_RET(DPI_ConfigHsync(hsync_pol, hsync_pulse_width, hsync_back_porch, hsync_front_porch));
DPI_CHECK_RET(DPI_ConfigVsync(vsync_pol, vsync_pulse_width, vsync_back_porch, vsync_front_porch));
DPI_CHECK_RET(DPI_FBSetSize(1280, 720));
//if (LCM_COLOR_ORDER_BGR == rgb_order)
if (HDMI_COLOR_ORDER_BGR == rgb_order)
{
DPI_CHECK_RET(DPI_SetRGBOrder(DPI_RGB_ORDER_RGB, DPI_RGB_ORDER_BGR));
}
else
{
DPI_CHECK_RET(DPI_SetRGBOrder(DPI_RGB_ORDER_RGB, DPI_RGB_ORDER_RGB));
}
//DPI_Internal_Pattern(1, 5);
DPI_CHECK_RET(DPI_EnableClk());
p->is_clock_on = true;
}
}
/* Will only be used in ioctl(MTK_HDMI_AUDIO_VIDEO_ENABLE) */
static HDMI_STATUS hdmi_drv_init(void)
{
int lcm_width, lcm_height;
int tmpBufferSize;
M4U_PORT_STRUCT portStruct;
HDMI_FUNC();
RETIF(p->output_mode == HDMI_OUTPUT_MODE_DPI_BYPASS, 0);
p->hdmi_width = 1280;
p->hdmi_height = 720;
lcm_width = DISP_GetScreenWidth();
lcm_height = DISP_GetScreenHeight();
//printk("[hdmi]%s, hdmi_width=%d, hdmi_height=%d\n", __func__, p->hdmi_width, p->hdmi_height);
HDMI_LOG("lcm_width=%d, lcm_height=%d\n", lcm_width, lcm_height);
tmpBufferSize = lcm_width * lcm_height *4 * 4;
temp_va = (unsigned int) vmalloc(tmpBufferSize);
if (((void*) temp_va) == NULL)
{
HDMI_LOG("vmalloc %dbytes fail\n", tmpBufferSize);
return -1;
}
// WDMA1
if (m4u_alloc_mva(M4U_CLNTMOD_WDMA,
temp_va,
tmpBufferSize,
0,
0,
&temp_mva_w))
{
HDMI_LOG("m4u_alloc_mva for temp_mva_w fail\n");
return -1;
}
m4u_dma_cache_maint(M4U_CLNTMOD_WDMA,
temp_va,
tmpBufferSize,
DMA_BIDIRECTIONAL);
portStruct.ePortID = M4U_PORT_WDMA1; //hardware port ID, defined in M4U_PORT_ID_ENUM
portStruct.Virtuality = 1;
portStruct.Security = 0;
portStruct.domain = 0; //domain : 0 1 2 3
portStruct.Distance = 1;
portStruct.Direction = 0;
m4u_config_port(&portStruct);
HDMI_LOG("temp_va=0x%08x, temp_mva_w=0x%08x\n", temp_va, temp_mva_w);
p->lcm_width = lcm_width;
p->lcm_height = lcm_height;
p->output_video_resolution = hdmi_params->init_config.vformat;
p->output_audio_format = hdmi_params->init_config.aformat;
//#ifdef NEW_HDMI_ARCH
// hdmi_display_path_overlay_config(true);
//#endif
DISP_Config_Overlay_to_Memory(temp_mva_w, 1);
//hdmi_dpi_config_clock(); // configure dpi clock
//hdmi_dpi_power_switch(false); // but dpi power is still off
//hdmi_drv->suspend();
#if 0
LCD_WaitForNotBusy();
LCD_SetOutputMode(3); // LCD write to memory and LCM
#endif
return HDMI_STATUS_OK;
}
