自学教程：C++ DE_WRN函数代码示例

s32 disp_lcd_set_bright(struct disp_lcd *lcd, u32 bright){	u32 duty_ns;	__u64 backlight_bright = bright;	__u64 backlight_dimming;	__u64 period_ns;	struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);	bool need_enable_bl = false, need_disable_bl = false;	if((NULL == lcd) || (NULL == lcdp)) {		DE_WRN("NULL hdl!/n");		return DIS_FAIL;	}	if((0 == lcdp->lcd_cfg.backlight_bright) && (0 != bright))		need_enable_bl = true;	if((0 != lcdp->lcd_cfg.backlight_bright) && (0 == bright))		need_disable_bl = true;	backlight_bright = (backlight_bright > 255)? 255:backlight_bright;	if(lcdp->lcd_cfg.backlight_bright != backlight_bright) {		lcdp->lcd_cfg.backlight_bright = backlight_bright;		disp_notifier_call_chain(DISP_EVENT_BACKLIGHT_UPDATE, lcd->channel_id, (void*)bright);	}	if(backlight_bright != 0)	{		backlight_bright += 1;	}	lcdp->lcd_cfg.backlight_dimming = (0 == lcdp->lcd_cfg.backlight_dimming)? 256:lcdp->lcd_cfg.backlight_dimming;	backlight_dimming = lcdp->lcd_cfg.backlight_dimming;	period_ns = lcdp->pwm_info.period_ns;	duty_ns = (backlight_bright * backlight_dimming *  period_ns/256 + 128) / 256;	lcdp->pwm_info.duty_ns = duty_ns;//		DE_DBG("[PWM]bright=%d, bright_modify=%d, backlight_dimming=%d, period_ns=%d, duty_ns=%d/n",//		bright,(u32)backlight_bright, lcdp->lcd_cfg.backlight_dimming,  (u32)period_ns, (u32)duty_ns);	sunxi_pwm_config(lcdp->pwm_info.channel, duty_ns, period_ns);	if(need_enable_bl)		disp_lcd_backlight_enable(lcd);	if(need_disable_bl)		disp_lcd_backlight_enable(lcd);	return DIS_SUCCESS;}

s32 disp_lcd_get_driver_name(struct disp_lcd *lcd, char* name){	char primary_key[20];	s32 ret;	struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);	if((NULL == lcd) || (NULL == lcdp)) {		DE_WRN("NULL hdl!/n");		return DIS_FAIL;	}	sprintf(primary_key, "lcd%d_para", lcd->channel_id);	ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_driver_name",  (int*)name, 32);	DE_INF("disp_lcd_get_driver_name, %s/n", name);	return ret;}

__s32 BSP_disp_tv_get_interface(__u32 sel){    __u8 dac[4];    __s32 i = 0;	__u32  ret = DISP_TV_NONE;    if(!(gdisp.screen[sel].status & TV_ON))    {        tve_clk_on();    }    for(i=0; i<4; i++)    {        dac[i] = TVE_get_dac_status(i);    }    if(dac[0]>1 || dac[1]>1 || dac[2]>1 || dac[3]>1)    {        DE_WRN("shor to ground/n");    }    else    {        for(i=0; i<4; i++)        {            if(gdisp.screen[sel].dac_source[i] == DISP_TV_DAC_SRC_COMPOSITE && dac[i] == 1)            {                ret |= DISP_TV_CVBS;            }            else if(gdisp.screen[sel].dac_source[i] == DISP_TV_DAC_SRC_Y && dac[i] == 1)            {                ret |= DISP_TV_YPBPR;            }            else if(gdisp.screen[sel].dac_source[i] == DISP_TV_DAC_SRC_LUMA && dac[i] == 1)            {                ret |= DISP_TV_SVIDEO;            }        }    }    if(!(gdisp.screen[sel].status & TV_ON))    {        tve_clk_off();    }    return  ret;}

