コード例 #1
0
ファイル: de_fcc.c プロジェクト: Aorjoa/bootloader
int de_fcc_init(unsigned int sel, unsigned int chno, unsigned int reg_base)
{
	unsigned int fcc_base;
	void *memory;

	fcc_base = reg_base + (sel+1)*0x00100000 + FCC_OFST;	//FIXME  display path offset should be defined
	__inf("sel %d, fcc_base[%d]=0x%x\n", sel, chno, fcc_base);

	memory = disp_sys_malloc(sizeof(__fcc_reg_t));
	if(NULL == memory) {
		__wrn("malloc vep fcc[%d][%d] memory fail! size=0x%x\n", sel, chno, sizeof(__fcc_reg_t));
		return -1;
	}

	fcc_para_block[sel][chno].off		= fcc_base;
	fcc_para_block[sel][chno].val		= memory;
	fcc_para_block[sel][chno].size		= 0x48;
	fcc_para_block[sel][chno].dirty 	= 1;

	fcc_csc_block[sel][chno].off		= fcc_base + 0x50;
	fcc_csc_block[sel][chno].val		= memory + 0x50;
	fcc_csc_block[sel][chno].size		= 0x40;
	fcc_csc_block[sel][chno].dirty 		= 1;

	de_fcc_set_reg_base(sel, chno, memory);

	return 0;
}
コード例 #2
0
static void LCD_panel_init(u32 sel)
{
	disp_panel_para *panel_info = disp_sys_malloc(sizeof(disp_panel_para));
	u32 bright = 0;

	bsp_disp_get_panel_info(sel, panel_info);
	bright = bsp_disp_lcd_get_bright(sel);

	sunxi_lcd_dsi_clk_enable(sel);
	sunxi_lcd_delay_ms(5);
	sunxi_lcd_dsi_dcs_write_0para(sel,DSI_DCS_SOFT_RESET);
	sunxi_lcd_delay_ms(5);
	sunxi_lcd_dsi_gen_write_1para(sel,0xb0,0x00);
	sunxi_lcd_dsi_gen_write_5para(sel,0xb3,0x04,0x08,0x00,0x22,0x00);
	sunxi_lcd_dsi_gen_write_1para(sel,0xb4,0x0c);
	sunxi_lcd_dsi_gen_write_2para(sel,0xb6,0x3a,0xd3);
	sunxi_lcd_dsi_dcs_write_1para(sel,0x51,bright);
	sunxi_lcd_dsi_dcs_write_1para(sel,0x53,0x2c);
	sunxi_lcd_dsi_dcs_write_1para(sel,DSI_DCS_SET_PIXEL_FORMAT,0x77);
	sunxi_lcd_dsi_dcs_write_4para(sel,DSI_DCS_SET_COLUMN_ADDRESS,0x00,0x00,0x04,0xaf);
	sunxi_lcd_dsi_dcs_write_4para(sel,DSI_DCS_SET_PAGE_ADDRESS,0x00,0x00,0x07,0x7f);
	sunxi_lcd_dsi_dcs_write_0para(sel,DSI_DCS_EXIT_SLEEP_MODE);

	disp_sys_free(panel_info);

	return;
}
コード例 #3
0
static s32 vdevice_clk_config(struct disp_device *vdevice)
{
	struct disp_vdevice_private_data *vdevicep = disp_vdevice_get_priv(vdevice);
	disp_panel_para *para;
	struct lcd_clk_info clk_info;
	unsigned long pll_rate, lcd_rate, dclk_rate;//hz
	unsigned long pll_rate_set, lcd_rate_set, dclk_rate_set;//hz

	if(!vdevice || !vdevicep) {
	    DE_WRN("null hdl!\n");
	    return DIS_FAIL;
	}

	memset(&clk_info, 0, sizeof(struct lcd_clk_info));
	para = (disp_panel_para*)disp_sys_malloc(sizeof(disp_panel_para));
	dclk_rate = vdevicep->video_info->pixel_clk * (vdevicep->video_info->pixel_repeat + 1);
	para->lcd_if = vdevicep->intf.intf;
	para->lcd_dclk_freq = dclk_rate;
	disp_al_lcd_get_clk_info(vdevice->disp, &clk_info, para);
	disp_sys_free((void*)para);
	clk_info.tcon_div = 8;//fixme
	lcd_rate = dclk_rate * clk_info.tcon_div;
	pll_rate = lcd_rate * clk_info.lcd_div;
	disp_sys_clk_set_rate(vdevicep->clk_parent, pll_rate);
	pll_rate_set = disp_sys_clk_get_rate(vdevicep->clk_parent);
	lcd_rate_set = pll_rate_set / clk_info.lcd_div;
	disp_sys_clk_set_rate(vdevicep->clk, lcd_rate_set);
	lcd_rate_set = disp_sys_clk_get_rate(vdevicep->clk);
	dclk_rate_set = lcd_rate_set / clk_info.tcon_div;
	if(dclk_rate_set != dclk_rate)
		DE_WRN("pclk=%ld, cur=%ld\n", dclk_rate, dclk_rate_set);

	return 0;
}
コード例 #4
0
static void LCD_panel_init2(u32 sel)
{
	disp_panel_para *panel_info = disp_sys_malloc(sizeof(disp_panel_para));
	u8 para[9];

	bsp_disp_get_panel_info(sel, panel_info);
	sunxi_lcd_dsi_dcs_write_0para(sel,DSI_DCS_SET_DISPLAY_ON);

	sunxi_lcd_dsi_gen_write_5para(sel,0xb3,0x14,0x08,0x00,0x22,0x00);

	sunxi_lcd_dsi_gen_write_1para(sel,0xd6,0x01);
	para[0] = 0x31;
	para[1] = 0xf7;
	para[2] = 0x80;
	para[3] = 0x00;
	para[4] = panel_info->lcd_vbp-1;
	para[5] = 0x00;
	para[6] = 0x08;
	para[7] = 0x00;
	para[8] = 0x00;
	sunxi_lcd_dsi_gen_write(sel, 0xc2, para, 9);

	disp_sys_free(panel_info);

	return;
}
コード例 #5
0
ファイル: t27p06.c プロジェクト: GREYFOXRGR/BPI-M3-bsp
static void LCD_panel_exit(u32 sel)
{
	disp_panel_para *info = disp_sys_malloc(sizeof(disp_panel_para));
	bsp_disp_get_panel_info(sel, info);
	disp_sys_free(info);
	return ;
}
コード例 #6
0
ファイル: de_lti.c プロジェクト: Aorjoa/bootloader
int de_lti_init(unsigned int sel, unsigned int chno, unsigned int reg_base)
{
	unsigned int base;
	void *memory;

	base = reg_base + (sel+1)*0x00100000 + LTI_OFST;	//FIXME  display path offset should be defined
	__inf("sel %d, lti_base[%d]=0x%x\n", sel, chno, base);

	memory = disp_sys_malloc(sizeof(__lti_reg_t));
	if(NULL == memory) {
		__wrn("malloc lti[%d][%d] memory fail! size=0x%x\n", sel, chno, sizeof(__lti_reg_t));
		return -1;
	}

	lti_block[sel][chno].off			= base;
	lti_block[sel][chno].val			= memory;
	lti_block[sel][chno].size			= 0x40;
	lti_block[sel][chno].dirty 			= 0;

	de_lti_set_reg_base(sel, chno, (unsigned int)memory);

	return 0;
}
コード例 #7
0
ファイル: de_peak.c プロジェクト: Aorjoa/bootloader
int de_peak_init(unsigned int sel, unsigned int chno, unsigned int reg_base)
{
	unsigned int base;
	void *memory;

	base = reg_base + (sel+1)*0x00100000 + PEAK_OFST;	//FIXME: chno is not considered
	__inf("sel %d, peak_base[%d]=0x%x\n", sel, chno, base);

	memory = disp_sys_malloc(sizeof(__peak_reg_t));
	if(NULL == memory) {
		__wrn("malloc peak[%d][%d] memory fail! size=0x%x\n", sel, chno, sizeof(__peak_reg_t));
		return -1;
	}

	peak_block[sel][chno].off			= base;
	peak_block[sel][chno].val			= memory;
	peak_block[sel][chno].size			= 0x30;
	peak_block[sel][chno].dirty 		= 0;

	de_peak_set_reg_base(sel, chno, (unsigned int)memory);

	return 0;
}
コード例 #8
0
struct disp_device* disp_vdevice_register(disp_vdevice_init_data *data)
{
	struct disp_device *vdevice;
	struct disp_vdevice_private_data *vdevicep;

