omap_disp_out.c

omap3 linux 2.6 用nocc去除了冗余代码

	if (!tv_in_use)
		return 0;

	omap2_disp_get_all_clks();
	omap2_disp_disable_output_dev(OMAP2_OUTPUT_TV);
	power_tv(TV_OFF);
	omap2_disp_put_all_clks();
	tv_in_use = 0;
	return 0;
}

static int __init tv_probe(struct platform_device *odev);
static int tv_suspend(struct platform_device *odev, pm_message_t state);
static int tv_resume(struct platform_device *odev);

static struct platform_driver omap2_tv_driver = {
	.driver = {
		.name   = OMAP2_TV_DRIVER,
	},
	.probe          = tv_probe,
	.suspend        = tv_suspend,
	.resume         = tv_resume,
};

static struct platform_device tv_device = {
        .name     = OMAP24xx_TV_DEVICE,
	.id    = 10,
};

static int __init
tv_probe(struct platform_device *odev)
{
	return tv_init();
}

static int
tv_suspend(struct platform_device *odev, pm_message_t state)
{
	if (!tv_in_use)
		return 0;

	/* TODO-- need to delink DSS and TV clocks.. For now, TV is put to 
	 * off in fb_blank and put_dss */

	tv_in_use = 0;

	return 0;
}

static int
tv_resume(struct platform_device *odev)
{
	if (tv_in_use)
		return 0;

	/* TODO-- need to delink DSS and TV clocks.. For now, TV is put to 
	 * on in fb_blank and get_dss */
	tv_in_use = 1;
	return 0;
}



/*---------------------------------------------------------------------------*/
/* Sysfs support */

struct board_properties {
	struct module *owner;
};
static struct board_properties *bd;
		
struct dispc_device {
	struct board_properties *props;
	struct class_device class_dev;
};
static struct dispc_device *new_bd;


static void dispc_class_release(struct class_device *dev)
{
	if(new_bd != NULL) kfree(new_bd);
	if(bd != NULL) kfree(bd);
}

struct class dispc_class = {
	.name = "display_control",
	.release = dispc_class_release,
};

static ssize_t 
read_layer_out(char *buf, int layer)
{
	int p = 0;
	int output_dev = omap2_disp_get_output_dev(layer);

	switch (output_dev) {
		case OMAP2_OUTPUT_LCD :	
			p = sprintf(buf, "lcd\n");
			break;
		case OMAP2_OUTPUT_TV :	
			p = sprintf(buf, "tv\n");
			break;
	}
	return(p);
}

static ssize_t
write_layer_out(const char *buffer, size_t count,int layer)
{
	int out_dev;
	if (!buffer || (count == 0))
		return 0;

	/* only 'lcd' or 'tv' are valid inputs */ 
	if (strncmp(buffer, "lcd", 3) == 0)
		out_dev = OMAP2_OUTPUT_LCD;
	else if (strncmp(buffer, "tv", 2) == 0)
		out_dev = OMAP2_OUTPUT_TV;
	else
		return -EINVAL;

	if(omap2_disp_get_output_dev(layer) == out_dev)
		return count;

	omap2_disp_get_all_clks();

	if (fb_out_layer != OMAP2_GRAPHICS)
	{
		omap2_disp_disable_layer(fb_out_layer);
		omap2_disp_release_layer (fb_out_layer);
	}
	mdelay(1);
	omap2_disp_set_output_dev(layer, out_dev);
	mdelay(1);

	if(fb_out_layer != OMAP2_GRAPHICS)
		omap24xxfb_set_output_layer(fb_out_layer);
	omap2_disp_put_all_clks();
	return count;
}

static ssize_t 
graphics_show(struct class_device *cdev, char *buf)
{
	return(read_layer_out(buf,OMAP2_GRAPHICS));
}

static ssize_t
graphics_store(struct class_device *cdev, const char *buffer, size_t count)
{
	return(write_layer_out(buffer,count,OMAP2_GRAPHICS));
}

static ssize_t 
video1_show(struct class_device *cdev, char *buf)
{
	return(read_layer_out(buf,OMAP2_VIDEO1));
}