s32 disp_lcd_set_panel_funs(struct disp_lcd* lcd, disp_lcd_panel_fun * lcd_cfg){	struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);	if((NULL == lcd) || (NULL == lcdp)) {		DE_WRN("NULL hdl!/n");		return DIS_FAIL;	}	memset(&lcdp->lcd_panel_fun, 0, sizeof(disp_lcd_panel_fun));	lcdp->lcd_panel_fun.cfg_panel_info= lcd_cfg->cfg_panel_info;	lcdp->lcd_panel_fun.cfg_open_flow = lcd_cfg->cfg_open_flow;	lcdp->lcd_panel_fun.cfg_close_flow = lcd_cfg->cfg_close_flow;	lcdp->lcd_panel_fun.lcd_user_defined_func = lcd_cfg->lcd_user_defined_func;	return 0;}

s32 disp_hdmi_get_vendor_id(struct disp_hdmi* hdmi, __u8 *id){	struct disp_hdmi_private_data *hdmip = disp_hdmi_get_priv(hdmi);	__inf("disp_hdmi_get_vendor_id/n");	if((NULL == hdmi) || (NULL == hdmip)){		DE_WRN("hdmi set func null hdl!/n");		return DIS_FAIL;	}	if(hdmip->hdmi_func.hdmi_get_vendor_id == NULL){		__inf("hdmi_get_vendor_id NULL");		return -1;	}	return hdmip->hdmi_func.hdmi_get_vendor_id(id);}