	vdevice = (struct disp_device *)disp_sys_malloc(sizeof(struct disp_device));
	if(NULL == vdevice) {
			DE_WRN("malloc memory fail!\n");
			return NULL;
	}
	vdevicep = (struct disp_vdevice_private_data *)disp_sys_malloc(sizeof(struct disp_vdevice_private_data));
	if(NULL == vdevicep) {
			DE_WRN("malloc memory fail!\n");
			disp_sys_free(vdevice);
			return NULL;
	}
#if defined(__LINUX_PLAT__)
	mutex_init(&vdevicep->mlock);
#endif

	memset(vdevice, 0, sizeof(struct disp_device));
	memcpy(&vdevice->name, data->name, 32);
	vdevice->disp = data->disp;
	vdevice->fix_timing = data->fix_timing;
	vdevice->type = data->type;
	memcpy(&vdevicep->func, &data->func, sizeof(disp_device_func));

	vdevicep->irq_no = gdisp.init_para.irq_no[DISP_MOD_LCD0 + vdevice->disp];
	switch(vdevice->disp) {
	case 0:
		vdevicep->clk = DE_LCD_CLK0;
		break;
	case 1:
		vdevicep->clk = DE_LCD_CLK1;//TCON clk
		break;
	default:
		vdevicep->clk = DE_LCD_CLK0;
	}
	vdevicep->clk_parent = DE_LCD_CLK_SRC;

