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; }