static ssize_t
video1_store(struct class_device *cdev, const char *buffer, size_t count)
{
	return(write_layer_out(buffer,count,OMAP2_VIDEO1));
}

static ssize_t 
video2_show(struct class_device *cdev, char *buf)
{
	return(read_layer_out(buf,OMAP2_VIDEO2));
}

static ssize_t
video2_store(struct class_device *cdev, const char *buffer, size_t count)
{
	return(write_layer_out(buffer,count,OMAP2_VIDEO2));
}

static ssize_t 
lcdbacklight_show(struct class_device *cdev, char *buf)
{
	int p =0;

	switch (lcd_backlight_state) {
		case LCD_ON:
			p = sprintf(buf, "on\n");
			break;
		case LCD_OFF:
			p = sprintf(buf, "off\n");
			break;
	}
	return p;
}

static ssize_t
lcdbacklight_store(struct class_device *cdev, const char *buffer, size_t count)
{
	/* 
	 * If the LCD is already in suspend state do not accept any changes to 
	 * backlight
	 */

	if (!lcd_in_use)
		return -EINVAL;

	if (!buffer || (count == 0))
		return 0;

	if (strncmp(buffer,"on",2) == 0){
		power_lcd_backlight(LCD_ON);
	}
	else if (strncmp(buffer, "off", 3) == 0){
		power_lcd_backlight(LCD_OFF);
	}
	else{
		return -EINVAL;
	}
	return count;
}

static ssize_t 
lcd_data_lines_show(struct class_device *cdev, char *buf)
{
	int p =0;
	int current_lcddatalines_state;

	current_lcddatalines_state = omap2_disp_get_lcddatalines();

	switch (current_lcddatalines_state) {
		case LCD_DATA_LINE_18BIT:
			p = sprintf(buf, "18 bits\n");
			break;
		case LCD_DATA_LINE_16BIT:
			p = sprintf(buf, "16 bits\n");
			break;
	}
	return (p);
}

static ssize_t
lcd_data_lines_store(struct class_device *cdev, const char *buffer, size_t count)
{
    int no_of_data_lines;

	if (!buffer || (count == 0))
		return 0;

	if (strncmp(buffer,"18",2) == 0)
		no_of_data_lines = LCD_DATA_LINE_18BIT;
	else if (strncmp(buffer, "16", 2) == 0)
		no_of_data_lines = LCD_DATA_LINE_16BIT;
	else
		return -EINVAL;

	omap2_disp_set_lcddatalines(no_of_data_lines);
	return count;
}

static ssize_t 
dithering_show(struct class_device *cdev, char *buf)
{
	int p=0;
	int current_dither_state;

	omap2_disp_get_dss();
	current_dither_state = omap2_disp_get_dithering();
	switch (current_dither_state) {
		case DITHERING_ON:
			p = sprintf(buf, "on\n");
			break;
		case DITHERING_OFF:
			p = sprintf(buf, "off\n");
			break;
	}
	omap2_disp_put_dss();
	return p;
}

static ssize_t
dithering_store(struct class_device *cdev, const char *buffer, size_t count)
{
	int dither_state;

	if (!buffer || (count == 0)){
		return 0;
	}
	if (strncmp(buffer,"on",2) == 0){
		dither_state = DITHERING_ON;
	}
	else if (strncmp(buffer, "off", 3) == 0){
		dither_state = DITHERING_OFF;
	}
	else
		return -EINVAL;
        omap2_disp_get_dss();
	omap2_disp_set_dithering(dither_state);
        omap2_disp_put_dss();
	return count;
}


static ssize_t 
lcd_alphablend_show(struct class_device *cdev, char *buf)
{
	int p=0;
	int alphablend_state;

	omap2_disp_get_dss();
	alphablend_state = omap2_disp_get_alphablend(OMAP2_OUTPUT_LCD);
	switch (alphablend_state) {
		case 0:
			p = sprintf(buf, "off\n");
			break;
		case 1:
			p = sprintf(buf, "on\n");
			break;
	}
	omap2_disp_put_dss();
	return p;
}