	vdevice->set_manager = disp_device_set_manager;
	vdevice->unset_manager = disp_device_unset_manager;
	vdevice->get_resolution = disp_device_get_resolution;
	vdevice->get_timings = disp_device_get_timings;
	vdevice->is_interlace = disp_device_is_interlace;

	vdevice->init = disp_vdevice_init;
	vdevice->exit = disp_vdevice_exit;

	vdevice->enable = disp_vdevice_enable;
	vdevice->sw_enable = disp_vdevice_sw_enable;
	vdevice->disable = disp_vdevice_disable;
	vdevice->is_enabled = disp_vdevice_is_enabled;
	vdevice->set_mode = disp_vdevice_set_mode;
	vdevice->get_mode = disp_vdevice_get_mode;
	vdevice->check_support_mode = disp_vdevice_check_support_mode;
	vdevice->get_input_csc = disp_vdevice_get_input_csc;
	vdevice->get_input_color_range = disp_vdevice_get_input_color_range;
	vdevice->suspend = disp_vdevice_suspend;
	vdevice->resume = disp_vdevice_resume;
	vdevice->detect = disp_vdevice_detect;

	vdevice->priv_data = (void*)vdevicep;
	vdevice->init(vdevice);
	disp_device_register(vdevice);
	if(gdisp.init_para.start_process)
		gdisp.init_para.start_process();

