Пример #1
0
static int hdmi_remove(struct platform_device *pdev)
{
	__inf("hdmi_remove call\n");

	Hdmi_exit(pdev);

	return 0;
}
Пример #2
0
__s32 Hdmi_close(void)
{
	__inf("[Hdmi_close]\n");

	Hdmi_hal_video_enable(0);
	bopen = 0;
	return 0;
}
Пример #3
0
__s32 OSAL_CCMU_MclkReset(__hdle hMclk, __s32 bReset)
{
	struct clk *hModClk = (struct clk *)hMclk;

	__inf("OSAL_CCMU_MclkReset<%s,%d>\n", clk_name(hModClk), bReset);

	return clk_reset(hModClk, bReset);
}
Пример #4
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);
}
int OSAL_Script_FetchParser_Data(char *main_name, char *sub_name, int value[], int count)
{
        script_item_u   val;
        script_item_value_type_e  type;
        int ret = -1;

        if(count == 1)
        {
                type = script_get_item(main_name, sub_name, &val);
                if(SCIRPT_ITEM_VALUE_TYPE_INT == type)
                {
                        ret = 0;
                        *value = val.val;
                        __inf("%s.%s=%d\n", main_name, sub_name, *value);
                }
                else
                {
                        ret = -1;
                        __inf("fetch script data %s.%s fail\n", main_name, sub_name);
                }
        }
        else if(count == sizeof(disp_gpio_set_t)/sizeof(int))
        {
                type = script_get_item(main_name, sub_name, &val);
                if(SCIRPT_ITEM_VALUE_TYPE_PIO == type)
                {
                        disp_gpio_set_t *gpio_info = (disp_gpio_set_t *)value;

                        ret = 0;
                        gpio_info->gpio = val.gpio.gpio;
                        gpio_info->mul_sel = val.gpio.mul_sel;
                        gpio_info->pull = val.gpio.pull;
                        gpio_info->drv_level = val.gpio.drv_level;
                        gpio_info->data = val.gpio.data;
                        memcpy(gpio_info->gpio_name, sub_name, strlen(sub_name)+1);
                        __inf("%s.%s gpio=%d,mul_sel=%d,data:%d\n",main_name, sub_name, gpio_info->gpio, gpio_info->mul_sel, gpio_info->data);
                }
                else
                {
                        ret = -1;
                        __inf("fetch script data %s.%s fail\n", main_name, sub_name);
                }
        }

        return ret;
}
Пример #6
0
__s32 Hdmi_hal_set_display_mode(__u32 hdmi_mode)
{
	__inf("Hdmi_hal_set_display_mode = %x\n",hdmi_mode);
	if(hdmi_mode != get_video_mode()) {
		video_config(hdmi_mode);
	}
	return 0;
}
Пример #7
0
static int disp_remove(struct platform_device *pdev)
{
	__inf("disp_remove call\n");

	platform_set_drvdata(pdev, NULL);

	return 0;
}
Пример #8
0
static void __exit hdmi_module_exit(void)
{
    __inf("hdmi_module_exit\n");
    platform_driver_unregister(&hdmi_driver);
    platform_device_unregister(&hdmi_device);
    class_destroy(hdmi_class);
    cdev_del(my_cdev);
}
Пример #9
0
static int __init hdmi_probe(struct platform_device *pdev)
{
	__inf("hdmi_probe call\n");
	memset(&ghdmi, 0, sizeof(hdmi_info_t));
	ghdmi.dev = &pdev->dev;
	Hdmi_init();
	return 0;
}
Пример #10
0
int ir_cut_sys_gpio_request(ir_cut_gpio_set_t *gpio_list, u32 group_count_max)
{
	int ret = 0;
	struct gpio_config pin_cfg;
	char   pin_name[32];
	u32 config;

	if(gpio_list == NULL)
		return 0;

	pin_cfg.gpio = gpio_list->gpio;
	pin_cfg.mul_sel = gpio_list->mul_sel;
	pin_cfg.pull = gpio_list->pull;
	pin_cfg.drv_level = gpio_list->drv_level;
	pin_cfg.data = gpio_list->data;
	ret = gpio_request(pin_cfg.gpio, NULL);
	if(0 != ret) {
		__wrn("%s failed, gpio_name=%s, gpio=%d, ret=%d\n", __func__, gpio_list->gpio_name, gpio_list->gpio, ret);
		return ret;
	} else {
		__inf("%s, gpio_name=%s, gpio=%d, ret=%d\n", __func__, gpio_list->gpio_name, gpio_list->gpio, ret);
	}
	ret = pin_cfg.gpio;

	if (!IS_AXP_PIN(pin_cfg.gpio)) {
		/* valid pin of sunxi-pinctrl,
		* config pin attributes individually.
		*/
		sunxi_gpio_to_name(pin_cfg.gpio, pin_name);
		config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_FUNC, pin_cfg.mul_sel);
		pin_config_set(SUNXI_PINCTRL, pin_name, config);
		if (pin_cfg.pull != GPIO_PULL_DEFAULT) {
			config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_PUD, pin_cfg.pull);
			pin_config_set(SUNXI_PINCTRL, pin_name, config);
		}
		if (pin_cfg.drv_level != GPIO_DRVLVL_DEFAULT) {
			config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_DRV, pin_cfg.drv_level);
			pin_config_set(SUNXI_PINCTRL, pin_name, config);
		}
		if (pin_cfg.data != GPIO_DATA_DEFAULT) {
			config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_DAT, pin_cfg.data);
			pin_config_set(SUNXI_PINCTRL, pin_name, config);
		}
	} else if (IS_AXP_PIN(pin_cfg.gpio)) {
		/* valid pin of axp-pinctrl,
		* config pin attributes individually.
		*/
		sunxi_gpio_to_name(pin_cfg.gpio, pin_name);
		if (pin_cfg.data != GPIO_DATA_DEFAULT) {
			config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_DAT, pin_cfg.data);
			pin_config_set(AXP_PINCTRL, pin_name, config);
		}
	} else {
		pr_warn("invalid pin [%d] from sys-config\n", pin_cfg.gpio);
	}

	return ret;
}
Пример #11
0
__s32 video_config(__u32 vic)
{
//	cts_enable = 1;
//  isHDMI = 1;
//  YCbCr444_Support = 0;
//  hdcp_enable = 1;

	__inf("video_config, vic:%d,cts_enable:%d,isHDMI:%d,YCbCr444_Support:%d,hdcp_enable:%d\n",
    vic,cts_enable,isHDMI,YCbCr444_Support,hdcp_enable);

	video_info.vic = vic;
	if((cts_enable==1) && (isHDMI == 0))
  {
      video_info.is_hdmi = 0;
  }
  else
  {
      video_info.is_hdmi = 1;
  }

  if(cts_enable &&(!YCbCr444_Support))
  {
      video_info.is_yuv = 0;
  }
  else
  {
      video_info.is_yuv = 0; //fixme, 1
  }

  if((video_enable == 1) && (hdcp_enable == 1))
  {
			video_info.is_hdcp = 1;

      __inf("hdmi full function\n");
  }
  else if(video_enable==1)
  {
      video_info.is_hdcp = 0;

      __inf("hdmi video + audio\n");
  }

  sunxi_video_config(&video_info);
	return 0;
}
Пример #12
0
__s32 GetFileListInfo(__hdle hConfig, const char *secName,
                      char *type, char *SrcPath, char *DesPath)
{
    __u32 ret;
    if ((NULL == hConfig) || (NULL == secName) || 
        (NULL == type) || (NULL == SrcPath) || (NULL == DesPath))
    {
        return EPDK_FAIL;
    }
    
    /* get filelist type information */
    ret = GetKeyString((HCONFIG)hConfig, 
                       (s8 *)secName, 
                       (s8 *)FILE_LIST_TYPE_NAME, 
                       (s8 *)type);
    if (ret != OK)
    {
        __inf("GetKeyValue failed\n");
        return EPDK_FAIL;
    }

    /* get filelist source path information */
    ret = GetKeyString((HCONFIG)hConfig, 
                       (s8 *)secName, 
                       (s8 *)FILE_LIST_SRC_PATH_NAME, 
                       (s8 *)SrcPath);
    if (ret != OK)
    {
        __inf("GetKeyValue failed\n");
        return EPDK_FAIL;
    }
    
    /* get filelist dest path information */
    ret = GetKeyString((HCONFIG)hConfig, 
                       (s8 *)secName, 
                       (s8 *)FILE_LIST_DES_PATH_NAME, 
                       (s8 *)DesPath);
    if (ret != OK)
    {
        __inf("GetKeyValue failed\n");
        return EPDK_FAIL;
    }
    
    return EPDK_OK;
}
Пример #13
0
__s32 Parse_VideoData_Block(__u8 *pbuf,__u8 size)
{
	int i=0;
	while(i<size)
	{
		Device_Support_VIC[pbuf[i] &0x7f] = 1;
		if(pbuf[i] &0x80)
		{
		   __inf("Parse_VideoData_Block: VIC %d(native) support\n", pbuf[i]&0x7f);
		}
		else
		{
		   __inf("Parse_VideoData_Block: VIC %d support\n", pbuf[i]);
		}
		i++;
	}
	return 0;
}
Пример #14
0
int disp_al_smbl_apply(unsigned int disp, struct disp_smbl_info *info)
{
	static u32 count = 0;
		if(count < 10) {
			count ++;
			__inf("disp %d\n", disp);
		}
	return de_smbl_apply(disp, info);
}
Пример #15
0
__s32 Hdmi_hal_audio_enable(__u8 mode, __u8 channel)
{
	__inf("Hdmi_hal_audio_enable = %x\n",channel);
	if(channel)
		set_audio_enable(1);
	else
		set_audio_enable(0);
	return 0;
}
Пример #16
0
int disp_al_smbl_sync(unsigned int disp)
{
	static u32 count = 0;
		if(count < 10) {
			count ++;
			__inf("disp %d\n", disp);
		}
	return de_smbl_sync(disp);
}
Пример #17
0
static __s32 Hdmi_close(void)
{
	__inf("[Hdmi_close]\n");

	Hdmi_enable(0);
	ghdmi.bopen = 0;

	return 0;
}
Пример #18
0
void DDC_Init()
{
	__inf("DDC_Init\n");

    HDMI_WUINT32(0x504,HDMI_RUINT32(0x504)| 0x00000010);//set intial sequence
    HDMI_WUINT32(0x500,HDMI_RUINT32(0x500)| 0x08000000);//start
    while(HDMI_RUINT32(0x500)& 0x08000000);
    HDMI_WUINT32(0x504,HDMI_RUINT32(0x504)& 0xffffffef);//clear intial sequence
}
Пример #19
0
__s32 boot_ui_progressbar_upgrate(__hdle p, int rate)
{
    progressbar_t *progress = (progressbar_t *)p;
    int base_color, progresscolor;
    int pixel;
    int x1, y1;
    int x2, y2;

    if((rate < 0) || (rate > 100))
    {
        __inf("boot ui progressbar: invalid progressbar rate\n");
        return -1;
    }
    if(!p)
    {
        __inf("boot ui progressbar: invalid progressbar pointer\n");
        return -1;
    }
    pixel = (rate * (progress->width - progress->thick*2)/100);
    if(rate == progress->progress_ratio)
    {
        return 0;
    }
    else
    {
        x1 = progress->pr_x;
        x2 = progress->st_x + pixel;
        progresscolor = (rate > progress->progress_ratio)?(progress->progress_color):(UI_BOOT_GUI_BLACK);
        progress->pr_x  = x2;
        progress->progress_ratio = rate;

    }
    base_color = boot_ui_get_color();
    boot_ui_set_color(progresscolor);
    y1 = progress->y1 + progress->thick;
    y2 = progress->y2 - progress->thick;

    boot_ui_draw_solidrectangle(x1, y1, x2, y2);

    boot_ui_set_color(base_color);
    wlibc_FlushDCacheRegion(ui_source.screen_buf,ui_source.screen_width*ui_source.screen_height*4);

    return 0;
}
void LCD_get_panel_funs_0(__lcd_panel_fun_t * fun)
{
    __inf("LCD_get_panel_funs_0\n");
#ifdef LCD_PARA_USE_CONFIG
    fun->cfg_panel_info = LCD_cfg_panel_info;//delete this line if you want to use the lcd para define in sys_config1.fex
#endif
    fun->cfg_open_flow = LCD_open_flow;
    fun->cfg_close_flow = LCD_close_flow;
    fun->lcd_user_defined_func = LCD_user_defined_func;
}
Пример #21
0
/*
************************************************************************************************************
*
*                                             function
*
*    函数名称:
*
*    参数列表:
*
*    返回值  :
*
*    说明    :
*
*
************************************************************************************************************
*/
void power_set_usbpc(void)
{
    __inf("set pc\n");
    if(usb_ac_enable_gpio_hd)
    {
        wBoot_GPIO_Write_One_PIN_Value(usb_ac_enable_gpio_hd, 0, "usb_ac_enable_gpio");
    }
	wBoot_power_cur_limit(usbpc_cur);
	wBoot_power_vol_limit(usbpc_vol);
}
Пример #22
0
static void __exit lcd_module_exit(void)
{
	__inf("lcd_module_exit\n");

	device_destroy(g_lcd_drv.lcd_class,  g_lcd_drv.devid);

	class_destroy(g_lcd_drv.lcd_class);

	cdev_del(g_lcd_drv.lcd_cdev);
}
Пример #23
0
__s32 video_enter_lp(void)
{
	__inf("video enter lp\n");

	hdmi_state = HDMI_State_Idle;
	bsp_hdmi_standby();
	hdmi_para_reset();

	return 0;
}
Пример #24
0
__s32 set_video_enable(bool enable)
{
	int ret = 0;
	mutex_lock(&hdmi_lock);
	__inf("set_video_enable = %x!\n",enable);
	__inf("video_on @ set_video_enable = %d!\n",video_on);
	if((hdmi_state == HDMI_State_HPD_Done) && enable && (0 == video_on))
	{
		video_config(glb_video_para.vic);
		__inf("set_video_enable, vic:%d,is_hdmi:%d,is_yuv:%d,is_hcts:%d\n",
			glb_video_para.vic, glb_video_para.is_hdmi,glb_video_para.is_yuv, glb_video_para.is_hcts);
		if(bsp_hdmi_video(&glb_video_para))
	  {
	  	__wrn("set hdmi video error!\n");
	  	ret = -1;
	  	goto video_en_end;
	  }

	  bsp_hdmi_set_video_en(enable);
	  video_on = 1;

		if(((glb_audio_para.type != 1) && (true == audio_enable)) ||
			((glb_audio_para.type == 1) && (audio_cfged == true)) ) {
			if(audio_config_internal())
			{
				__wrn("set audio_config_internal error!\n");
				ret = -1;
				goto video_en_end;
			}
		}
	}
	else
	{
		video_on = 0;
		bsp_hdmi_set_video_en(enable);
	}

	video_enable = enable;

video_en_end:
	mutex_unlock(&hdmi_lock);
	return ret;
}
Пример #25
0
/*
************************************************************************************************************
*
*                                             function
*
*    函数名称:
*
*    参数列表:
*
*    返回值  :
*
*    说明    :
*
*
************************************************************************************************************
*/
int power_set_init(void)
{
    script_gpio_set_t  gpio;
    int ret;
	__inf("set pc\n");
    ret = wBoot_script_parser_fetch("usbc0", "usb_ac_enable_gpio", &gpio, 1);    
	if(ret >= 0)
	{
       usb_ac_enable_gpio_hd = wBoot_GPIO_Request(&gpio, 1);
    }
	wBoot_script_parser_fetch("pmu_para", "pmu_usbvol", &usbdc_vol, 1);
	wBoot_script_parser_fetch("pmu_para", "pmu_usbcur", &usbdc_cur, 1);
	wBoot_script_parser_fetch("pmu_para", "pmu_usbvol_pc", &usbpc_vol, 1);
	wBoot_script_parser_fetch("pmu_para", "pmu_usbcur_pc", &usbpc_cur, 1);
	__inf("usbdc_vol = %d, usbdc_cur = %d\n", usbdc_vol, usbdc_cur);
	__inf("usbpc_vol = %d, usbpc_cur = %d\n", usbpc_vol, usbpc_cur);

	return 0;
}
Пример #26
0
static void __exit lcd_module_exit(void)
{
	__inf("lcd_module_exit\n");

		device_destroy(lcd_class,  devid);

    class_destroy(lcd_class);

    cdev_del(my_cdev);
}
Пример #27
0
static void  LCD_io_exit(__u32 sel)
{
    __inf("------+++++++++++++lcd exit*************\n");

    //release SCLB gpio
    LCD_GPIO_release(sel, 0);

    //release SDAB gpio
    LCD_GPIO_release(sel, 1);
}
Пример #28
0
//hpd: 0 plugout;  1 plugin
__s32 BSP_disp_set_hdmi_hpd(__u32 hpd)
{
    if(hpd == 1)
    {
        gdisp.screen[0].hdmi_hpd = 1;
        gdisp.screen[0].hdmi_hpd = 1;
        if(gdisp.screen[0].status & HDMI_ON)
        {
            if(BSP_dsip_hdmi_get_input_csc(0) == 0)
            {
                __inf("BSP_disp_set_hdmi_hpd:   hdmi output rgb\n");
                gdisp.screen[0].output_csc_type = DISP_OUT_CSC_TYPE_HDMI_RGB;
                BSP_disp_set_output_csc(0, gdisp.screen[0].output_csc_type);
            }else
            {
                __inf("BSP_disp_set_hdmi_hpd:   hdmi output yuv\n");//default  yuv
                gdisp.screen[0].output_csc_type = DISP_OUT_CSC_TYPE_HDMI_YUV;
                BSP_disp_set_output_csc(0, gdisp.screen[0].output_csc_type);
            }
        }
        else if(gdisp.screen[1].status & HDMI_ON)
        {
            if(BSP_dsip_hdmi_get_input_csc(1) == 0)
            {
                __inf("BSP_disp_set_hdmi_hpd:   hdmi output rgb\n");
                gdisp.screen[1].output_csc_type = DISP_OUT_CSC_TYPE_HDMI_RGB;
                BSP_disp_set_output_csc(1, gdisp.screen[1].output_csc_type);
            }else
            {
                __inf("BSP_disp_set_hdmi_hpd:   hdmi output yuv\n");
                gdisp.screen[1].output_csc_type = DISP_OUT_CSC_TYPE_HDMI_YUV;//default  yuv
                BSP_disp_set_output_csc(1, gdisp.screen[1].output_csc_type);
            }
        }
    }
    else
    {
        gdisp.screen[0].hdmi_hpd = 0;
        gdisp.screen[0].hdmi_hpd = 0;
    }
    return 0;
}
Пример #29
0
__s32 OSAL_CCMU_SetSrcFreq( __u32 nSclkNo, __u32 nFreq )
{
	struct clk* hSysClk = NULL;
	s32 retCode = -1;
	__disp_clk_t *disp_clk = NULL;


	disp_clk = (__disp_clk_t*)osal_ccmu_get_clk_by_name(nSclkNo);
	if(disp_clk == NULL) {
		__wrn("Fail to get clk name from clk id [%d].\n", nSclkNo);
		return -1;
	} else if(!strcmp(disp_clk->name, "none")) {
		__inf("OSAL_CCMU_SetSrcFreq, name of clk %d is none! \n", disp_clk->id);
		return -1;
	}
	__inf("OSAL_CCMU_SetSrcFreq,  <%s,%d>\n", disp_clk->name, nFreq);

	hSysClk = clk_get(NULL, disp_clk->name);

	if(NULL == hSysClk || IS_ERR(hSysClk)) {
		__wrn("Fail to get handle for system clock %s.\n", disp_clk->name);
		return -1;
	}

	if(nFreq == clk_get_rate(hSysClk)) {
		__inf("Sys clk %s freq is alreay %d, not need to set.\n", disp_clk->name, nFreq);
		clk_put(hSysClk);
		return 0;
	}
	__inf("OSAL_CCMU_SetSrcFreq, clk hdl=0x%x\n", (int)hSysClk);

	retCode = clk_set_rate(hSysClk, nFreq);
	if(0 != retCode) {
		__wrn("Fail to set nFreq[%d] for sys clk[%d].\n", nFreq, nSclkNo);
		clk_put(hSysClk);
		return retCode;
	}
	clk_put(hSysClk);
	hSysClk = NULL;

	return retCode;
}
Пример #30
0
int disp_al_capture_sync(u32 disp)
{
	static u32 count = 0;
		if(count < 10) {
			count ++;
			__inf("disp %d\n", disp);
		}
	WB_EBIOS_Update_Regs(disp);
	WB_EBIOS_Writeback_Enable(disp, 1);
	return 0;
}