static ssize_t
lcd_alphablend_store(struct class_device *cdev, const char *buffer, size_t count)
{
	int alpha_state;

	if (!buffer || (count == 0)){
		return 0;
	}
	if (strncmp(buffer,"on",2) == 0){
		alpha_state = 1;
	}
	else if (strncmp(buffer, "off", 3) == 0){
		alpha_state = 0;
	}
	else
		return -EINVAL;
        omap2_disp_get_dss();
	omap2_disp_set_alphablend(OMAP2_OUTPUT_LCD,alpha_state);
        omap2_disp_put_dss();
	return count;
}

static ssize_t 
tv_alphablend_show(struct class_device *cdev, char *buf)
{
	int p=0;
	int alphablend_state;

	omap2_disp_get_dss();
	alphablend_state = omap2_disp_get_alphablend(OMAP2_OUTPUT_TV);
	switch (alphablend_state) {
		case 0:
			p = sprintf(buf, "off\n");
			break;
		case 1:
			p = sprintf(buf, "on\n");
			break;
	}
	omap2_disp_put_dss();
	return p;
}

static ssize_t
tv_alphablend_store(struct class_device *cdev, const char *buffer, size_t count)
{
	int alpha_state;

	if (!buffer || (count == 0)){
		return 0;
	}
	if (strncmp(buffer,"on",2) == 0){
		alpha_state = 1;
	}
	else if (strncmp(buffer, "off", 3) == 0){
		alpha_state = 0;
	}
	else
		return -EINVAL;
        omap2_disp_get_dss();
	omap2_disp_set_alphablend(OMAP2_OUTPUT_TV,alpha_state);
        omap2_disp_put_dss();
	return count;
}

static ssize_t 
gfx_global_alpha_show(struct class_device *cdev, char *buf)
{
	int p=0;
	unsigned char alphablend_value;

        omap2_disp_get_dss();
	alphablend_value = omap2_disp_get_global_alphablend_value(OMAP2_GRAPHICS);
	p= sprintf(buf, "%d \n",alphablend_value);        
	omap2_disp_put_dss();
	return p;
}

static ssize_t
gfx_global_alpha_store(struct class_device *cdev, const char *buffer, size_t count)
{
	unsigned char alpha_value;

	if (!buffer || (count == 0)){
		return 0;
	}
        
	if (sscanf(buffer,"%hhu",&alpha_value) != 1) {
		printk(KERN_ERR "gfx_global_alpha_store: Invalid value \n");	
		return -EINVAL;
	}	
	
	omap2_disp_get_dss();
	omap2_disp_set_global_alphablend_value(OMAP2_GRAPHICS,alpha_value);
        omap2_disp_put_dss();
	return count;
}

static ssize_t 
vid2_global_alpha_show(struct class_device *cdev, char *buf)
{
	int p=0;
	int alphablend_value;

        omap2_disp_get_dss();
	alphablend_value = omap2_disp_get_global_alphablend_value(OMAP2_VIDEO2);
	p= sprintf(buf, "%d \n",alphablend_value);        
	omap2_disp_put_dss();
	return p;
}

static ssize_t
vid2_global_alpha_store(struct class_device *cdev, const char *buffer, size_t count)
{
	int alpha_value;

	if (!buffer || (count == 0)){
		return 0;
	}
        
	if (sscanf(buffer,"%d",&alpha_value) != 1) {
		printk(KERN_ERR "gfx_global_alpha_store: Invalid value \n");	
		return -EINVAL;
	}	
	
	omap2_disp_get_dss();
	omap2_disp_set_global_alphablend_value(OMAP2_VIDEO2,alpha_value);
        omap2_disp_put_dss();
	return count;
}
 
static ssize_t lpr_show(struct class_device *cdev, char *buf)
{
	int p = 0;

	switch (lpr_enabled) {
		case 0:
			p = sprintf(buf, "disable\n");
			break;
		case 1:
			p = sprintf(buf, "enable\n");
			break;
	}
	return p;
}

static ssize_t lpr_store(struct class_device *cdev, const char *buffer,
			 size_t count)
{
	int rc;