[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / video / omap / lcd_ams_delta.c

/*
 * Based on drivers/video/omap/lcd_inn1510.c
 *
 * LCD panel support for the Amstrad E3 (Delta) videophone.
 *
 * Copyright (C) 2006 Jonathan McDowell <noodles@earth.li>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/io.h>
#include <linux/delay.h>
#include <linux/lcd.h>
#include <linux/gpio.h>

#include <mach/hardware.h>
#include <mach/board-ams-delta.h>

#include "omapfb.h"

#define AMS_DELTA_DEFAULT_CONTRAST	112

#define AMS_DELTA_MAX_CONTRAST		0x00FF
#define AMS_DELTA_LCD_POWER		0x0100


/* LCD class device section */

static int ams_delta_lcd;

static int ams_delta_lcd_set_power(struct lcd_device *dev, int power)
{
	if (power == FB_BLANK_UNBLANK) {
		if (!(ams_delta_lcd & AMS_DELTA_LCD_POWER)) {
			omap_writeb(ams_delta_lcd & AMS_DELTA_MAX_CONTRAST,
					OMAP_PWL_ENABLE);
			omap_writeb(1, OMAP_PWL_CLK_ENABLE);
			ams_delta_lcd |= AMS_DELTA_LCD_POWER;
		}
	} else {
		if (ams_delta_lcd & AMS_DELTA_LCD_POWER) {
			omap_writeb(0, OMAP_PWL_ENABLE);
			omap_writeb(0, OMAP_PWL_CLK_ENABLE);
			ams_delta_lcd &= ~AMS_DELTA_LCD_POWER;
		}
	}
	return 0;
}

static int ams_delta_lcd_set_contrast(struct lcd_device *dev, int value)
{
	if ((value >= 0) && (value <= AMS_DELTA_MAX_CONTRAST)) {
		omap_writeb(value, OMAP_PWL_ENABLE);
		ams_delta_lcd &= ~AMS_DELTA_MAX_CONTRAST;
		ams_delta_lcd |= value;
	}
	return 0;
}

#ifdef CONFIG_LCD_CLASS_DEVICE
static int ams_delta_lcd_get_power(struct lcd_device *dev)
{
	if (ams_delta_lcd & AMS_DELTA_LCD_POWER)
		return FB_BLANK_UNBLANK;
	else
		return FB_BLANK_POWERDOWN;
}

static int ams_delta_lcd_get_contrast(struct lcd_device *dev)
{
	if (!(ams_delta_lcd & AMS_DELTA_LCD_POWER))
		return 0;

	return ams_delta_lcd & AMS_DELTA_MAX_CONTRAST;
}

static struct lcd_ops ams_delta_lcd_ops = {
	.get_power = ams_delta_lcd_get_power,
	.set_power = ams_delta_lcd_set_power,
	.get_contrast = ams_delta_lcd_get_contrast,
	.set_contrast = ams_delta_lcd_set_contrast,
};
#endif


/* omapfb panel section */

static const struct gpio _gpios[] = {
	{
		.gpio	= AMS_DELTA_GPIO_PIN_LCD_VBLEN,
		.flags	= GPIOF_OUT_INIT_LOW,
		.label	= "lcd_vblen",
	},
	{
		.gpio	= AMS_DELTA_GPIO_PIN_LCD_NDISP,
		.flags	= GPIOF_OUT_INIT_LOW,
		.label	= "lcd_ndisp",
	},
};

static int ams_delta_panel_init(struct lcd_panel *panel,
		struct omapfb_device *fbdev)
{
	return gpio_request_array(_gpios, ARRAY_SIZE(_gpios));
}

static void ams_delta_panel_cleanup(struct lcd_panel *panel)
{
	gpio_free_array(_gpios, ARRAY_SIZE(_gpios));
}

static int ams_delta_panel_enable(struct lcd_panel *panel)
{
	gpio_set_value(AMS_DELTA_GPIO_PIN_LCD_NDISP, 1);
	gpio_set_value(AMS_DELTA_GPIO_PIN_LCD_VBLEN, 1);
	return 0;
}

static void ams_delta_panel_disable(struct lcd_panel *panel)
{
	gpio_set_value(AMS_DELTA_GPIO_PIN_LCD_VBLEN, 0);
	gpio_set_value(AMS_DELTA_GPIO_PIN_LCD_NDISP, 0);
}

static unsigned long ams_delta_panel_get_caps(struct lcd_panel *panel)
{
	return 0;
}

static struct lcd_panel ams_delta_panel = {
	.name		= "ams-delta",
	.config		= 0,

	.bpp		= 12,
	.data_lines	= 16,
	.x_res		= 480,
	.y_res		= 320,
	.pixel_clock	= 4687,
	.hsw		= 3,
	.hfp		= 1,
	.hbp		= 1,
	.vsw		= 1,
	.vfp		= 0,
	.vbp		= 0,
	.pcd		= 0,
	.acb		= 37,

	.init		= ams_delta_panel_init,
	.cleanup	= ams_delta_panel_cleanup,
	.enable		= ams_delta_panel_enable,
	.disable	= ams_delta_panel_disable,
	.get_caps	= ams_delta_panel_get_caps,
};


/* platform driver section */

static int ams_delta_panel_probe(struct platform_device *pdev)
{
	struct lcd_device *lcd_device = NULL;
#ifdef CONFIG_LCD_CLASS_DEVICE
	int ret;

	lcd_device = lcd_device_register("omapfb", &pdev->dev, NULL,
						&ams_delta_lcd_ops);

	if (IS_ERR(lcd_device)) {
		ret = PTR_ERR(lcd_device);
		dev_err(&pdev->dev, "failed to register device\n");
		return ret;
	}

	platform_set_drvdata(pdev, lcd_device);
	lcd_device->props.max_contrast = AMS_DELTA_MAX_CONTRAST;
#endif

	ams_delta_lcd_set_contrast(lcd_device, AMS_DELTA_DEFAULT_CONTRAST);
	ams_delta_lcd_set_power(lcd_device, FB_BLANK_UNBLANK);

	omapfb_register_panel(&ams_delta_panel);
	return 0;
}

static int ams_delta_panel_remove(struct platform_device *pdev)
{
	return 0;
}

static int ams_delta_panel_suspend(struct platform_device *pdev,
		pm_message_t mesg)
{
	return 0;
}

static int ams_delta_panel_resume(struct platform_device *pdev)
{
	return 0;
}

static struct platform_driver ams_delta_panel_driver = {
	.probe		= ams_delta_panel_probe,
	.remove		= ams_delta_panel_remove,
	.suspend	= ams_delta_panel_suspend,
	.resume		= ams_delta_panel_resume,
	.driver		= {
		.name	= "lcd_ams_delta",
		.owner	= THIS_MODULE,
	},
};

module_platform_driver(ams_delta_panel_driver);
Commit	Line	Data
92e0ed07 JM	1	/*
	2	* Based on drivers/video/omap/lcd_inn1510.c
	3	*
	4	* LCD panel support for the Amstrad E3 (Delta) videophone.
	5	*
	6	* Copyright (C) 2006 Jonathan McDowell <noodles@earth.li>
	7	*
	8	* This program is free software; you can redistribute it and/or modify it
	9	* under the terms of the GNU General Public License as published by the
	10	* Free Software Foundation; either version 2 of the License, or (at your
	11	* option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful, but
	14	* WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	* General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License along
	19	* with this program; if not, write to the Free Software Foundation, Inc.,
	20	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	21	*/
	22
	23	#include <linux/module.h>
	24	#include <linux/platform_device.h>
	25	#include <linux/io.h>
	26	#include <linux/delay.h>
e7210327	27	#include <linux/lcd.h>
a218d19f	28	#include <linux/gpio.h>
92e0ed07	29
0adcbaf7	30	#include <mach/hardware.h>
e27e35ec	31	#include <mach/board-ams-delta.h>
91773a00 TV	32
91773a00 TV	33	#include "omapfb.h"
92e0ed07 JM	34
	35	#define AMS_DELTA_DEFAULT_CONTRAST 112
	36
e7210327 JK	37	#define AMS_DELTA_MAX_CONTRAST 0x00FF
	38	#define AMS_DELTA_LCD_POWER 0x0100
	39
	40
	41	/* LCD class device section */
	42
	43	static int ams_delta_lcd;
	44
	45	static int ams_delta_lcd_set_power(struct lcd_device *dev, int power)
	46	{
	47	if (power == FB_BLANK_UNBLANK) {
	48	if (!(ams_delta_lcd & AMS_DELTA_LCD_POWER)) {
	49	omap_writeb(ams_delta_lcd & AMS_DELTA_MAX_CONTRAST,
	50	OMAP_PWL_ENABLE);
	51	omap_writeb(1, OMAP_PWL_CLK_ENABLE);
	52	ams_delta_lcd \|= AMS_DELTA_LCD_POWER;
	53	}
	54	} else {
	55	if (ams_delta_lcd & AMS_DELTA_LCD_POWER) {
	56	omap_writeb(0, OMAP_PWL_ENABLE);
	57	omap_writeb(0, OMAP_PWL_CLK_ENABLE);
	58	ams_delta_lcd &= ~AMS_DELTA_LCD_POWER;
	59	}
	60	}
	61	return 0;
	62	}
	63
	64	static int ams_delta_lcd_set_contrast(struct lcd_device *dev, int value)
	65	{
	66	if ((value >= 0) && (value <= AMS_DELTA_MAX_CONTRAST)) {
	67	omap_writeb(value, OMAP_PWL_ENABLE);
	68	ams_delta_lcd &= ~AMS_DELTA_MAX_CONTRAST;
	69	ams_delta_lcd \|= value;
	70	}
	71	return 0;
	72	}
	73
	74	#ifdef CONFIG_LCD_CLASS_DEVICE
	75	static int ams_delta_lcd_get_power(struct lcd_device *dev)
	76	{
	77	if (ams_delta_lcd & AMS_DELTA_LCD_POWER)
	78	return FB_BLANK_UNBLANK;
	79	else
	80	return FB_BLANK_POWERDOWN;
	81	}
	82
	83	static int ams_delta_lcd_get_contrast(struct lcd_device *dev)
	84	{
	85	if (!(ams_delta_lcd & AMS_DELTA_LCD_POWER))
	86	return 0;
	87
	88	return ams_delta_lcd & AMS_DELTA_MAX_CONTRAST;
	89	}
	90
	91	static struct lcd_ops ams_delta_lcd_ops = {
	92	.get_power = ams_delta_lcd_get_power,
	93	.set_power = ams_delta_lcd_set_power,
	94	.get_contrast = ams_delta_lcd_get_contrast,
	95	.set_contrast = ams_delta_lcd_set_contrast,
	96	};
	97	#endif
	98
	99
	100	/* omapfb panel section */
101
da564a05	102	static const struct gpio _gpios[] = {
a218d19f JK	103	{
	104	.gpio = AMS_DELTA_GPIO_PIN_LCD_VBLEN,
	105	.flags = GPIOF_OUT_INIT_LOW,
	106	.label = "lcd_vblen",
	107	},
	108	{
	109	.gpio = AMS_DELTA_GPIO_PIN_LCD_NDISP,
	110	.flags = GPIOF_OUT_INIT_LOW,
	111	.label = "lcd_ndisp",
	112	},
	113	};
	114
92e0ed07 JM	115	static int ams_delta_panel_init(struct lcd_panel *panel,
	116	struct omapfb_device *fbdev)
	117	{
a218d19f	118	return gpio_request_array(_gpios, ARRAY_SIZE(_gpios));
92e0ed07 JM	119	}
	120
	121	static void ams_delta_panel_cleanup(struct lcd_panel *panel)
	122	{
a218d19f	123	gpio_free_array(_gpios, ARRAY_SIZE(_gpios));
92e0ed07 JM	124	}
	125
	126	static int ams_delta_panel_enable(struct lcd_panel *panel)
	127	{
a218d19f JK	128	gpio_set_value(AMS_DELTA_GPIO_PIN_LCD_NDISP, 1);
a218d19f JK	129	gpio_set_value(AMS_DELTA_GPIO_PIN_LCD_VBLEN, 1);
92e0ed07 JM	130	return 0;
	131	}
	132
	133	static void ams_delta_panel_disable(struct lcd_panel *panel)
	134	{
a218d19f JK	135	gpio_set_value(AMS_DELTA_GPIO_PIN_LCD_VBLEN, 0);
a218d19f JK	136	gpio_set_value(AMS_DELTA_GPIO_PIN_LCD_NDISP, 0);
92e0ed07 JM	137	}
	138
	139	static unsigned long ams_delta_panel_get_caps(struct lcd_panel *panel)
	140	{
	141	return 0;
	142	}
	143
	144	static struct lcd_panel ams_delta_panel = {
	145	.name = "ams-delta",
	146	.config = 0,
	147
	148	.bpp = 12,
	149	.data_lines = 16,
	150	.x_res = 480,
	151	.y_res = 320,
	152	.pixel_clock = 4687,
	153	.hsw = 3,
	154	.hfp = 1,
	155	.hbp = 1,
	156	.vsw = 1,
	157	.vfp = 0,
	158	.vbp = 0,
	159	.pcd = 0,
	160	.acb = 37,
	161
	162	.init = ams_delta_panel_init,
	163	.cleanup = ams_delta_panel_cleanup,
	164	.enable = ams_delta_panel_enable,
	165	.disable = ams_delta_panel_disable,
	166	.get_caps = ams_delta_panel_get_caps,
	167	};
	168
e7210327 JK	169
	170	/* platform driver section */
	171
92e0ed07 JM	172	static int ams_delta_panel_probe(struct platform_device *pdev)
92e0ed07 JM	173	{
e7210327 JK	174	struct lcd_device *lcd_device = NULL;
	175	#ifdef CONFIG_LCD_CLASS_DEVICE
	176	int ret;
	177
	178	lcd_device = lcd_device_register("omapfb", &pdev->dev, NULL,
	179	&ams_delta_lcd_ops);
	180
	181	if (IS_ERR(lcd_device)) {
	182	ret = PTR_ERR(lcd_device);
	183	dev_err(&pdev->dev, "failed to register device\n");
	184	return ret;
	185	}
	186
	187	platform_set_drvdata(pdev, lcd_device);
	188	lcd_device->props.max_contrast = AMS_DELTA_MAX_CONTRAST;
	189	#endif
	190
	191	ams_delta_lcd_set_contrast(lcd_device, AMS_DELTA_DEFAULT_CONTRAST);
	192	ams_delta_lcd_set_power(lcd_device, FB_BLANK_UNBLANK);
	193
92e0ed07 JM	194	omapfb_register_panel(&ams_delta_panel);
	195	return 0;
	196	}
	197
	198	static int ams_delta_panel_remove(struct platform_device *pdev)
	199	{
	200	return 0;
	201	}
	202
	203	static int ams_delta_panel_suspend(struct platform_device *pdev,
	204	pm_message_t mesg)
	205	{
	206	return 0;
	207	}
	208
	209	static int ams_delta_panel_resume(struct platform_device *pdev)
	210	{
	211	return 0;
	212	}
	213
f9905441	214	static struct platform_driver ams_delta_panel_driver = {
92e0ed07 JM	215	.probe = ams_delta_panel_probe,
	216	.remove = ams_delta_panel_remove,
	217	.suspend = ams_delta_panel_suspend,
	218	.resume = ams_delta_panel_resume,
	219	.driver = {
	220	.name = "lcd_ams_delta",
	221	.owner = THIS_MODULE,
	222	},
	223	};
	224
f806f9b6	225	module_platform_driver(ams_delta_panel_driver);