	return vdevice;
}
コード例 #9
0
s32 disp_init_smbl(disp_bsp_init_para * para)
{
	u32 num_smbls;
	u32 disp;
	struct disp_smbl *smbl;
	struct disp_smbl_private_data *smblp;

	DE_INF("disp_init_smbl\n");

#if defined(__LINUX_PLAT__)
	spin_lock_init(&smbl_data_lock);
#endif
	num_smbls = bsp_disp_feat_get_num_screens();
	smbls = (struct disp_smbl *)disp_sys_malloc(sizeof(struct disp_smbl) * num_smbls);
	if(NULL == smbls) {
		DE_WRN("malloc memory fail!\n");
		return DIS_FAIL;
	}
	smbl_private = (struct disp_smbl_private_data *)disp_sys_malloc(sizeof(struct disp_smbl_private_data) * num_smbls);
	if(NULL == smbl_private) {
		DE_WRN("malloc memory fail!\n");
		return DIS_FAIL;
	}

	for(disp=0; disp<num_smbls; disp++) {
		smbl = &smbls[disp];
		smblp = &smbl_private[disp];
#if defined(__LINUX_PLAT__)
		mutex_init(&smblp->mlock);
#endif

		switch(disp) {
		case 0:
			smbl->name = "smbl0";
			smbl->disp = 0;

			break;
		case 1:
			smbl->name = "smbl1";
			smbl->disp = 1;

			break;
		case 2:
			smbl->name = "smbl2";
			smbl->disp = 2;

			break;
		}
		smblp->shadow_protect = para->shadow_protect;

		smbl->enable = disp_smbl_enable;
		smbl->disable = disp_smbl_disable;
		smbl->is_enabled = disp_smbl_is_enabled;
		smbl->init = disp_smbl_init;
		smbl->exit = disp_smbl_exit;
		smbl->apply = disp_smbl_apply;
		smbl->update_regs = disp_smbl_update_regs;
		smbl->sync = disp_smbl_sync;
		smbl->set_manager = disp_smbl_set_manager;
		smbl->unset_manager = disp_smbl_unset_manager;
		smbl->set_window = disp_smbl_set_window;
		smbl->get_window = disp_smbl_get_window;

		smbl->init(smbl);
	}

	return 0;
}
コード例 #10
0
ファイル: de_smbl.c プロジェクト: GREYFOXRGR/BPI-M3-bsp
int de_smbl_init(unsigned int sel, unsigned int reg_base)
{
	unsigned int base;
	void *memory;
  	unsigned int lcdgamma;
  	int  value = 1;
  	char primary_key[20];
	char sub_key[20];
  	int  ret;

	base = reg_base + (sel+1)*0x00100000 + SMBL_OFST;
	smbl_hw_base[sel] = base;

	__inf("sel %d, smbl_base=0x%x\n", sel, base);

	memory = disp_sys_malloc(sizeof(__smbl_reg_t));
	if(NULL == memory) {
		__wrn("malloc smbl[%d] memory fail! size=0x%x\n", sel, sizeof(__smbl_reg_t));
		return -1;
	}

	smbl_enable_block[sel].off			= base;
	smbl_enable_block[sel].val			= memory;
	smbl_enable_block[sel].size			= 0x4;
	smbl_enable_block[sel].dirty 		= 0;

	smbl_ctrl_block[sel].off			= base + 0x4;
	smbl_ctrl_block[sel].val			= memory + 0x4;
	smbl_ctrl_block[sel].size			= 0x38;
	smbl_ctrl_block[sel].dirty 			= 0;

	smbl_hist_block[sel].off			= base + 0x60;
	smbl_hist_block[sel].val			= memory + 0x60;
	smbl_hist_block[sel].size			= 0x20;
	smbl_hist_block[sel].dirty 			= 0;

	smbl_csc_block[sel].off				= base + 0xc0;
	smbl_csc_block[sel].val				= memory + 0xc0;
	smbl_csc_block[sel].size			= 0x30;
	smbl_csc_block[sel].dirty 			= 0;

	smbl_filter_block[sel].off			= base + 0xf0;
	smbl_filter_block[sel].val			= memory + 0xf0;
	smbl_filter_block[sel].size			= 0x110;
	smbl_filter_block[sel].dirty 		= 0;

	smbl_lut_block[sel].off				= base + 0x200;
	smbl_lut_block[sel].val				= memory + 0x200;
	smbl_lut_block[sel].size			= 0x200;
	smbl_lut_block[sel].dirty 			= 0;

	de_smbl_set_reg_base(sel, (unsigned int)memory);

 	g_smbl_status[sel] = disp_sys_malloc(sizeof(__smbl_status_t));
	if(NULL == g_smbl_status[sel]) {
		__wrn("malloc g_smbl_status[%d] memory fail! size=0x%x\n", sel, sizeof(__smbl_status_t));
		return -1;
	}

	g_smbl_status[sel]->IsEnable = 0;
	g_smbl_status[sel]->Runtime = 0;
	g_smbl_status[sel]->dimming = 256;

	sprintf(primary_key, "lcd%d_para", sel);

	ret = disp_sys_script_get_item(primary_key, "lcdgamma4iep", &value, 1);
	if(ret != 1)	{
		lcdgamma = 6; //default gamma = 2.2;
	} else {
		//DE_INF("lcdgamma4iep for lcd%d = %d.\n", sel, value);
		if(value > 30 || value < 10) {
			//DE_WRN("lcdgamma4iep for lcd%d too small or too large. default value 22 will be set. please set it between 10 and 30 to make it valid.\n",sel);
			lcdgamma = 6;//default gamma = 2.2;
		}	else {
			lcdgamma = (value - 10)/2;
		}
	}

	pttab[sel] = (unsigned int *)pwrsv_lgc_tab[128*lcdgamma];

	ret = disp_sys_script_get_item(primary_key, "smartbl_low_limit", &value, 1);
	if(ret != 1) {
		//DE_INF("smartbl_low_limit for lcd%d not exist.\n", sel);
	}	else {
		//DE_INF("smartbl_low_limit for lcd%d = %d.\n", sel, value);
		if(value > 255 || value < 20)	{
			//DE_INF("smartbl_low_limit for lcd%d too small or too large. default value 85 will be set. please set it between 20 and 255 to make it valid.\n",sel);
		}	else {
			PWRSAVE_PROC_THRES = value;
		}
	}
	sprintf(sub_key, "lcd%d_backlight", sel);
	ret = disp_sys_script_get_item("disp_init", sub_key, &value, 1);
	if(1 == ret)
		g_smbl_status[sel]->backlight = value;

	return 0;
}
コード例 #11
0
ファイル: disp_tv.c プロジェクト: Aorjoa/bootloader
s32 disp_init_tv(disp_bsp_init_para * para)  //call by disp_display
{

	s32   val;
	s32  type;

	type = disp_sys_script_get_item("tv_para", "tv_used", &val, 1);
	if(1 == type)
		g_tv_used = val;
	if(g_tv_used ) {
		__u32 num_screens;
		__u32 disp;
		struct disp_device* p_tv;
		struct disp_device_private_data* p_tvp;

		DE_WRN("[boot]disp_init_tv\n");
#if defined(__LINUX_PLAT__)
		spin_lock_init(&g_tv_data_lock);
#endif
		DE_WRN("[DISP_TV] disp_init_tv enter g_tv_used\n");
		num_screens = bsp_disp_feat_get_num_screens();
		g_ptv_devices = (struct disp_device *)disp_sys_malloc(sizeof(struct disp_device) * num_screens);
		if(NULL == g_ptv_devices) {
			DE_WRN("malloc memory fail!\n");
			return DIS_FAIL;
		}

		g_ptv_private = (struct disp_device_private_data *)disp_sys_malloc(sizeof(struct disp_device_private_data) * num_screens);
		if(NULL == g_ptv_private) {
			DE_WRN("malloc memory fail!\n");
			return DIS_FAIL;
		}

		for(disp=0; disp<num_screens; disp++) {
			p_tv = &g_ptv_devices[disp];
			p_tvp = &g_ptv_private[disp];

			if(!bsp_disp_feat_is_supported_output_types(disp, DISP_OUTPUT_TYPE_TV)) { //modify 1
			    DE_WRN("screen %d do not support TV TYPE!\n", disp);
			    continue;
			}

			p_tv->disp = disp;
			sprintf(p_tv->name, "tv%d", disp);
			p_tv->type = DISP_OUTPUT_TYPE_TV;
			p_tvp->tv_mode = DISP_TV_MOD_PAL;						//modifyed
			p_tvp->irq_no = para->irq_no[DISP_MOD_LCD0 + disp];			//modify
			p_tvp->clk = "tcon1";
			p_tvp->clk_parent = "pll_video0";

			p_tv->set_manager = disp_device_set_manager;
			p_tv->unset_manager = disp_device_unset_manager;
			p_tv->get_resolution = disp_device_get_resolution;
			p_tv->get_timings = disp_device_get_timings;

			p_tv->init =  disp_tv_init;
			p_tv->exit =  disp_tv_exit;
			p_tv->set_tv_func = disp_tv_set_func;
			p_tv->enable = disp_tv_enable;
			p_tv->disable = disp_tv_disable;
			p_tv->is_enabled = disp_tv_is_enabled;
			p_tv->set_mode = disp_tv_set_mode;
			p_tv->get_mode = disp_tv_get_mode;
			p_tv->check_support_mode = disp_tv_check_support_mode;
			p_tv->get_input_csc = disp_tv_get_input_csc;
			p_tv->detect = disp_tv_detect;
			p_tv->suspend = disp_tv_suspend;
			p_tv->resume = disp_tv_resume;
			p_tv->init(p_tv);
			if(bsp_disp_feat_is_supported_output_types(disp, DISP_OUTPUT_TYPE_TV))
				disp_device_register(p_tv);
			DE_WRN("[BOOOT_DISP_TV] disp tv device_registered\n");
		}


	}
	return 0;
}
コード例 #12
0
ファイル: disp_hdmi.c プロジェクト: carpecarp/CC-A80-u-boot
s32 disp_init_hdmi(disp_bsp_init_para * para)
{
	s32 ret;
	s32 value;
	//get sysconfig hdmi_used
	ret = disp_sys_script_get_item("hdmi_para", "hdmi_used", &value, 1);
	if(ret == 1)
		hdmi_used = value;

	if(hdmi_used) {
		u32 num_screens;
		u32 disp;
		struct disp_device* hdmi;
		struct disp_device_private_data* hdmip;

		DE_INF("disp_init_hdmi\n");
#if defined(__LINUX_PLAT__)
		spin_lock_init(&hdmi_data_lock);
#endif

		num_screens = bsp_disp_feat_get_num_screens();
		hdmis = (struct disp_device *)disp_sys_malloc(sizeof(struct disp_device) * num_screens);
		if(NULL == hdmis) {
			DE_WRN("malloc memory fail!\n");
			return DIS_FAIL;
		}

		hdmi_private = (struct disp_device_private_data *)disp_sys_malloc(sizeof(struct disp_device_private_data) * num_screens);
		if(NULL == hdmi_private) {
			DE_WRN("malloc memory fail!\n");
			return DIS_FAIL;
		}

		for(disp=0; disp<num_screens; disp++) {
			hdmi = &hdmis[disp];
			hdmip = &hdmi_private[disp];

			if(!bsp_disp_feat_is_supported_output_types(disp, DISP_OUTPUT_TYPE_HDMI)) {
			    continue;
			}

			hdmi->disp = disp;
			sprintf(hdmi->name, "hdmi%d", disp);
			hdmi->type = DISP_OUTPUT_TYPE_HDMI;
			hdmip->mode = DISP_TV_MOD_720P_50HZ;
			hdmip->irq_no = para->irq_no[DISP_MOD_LCD0 + disp];
			switch(disp) {
			case 0:
				hdmip->clk = DE_LCD_CLK0;
				break;
			case 1:
				hdmip->clk = DE_LCD_CLK1;//TCON clk
				break;
			default:
				hdmip->clk = DE_LCD_CLK0;
			}
			hdmip->clk_parent = DE_HDMI_CLK_SRC;

			hdmi->set_manager = disp_device_set_manager;
			hdmi->unset_manager = disp_device_unset_manager;
			hdmi->get_resolution = disp_device_get_resolution;
			hdmi->get_timings = disp_device_get_timings;
			hdmi->is_interlace = disp_device_is_interlace;

			hdmi->init = disp_hdmi_init;
			hdmi->exit = disp_hdmi_exit;

			hdmi->set_func = disp_hdmi_set_func;
			hdmi->enable = disp_hdmi_enable;
			hdmi->disable = disp_hdmi_disable;
			hdmi->is_enabled = disp_hdmi_is_enabled;
			hdmi->set_mode = disp_hdmi_set_mode;
			hdmi->get_mode = disp_hdmi_get_mode;
			hdmi->check_support_mode = disp_hdmi_check_support_mode;
			hdmi->get_input_csc = disp_hdmi_get_input_csc;
			hdmi->get_input_color_range = disp_hdmi_get_input_color_range;
			hdmi->suspend = disp_hdmi_suspend;
			hdmi->resume = disp_hdmi_resume;
			hdmi->detect = disp_hdmi_detect;

			if(bsp_disp_feat_is_supported_output_types(disp, DISP_OUTPUT_TYPE_HDMI)) {
				hdmi->init(hdmi);
				disp_device_register(hdmi);
			}
		}
	}
	return 0;
}
コード例 #13
0
ファイル: de_fce.c プロジェクト: zipob/OrangePI-Kernel
int de_fce_init(unsigned int sel, unsigned int chno, unsigned int reg_base)
{
    unsigned int base;
    void *memory;

    base = reg_base + (sel+1)*0x00100000 + FCE_OFST;	//FIXME  display path offset should be defined
    fce_hw_base[sel][chno] = base;

    __inf("sel %d, fce_base[%d]=0x%x\n", sel, chno, base);

    memory = disp_sys_malloc(sizeof(__fce_reg_t));
    if(NULL == memory) {
        __wrn("malloc fce[%d][%d] memory fail! size=0x%x\n", sel, chno, sizeof(__fce_reg_t));
        return -1;
    }

    fce_para_block[sel][chno].off			= base;
    fce_para_block[sel][chno].val			= memory;
    fce_para_block[sel][chno].size			= 0x34;
    fce_para_block[sel][chno].dirty 		= 0;

    fce_celut_block[sel][chno].off			= base + 0x100;
    fce_celut_block[sel][chno].val			= memory + 0x100;
    fce_celut_block[sel][chno].size		    = 0x100;
    fce_celut_block[sel][chno].dirty 		= 0;

    fce_hist_block[sel][chno].off			= base + 0x200;
    fce_hist_block[sel][chno].val			= memory + 0x200;
    fce_hist_block[sel][chno].size			= 0x400;
    fce_hist_block[sel][chno].dirty 		= 0;

    de_fce_set_reg_base(sel, chno, (unsigned int)memory);

    //hist
    g_hist_status[sel][chno] = disp_sys_malloc(sizeof(__hist_status_t));	//FIXME where to FREE?
    if(NULL == g_hist_status[sel][chno]) {
        __wrn("malloc g_hist_status[%d][%d] memory fail! size=0x%x\n", sel, chno, sizeof(__hist_status_t));
        return -1;
    }
    __inf("g_hist_status[%d][%d]=0x%x\n", sel, chno, (unsigned int)g_hist_status[sel][chno]);

    g_hist_status[sel][chno]->Runtime = 0;
    g_hist_status[sel][chno]->IsEnable = 0;
    g_hist_status[sel][chno]->TwoHistReady = 0;

    g_hist[sel][chno] = disp_sys_malloc(1024);		//FIXME where to FREE?
    if(NULL == g_hist[sel][chno]) {
        __wrn("malloc hist[%d][%d] memory fail! size=0x%x\n", sel, chno, 1024);
        return -1;
    }

    g_hist_p[sel][chno] = disp_sys_malloc(1024);	//FIXME where to FREE?
    if(NULL == g_hist_p[sel][chno]) {
        __wrn("malloc hist_p[%d][%d] memory fail! size=0x%x\n", sel, chno, 1024);
        return -1;
    }

    //ce
    g_ce_status[sel][chno] = disp_sys_malloc(sizeof(__ce_status_t));	//FIXME where to FREE?
    if(NULL == g_ce_status[sel][chno]) {
        __wrn("malloc g_ce_status[%d][%d] memory fail! size=0x%x\n", sel, chno, sizeof(__ce_status_t));
        return -1;
    }

    g_ce_status[sel][chno]->IsEnable = 0;

    g_celut[sel][chno] = disp_sys_malloc(256);	//FIXME where to FREE?
    if(NULL == g_celut[sel][chno]) {
        __wrn("malloc celut[%d][%d] memory fail! size=0x%x\n", sel, chno, 256);
        return -1;
    }

    return 0;
}
コード例 #14
0
s32 disp_init_enhance(disp_bsp_init_para * para)
{
	u32 num_enhances;
	u32 disp;
	struct disp_enhance *enhance;
	struct disp_enhance_private_data *enhancep;

	DE_INF("disp_init_enhance\n");

#if defined(__LINUX_PLAT__)
	spin_lock_init(&enhance_data_lock);
#endif
	num_enhances = bsp_disp_feat_get_num_screens();//bsp_disp_feat_get_num_smart_backlights();
	enhances = (struct disp_enhance *)disp_sys_malloc(sizeof(struct disp_enhance) * num_enhances);
	if(NULL == enhances) {
		DE_WRN("malloc memory fail!\n");
		return DIS_FAIL;
	}
	enhance_private = (struct disp_enhance_private_data *)disp_sys_malloc(sizeof(struct disp_enhance_private_data) * num_enhances);
	if(NULL == enhance_private) {
		DE_WRN("malloc memory fail!\n");
		return DIS_FAIL;
	}

	for(disp=0; disp<num_enhances; disp++) {
		enhance = &enhances[disp];
		enhancep = &enhance_private[disp];

		switch(disp) {
		case 0:
			enhance->name = "enhance0";
			enhance->disp = 0;
			break;
		case 1:
			enhance->name = "enhance1";
			enhance->disp = 1;
			break;
		case 2:
			enhance->name = "enhance2";
			enhance->disp = 2;

			break;
		}
		enhancep->shadow_protect = para->shadow_protect;

		enhance->enable = disp_enhance_enable;
		enhance->disable = disp_enhance_disable;
		enhance->is_enabled = disp_enhance_is_enabled;
		enhance->init = disp_enhance_init;
		enhance->exit = disp_enhance_exit;
		enhance->apply = disp_enhance_apply;
		enhance->update_regs = disp_enhance_update_regs;
		enhance->force_apply = disp_enhance_force_apply;
		enhance->sync = disp_enhance_sync;
		enhance->set_manager = disp_enhance_set_manager;
		enhance->unset_manager = disp_enhance_unset_manager;
		//enhance->set_para = disp_enhance_set_para;
#if 0
		enhance->set_bright = disp_enhance_set_bright;
		enhance->set_saturation = disp_enhance_set_saturation;
		enhance->set_hue = disp_enhance_set_hue;
		//enhance->set_contrast = disp_enhance_set_contrast;
		enhance->set_mode = disp_enhance_set_mode;
		enhance->set_window = disp_enhance_set_window;
#endif

		enhance->init(enhance);
	}

	return 0;
}