s32 bsp_disp_lcd_post_enable(u32 screen_id){	struct disp_lcd* lcd;	int ret = 0;	lcd = disp_get_lcd(screen_id);	if(!lcd) {		DE_WRN("get lcd%d fail/n", screen_id);	}	if(lcd->post_enable)		ret = lcd->post_enable(lcd);#if defined(__LINUX_PLAT__)	Display_set_fb_timming(screen_id);#endif	return ret;}

s32 hdmi_clk_enable(struct disp_hdmi *hdmi){	struct disp_hdmi_private_data *hdmip = disp_hdmi_get_priv(hdmi);	if(!hdmi || !hdmip) {	    DE_WRN("hdmi clk init null hdl!/n");	    return DIS_FAIL;	}	hdmi_clk_config(hdmi);	if(hdmip->drc_clk.clk)		disp_al_hdmi_clk_enable(hdmip->drc_clk.clk);	disp_al_hdmi_enable(hdmi->channel_id);	return 0;}

s32 bsp_disp_get_timming(u32 screen_id, disp_video_timing * tt){	memset(tt, 0, sizeof(disp_video_timing));	if(DISP_OUTPUT_TYPE_LCD == bsp_disp_get_output_type(screen_id)) {		struct disp_lcd *lcd;		lcd = disp_get_lcd(screen_id);		if(!lcd) {			DE_WRN("get lcd%d failed/n", screen_id);			return DIS_FAIL;		}		if(lcd->get_timing)			return lcd->get_timing(lcd, tt);	}#if 0	struct disp_hdmi* hdmi;	else if(DISP_OUTPUT_TYPE_HDMI == bsp_disp_get_output_type(screen_id)) {

s32 disp_lcd_set_close_func(struct disp_lcd* lcd, LCD_FUNC func, u32 delay){	struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);	if((NULL == lcd) || (NULL == lcdp)) {		DE_WRN("NULL hdl!/n");		return -1;	}	if(func) {		lcdp->close_flow.func[lcdp->close_flow.func_num].func = func;		lcdp->close_flow.func[lcdp->close_flow.func_num].delay = delay;		lcdp->close_flow.func_num ++;	}	return DIS_SUCCESS;}

__s32 BSP_disp_hdmi_open(__u32 sel){    if(!(gdisp.screen[sel].status & HDMI_ON))    {    	__disp_tv_mode_t     tv_mod;            	tv_mod = gdisp.screen[sel].hdmi_mode;        hdmi_clk_on();    	lcdc_clk_on(sel);    	image_clk_on(sel);		Image_open(sel);//set image normal channel start bit , because every de_clk_off( )will reset this bit    	disp_clk_cfg(sel,DISP_OUTPUT_TYPE_HDMI, tv_mod);        BSP_disp_set_output_csc(sel, DISP_OUTPUT_TYPE_HDMI);    	DE_BE_set_display_size(sel, tv_mode_to_width(tv_mod), tv_mode_to_height(tv_mod));    	DE_BE_Output_Select(sel, sel);    	TCON1_set_hdmi_mode(sel,tv_mod);		 	     	TCON1_open(sel);    	if(gdisp.init_para.Hdmi_open)    	{    	    gdisp.init_para.Hdmi_open();    	}    	else    	{    	    DE_WRN("Hdmi_open is NULL/n");    	    return -1;    	}    	    	Disp_Switch_Dram_Mode(DISP_OUTPUT_TYPE_HDMI, tv_mod);    	gdisp.screen[sel].b_out_interlace = Disp_get_screen_scan_mode(tv_mod);    	gdisp.screen[sel].status |= HDMI_ON;        gdisp.screen[sel].lcdc_status |= LCDC_TCON1_USED;        gdisp.screen[sel].output_type = DISP_OUTPUT_TYPE_HDMI;        Disp_set_out_interlace(sel);#ifdef __LINUX_OSAL__        Display_set_fb_timming(sel);#endif    }        return DIS_SUCCESS;}

s32 disp_sync_all(u32 screen_id){	struct disp_manager *mgr;	struct disp_smcl *smcl;	struct disp_smbl *smbl;#if defined(CONFIG_ARCH_SUN9IW1P1)	struct disp_cursor *cursor;#endif	mgr = disp_get_layer_manager(screen_id);	if(!mgr) {		DE_WRN("get mgr%d fail/n", screen_id);	}	if(mgr->sync)		mgr->sync(mgr);	smcl = disp_get_smcl(screen_id);	if(!smcl) {		//DE_WRN("get smcl %d fail/n", screen_id);	} else {		if(smcl->sync)			smcl->sync(smcl);		}	smbl = disp_get_smbl(screen_id);	if(!smbl) {		//DE_WRN("get smbl%d fail/n", screen_id);	} else {		if(smbl->sync)			smbl->sync(smbl);		}#if defined(CONFIG_ARCH_SUN9IW1P1)	cursor = disp_get_cursor(screen_id);	if(!cursor) {		//DE_WRN("get cursor%d fail/n", screen_id);	} else {		if(cursor->sync)			cursor->sync(cursor);		}#endif	return 0;}

static s32 lcd_clk_config(struct disp_lcd* lcd){	u32 lcd_dclk_freq;	//Hz	u32 pll_freq = 0;	struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);	if((NULL == lcd) || (NULL == lcdp)) {		DE_WRN("NULL hdl!/n");		return -1;	}	lcd_dclk_freq = lcdp->panel_info.lcd_dclk_freq * 1000000;	if ((lcdp->panel_info.lcd_if == LCD_IF_HV) || (lcdp->panel_info.lcd_if == LCD_IF_CPU)	    || (lcdp->panel_info.lcd_if == LCD_IF_EDP))	{		lcdp->lcd_clk.clk_div = 6;//todo?	}	else if(lcdp->panel_info.lcd_if == LCD_IF_LVDS) {		lcdp->lcd_clk.clk_div = 7;	}	else if(lcdp->panel_info.lcd_if == LCD_IF_DSI) {		u32 lane = lcdp->panel_info.lcd_dsi_lane;		u32 bitwidth = 0;		switch(lcdp->panel_info.lcd_dsi_format) {			case LCD_DSI_FORMAT_RGB888:			bitwidth = 24;			break;			case LCD_DSI_FORMAT_RGB666:			bitwidth = 24;			break;			case LCD_DSI_FORMAT_RGB565:			bitwidth = 16;			break;			case LCD_DSI_FORMAT_RGB666P://todo?			bitwidth = 18;			break;		}		lcdp->lcd_clk.clk_div = bitwidth/lane;	}	pll_freq = lcd_dclk_freq * (lcdp->lcd_clk.clk_div);	set_src_freq(lcdp->lcd_clk.clk_src, pll_freq);	return 0;}

__s32 bsp_disp_hdmi_check_support_mode(__u32 screen_id, __u8  mode){	if(disp_hdmi_get_support(screen_id) && (gdisp.screen[screen_id].hdmi_used)	    && (gdisp.init_para.hdmi_mode_support)) {		if(gdisp.screen[screen_id].hdmi_test_mode < DISP_TV_MODE_NUM)	{			if(mode == gdisp.screen[screen_id].hdmi_test_mode) {				return 1;			} else {				return 0;			}		} else {			return gdisp.init_para.hdmi_mode_support(mode);		}	}	else {		DE_WRN("hdmi_mode_support is NULL/n");		return DIS_NOT_SUPPORT;	}}

s32 disp_vdevice_unregister(struct disp_device *vdevice){	struct disp_vdevice_private_data *vdevicep;	if(NULL == vdevice) {		DE_WRN("null hdl/n");		return DIS_FAIL;	}	disp_device_unset_manager(vdevice);	disp_device_unregister(vdevice);	vdevice->exit(vdevice);	vdevicep = (struct disp_vdevice_private_data *)vdevice->priv_data;	disp_sys_free((void*)vdevice);	disp_sys_free((void*)vdevicep);	return 0;}

static s32 hdmi_clk_disable(struct disp_hdmi *hdmi){	struct disp_hdmi_private_data *hdmip = disp_hdmi_get_priv(hdmi);	if(!hdmi || !hdmip) {	    DE_WRN("hdmi clk init null hdl!/n");	    return DIS_FAIL;	}	disp_al_hdmi_disable(hdmi->channel_id);	hdmip->lcd_clk.h_clk = OSAL_CCMU_OpenMclk(hdmip->lcd_clk.clk);	OSAL_CCMU_MclkOnOff(hdmip->lcd_clk.h_clk, CLK_OFF);	OSAL_CCMU_CloseMclk(hdmip->lcd_clk.h_clk);	if(hdmip->drc_clk.clk)		disp_al_hdmi_clk_disable(hdmip->drc_clk.clk);	return 0;}

s32 lcd_clk_init(struct disp_lcd* lcd){	struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);	if((NULL == lcd) || (NULL == lcdp)) {		DE_WRN("NULL hdl!/n");		return -1;	}	mod_clk_set_src(lcdp->lcd_clk.clk, lcdp->lcd_clk.clk_src);	if(LCD_IF_LVDS == lcdp->panel_info.lcd_if) {	} else if(LCD_IF_DSI == lcdp->panel_info.lcd_if) {		mod_clk_set_src(lcdp->dsi_clk.clk, lcdp->dsi_clk.clk_src);	} else if(LCD_IF_EDP == lcdp->panel_info.lcd_if) {	}	return DIS_SUCCESS;}

__s32 BSP_disp_hdmi_set_src(__u32 sel, __disp_lcdc_src_t src){    switch (src)    {        case DISP_LCDC_SRC_DE_CH1:            tcon1_src_select(sel, LCDC_SRC_BE0);            break;        case DISP_LCDC_SRC_DE_CH2:            tcon1_src_select(sel, LCDC_SRC_BE1);            break;        case DISP_LCDC_SRC_BLUE:            tcon1_src_select(sel, LCDC_SRC_BLUE);            break;        default:            DE_WRN("not supported lcdc src:%d in BSP_disp_tv_set_src/n", src);            return DIS_NOT_SUPPORT;    }    return DIS_SUCCESS;}

/* returns: us */s32 bsp_disp_get_next_vb_time(void){	u32 cur_line;	u32 num_screens, screen_id;	disp_video_timing tt;	u32 next_time = 16000;	num_screens = bsp_disp_feat_get_num_screens();	for(screen_id=0; screen_id<num_screens; screen_id++) {		if(bsp_disp_get_output_type(screen_id) == DISP_OUTPUT_TYPE_LCD) {			struct disp_lcd* lcd;			u32 time_per_line = 0;			static disp_panel_para info;			cur_line = disp_al_lcd_get_cur_line(screen_id);			lcd = disp_get_lcd(screen_id);			if(!lcd) {				DE_WRN("get lcd%d fail/n", screen_id);			}			memset(&info, 0, sizeof(disp_panel_para));			if(lcd && lcd->get_panel_info)				lcd->get_panel_info(lcd, &info);			if(LCD_IF_EDP != info.lcd_if) {				if(lcd && lcd->get_timing) {					u32 fps = 0;					lcd->get_timing(lcd, &tt);					if((tt.ver_total_time != 0) && (tt.hor_total_time != 0))						fps = tt.pixel_clk*1000/(tt.ver_total_time*tt.hor_total_time);					fps = (0 == fps)? 60:fps;					time_per_line = 1000000 / fps / tt.ver_total_time;					next_time = (tt.ver_total_time - cur_line) * time_per_line;				}			} else {				/* EDP PANEL */				next_time = 16000;//fix to 16ms			}		} else if(bsp_disp_get_output_type(screen_id) == DISP_OUTPUT_TYPE_HDMI) {			/* FIXME: add hdmi */		}	}	return next_time;}

s32 bsp_disp_hdmi_resume(u32 screen_id){	struct disp_hdmi* hdmi;	hdmi = disp_get_hdmi(screen_id);	if(!(bsp_disp_feat_get_supported_output_types(screen_id) & DISP_OUTPUT_TYPE_HDMI))		return 0;	if(!hdmi) {		DE_WRN("get hdmi%d failed!/n", screen_id);		return DIS_FAIL;	}	if(hdmi->resume) {	  return hdmi->resume(hdmi);	}	return DIS_FAIL;}

s32 bsp_disp_layer_deinterlace_cfg(u32 screen_id){	struct disp_layer *lyr;	int layer_id, num_layer;	num_layer = bsp_disp_feat_get_num_layers(screen_id);	for(layer_id = 0; layer_id < num_layer; layer_id++) {		lyr = disp_get_layer(screen_id, layer_id);		if(!lyr || (lyr->is_enabled && !lyr->is_enabled(lyr))) {			continue;		}		if(lyr->deinterlace_cfg)			lyr->deinterlace_cfg(lyr);		else			DE_WRN("lyr deinterlace_cfg is NULL/n");	}	return 0;}

static s32 disp_vdevice_sw_enable(struct disp_device* vdevice){	struct disp_vdevice_private_data *vdevicep = disp_vdevice_get_priv(vdevice);	struct disp_manager *mgr = NULL;	if((NULL == vdevice) || (NULL == vdevicep)) {		DE_WRN("null  hdl!/n");		return DIS_FAIL;	}	mgr = vdevice->manager;	if(!mgr) {		DE_WRN("%s%d's mgr is NULL/n", vdevice->name, vdevice->disp);		return DIS_FAIL;	}	if(vdevicep->enabled == 1) {		DE_WRN("%s%d is already enabled/n", vdevice->name, vdevice->disp);		return DIS_FAIL;	}	if(vdevicep->func.get_video_timing_info == NULL) {		DE_WRN("vdevice_get_video_timing_info func is null/n");		return DIS_FAIL;	}	vdevicep->func.get_video_timing_info(&(vdevicep->video_info));	if(vdevicep->video_info == NULL) {		DE_WRN("video info is null/n");		return DIS_FAIL;	}	if(vdevicep->func.get_interface_para == NULL) {		DE_WRN("get_interface_para func is null/n");		return DIS_FAIL;	}	vdevicep->func.get_interface_para((void*)&(vdevicep->intf));	disp_sys_lock((void*)&vdevicep->mlock);	memcpy(&vdevice->timings, vdevicep->video_info, sizeof(disp_video_timings));	if(mgr->sw_enable)		mgr->sw_enable(mgr);	disp_sys_register_irq(vdevicep->irq_no,0,disp_vdevice_event_proc,(void*)vdevice,0,0);	disp_sys_enable_irq(vdevicep->irq_no);	vdevicep->enabled = 1;	disp_sys_unlock((void*)&vdevicep->mlock);	return 0;}

s32 bsp_disp_lcd_pre_disable(u32 screen_id){	struct disp_lcd* lcd;	struct disp_manager *mgr;	mgr = disp_get_layer_manager(screen_id);	lcd = disp_get_lcd(screen_id);	if(!mgr || !lcd) {		DE_WRN("get lcd%d or mgr%d fail/n", screen_id, screen_id);        return -1;	}	if(mgr->set_output_type)		mgr->set_output_type(mgr, DISP_OUTPUT_TYPE_NONE);	if(lcd->pre_disable) {		return lcd->pre_disable(lcd);	}	return DIS_FAIL;}

s32 disp_hdmi_set_func(struct disp_hdmi*  hdmi, disp_hdmi_func * func){	struct disp_hdmi_private_data *hdmip = disp_hdmi_get_priv(hdmi);	if((NULL == hdmi) || (NULL == hdmip)) {		DE_WRN("hdmi set func null  hdl!/n");		return DIS_FAIL;	}	hdmip->hdmi_func.hdmi_open = func->hdmi_open;	hdmip->hdmi_func.hdmi_close= func->hdmi_close;	hdmip->hdmi_func.hdmi_set_mode= func->hdmi_set_mode;	hdmip->hdmi_func.hdmi_mode_support= func->hdmi_mode_support;	hdmip->hdmi_func.hdmi_get_HPD_status = func->hdmi_get_HPD_status;	hdmip->hdmi_func.hdmi_get_input_csc= func->hdmi_get_input_csc;	hdmip->hdmi_func.hdmi_set_pll = func->hdmi_set_pll;	hdmip->hdmi_func.hdmi_get_video_timing_info = func->hdmi_get_video_timing_info;	hdmip->hdmi_func.hdmi_get_video_info_index = func->hdmi_get_video_info_index;	return 0;}

s32 bsp_disp_set_hdmi_func(u32 screen_id, disp_hdmi_func * func){	struct disp_hdmi* hdmi;	s32 ret = -1;	hdmi = disp_get_hdmi(screen_id);	if(!hdmi) {	    DE_WRN("get hdmi%d failed!/n", screen_id);	    return DIS_FAIL;	    }	gdisp.hdmi_registered = 1;	if(hdmi->set_func)	    ret = hdmi->set_func(hdmi, func);	if(gdisp.init_para.start_process) {		DE_INF("gdisp.init_para.start_process/n");		gdisp.init_para.start_process();	}	return ret;}

static s32 hdmi_clk_enable(struct disp_hdmi *hdmi){	struct disp_hdmi_private_data *hdmip = disp_hdmi_get_priv(hdmi);	if(!hdmi || !hdmip) {	    DE_WRN("hdmi clk init null hdl!/n");	    return DIS_FAIL;	}	if((NULL == hdmi->p_sw_init_flag) || (0 == *(hdmi->p_sw_init_flag))) {		hdmi_clk_config(hdmi);	}	if(hdmip->drc_clk.clk && ((NULL == hdmi->p_sw_init_flag) || (0 == *(hdmi->p_sw_init_flag))))		disp_al_hdmi_clk_enable(hdmip->drc_clk.clk);	if((NULL == hdmi->p_sw_init_flag) || (0 == *(hdmi->p_sw_init_flag))) {		disp_al_hdmi_enable(hdmi->channel_id);	} else {		//disp_al_hdmi_enable_sw(hdmi->channel_id);	}	return 0;}

s32 bsp_disp_lcd_post_disable(u32 screen_id){	struct disp_lcd* lcd;	struct disp_manager *mgr;	s32 ret = -1;	mgr = disp_get_layer_manager(screen_id);	lcd = disp_get_lcd(screen_id);	if(!mgr || !lcd) {		DE_WRN("get lcd%d or mgr%d fail/n", screen_id, screen_id);        return -1;	}	if(lcd->post_disable)		ret = lcd->post_disable(lcd);	if(mgr->disable)		mgr->disable(mgr);	return ret;}

s32 bsp_disp_hdmi_disable(u32 screen_id){	struct disp_hdmi* hdmi;	struct disp_manager *mgr;	hdmi = disp_get_hdmi(screen_id);	mgr = disp_get_layer_manager(screen_id);	if(!hdmi || !mgr) {		DE_WRN("get hdm%dor mgr%d failed!/n", screen_id, screen_id);		return DIS_FAIL;	    }	if(hdmi->disable)	    hdmi->disable(hdmi);	if(mgr->is_enabled && mgr->is_enabled(mgr))		mgr->disable(mgr);	if(mgr->set_output_type)		mgr->set_output_type(mgr, DISP_OUTPUT_TYPE_NONE);	return DIS_FAIL;}

__s32 BSP_disp_hdmi_close(__u32 sel){    if(gdisp.screen[sel].status & HDMI_ON)    {        __u32 scaler_index;    	if(gdisp.init_para.Hdmi_close)    	{    	    gdisp.init_para.Hdmi_close();    	}    	else    	{    	    DE_WRN("Hdmi_close is NULL/n");    	    return -1;    	}        Image_close(sel);    	TCON1_close(sel);    	image_clk_off(sel);    	lcdc_clk_off(sel);    	hdmi_clk_off();    	DE_BE_Set_Outitl_enable(sel, FALSE);        for(scaler_index=0; scaler_index<2; scaler_index++)        {            if((gdisp.scaler[scaler_index].status & SCALER_USED) && (gdisp.scaler[scaler_index].screen_index == sel))            {                Scaler_Set_Outitl(scaler_index, FALSE);            }        }        gdisp.screen[sel].b_out_interlace = 0;        gdisp.screen[sel].lcdc_status &= LCDC_TCON1_USED_MASK;    	gdisp.screen[sel].status &= HDMI_OFF;    	gdisp.screen[sel].output_type = DISP_OUTPUT_TYPE_NONE;		gdisp.screen[sel].pll_use_status &= ((gdisp.screen[sel].pll_use_status == VIDEO_PLL0_USED)? VIDEO_PLL0_USED_MASK : VIDEO_PLL1_USED_MASK);    }	return DIS_SUCCESS;}

struct disp_hdmi* disp_get_hdmi(u32 screen_id){	u32 num_screens;	num_screens = bsp_disp_feat_get_num_screens();	if(screen_id >= num_screens) {		DE_WRN("screen_id %d out of range/n", screen_id);		return NULL;	}	if(!(bsp_disp_feat_get_supported_output_types(screen_id) & DISP_OUTPUT_TYPE_HDMI)) {	    DE_INF("screen_id %d do not support HDMI TYPE!/n", screen_id);	    return NULL;	}	if(!disp_al_query_hdmi_mod(screen_id)) {		DE_INF("hdmi %d is not registered/n", screen_id);		return NULL;	}	return &hdmis[screen_id];}