[deliverable/linux.git] / drivers / video / cobalt_lcdfb.c

/*
 *  Cobalt server LCD frame buffer driver.
 *
 *  Copyright (C) 2008  Yoichi Yuasa <yuasa@linux-mips.org>
 *
 *  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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
#include <linux/delay.h>
#include <linux/fb.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/ioport.h>
#include <linux/uaccess.h>
#include <linux/platform_device.h>
#include <linux/module.h>

/*
 * Cursor position address
 * \X  0    1    2  ...  14   15
 * Y+----+----+----+---+----+----+
 * 0|0x00|0x01|0x02|...|0x0e|0x0f|
 *  +----+----+----+---+----+----+
 * 1|0x40|0x41|0x42|...|0x4e|0x4f|
 *  +----+----+----+---+----+----+
 */
#define LCD_DATA_REG_OFFSET	0x10
#define LCD_XRES_MAX		16
#define LCD_YRES_MAX		2
#define LCD_CHARS_MAX		32

#define LCD_CLEAR		0x01
#define LCD_CURSOR_MOVE_HOME	0x02
#define LCD_RESET		0x06
#define LCD_OFF			0x08
#define LCD_CURSOR_OFF		0x0c
#define LCD_CURSOR_BLINK_OFF	0x0e
#define LCD_CURSOR_ON		0x0f
#define LCD_ON			LCD_CURSOR_ON
#define LCD_CURSOR_MOVE_LEFT	0x10
#define LCD_CURSOR_MOVE_RIGHT	0x14
#define LCD_DISPLAY_LEFT	0x18
#define LCD_DISPLAY_RIGHT	0x1c
#define LCD_PRERESET		0x3f	/* execute 4 times continuously */
#define LCD_BUSY		0x80

#define LCD_GRAPHIC_MODE	0x40
#define LCD_TEXT_MODE		0x80
#define LCD_CUR_POS_MASK	0x7f

#define LCD_CUR_POS(x)		((x) & LCD_CUR_POS_MASK)
#define LCD_TEXT_POS(x)		((x) | LCD_TEXT_MODE)

static inline void lcd_write_control(struct fb_info *info, u8 control)
{
	writel((u32)control << 24, info->screen_base);
}

static inline u8 lcd_read_control(struct fb_info *info)
{
	return readl(info->screen_base) >> 24;
}

static inline void lcd_write_data(struct fb_info *info, u8 data)
{
	writel((u32)data << 24, info->screen_base + LCD_DATA_REG_OFFSET);
}

static inline u8 lcd_read_data(struct fb_info *info)
{
	return readl(info->screen_base + LCD_DATA_REG_OFFSET) >> 24;
}

static int lcd_busy_wait(struct fb_info *info)
{
	u8 val = 0;
	int timeout = 10, retval = 0;

	do {
		val = lcd_read_control(info);
		val &= LCD_BUSY;
		if (val != LCD_BUSY)
			break;

		if (msleep_interruptible(1))
			return -EINTR;

		timeout--;
	} while (timeout);

	if (val == LCD_BUSY)
		retval = -EBUSY;

	return retval;
}

static void lcd_clear(struct fb_info *info)
{
	int i;

	for (i = 0; i < 4; i++) {
		udelay(150);

		lcd_write_control(info, LCD_PRERESET);
	}

	udelay(150);

	lcd_write_control(info, LCD_CLEAR);

	udelay(150);

	lcd_write_control(info, LCD_RESET);
}

static struct fb_fix_screeninfo cobalt_lcdfb_fix __devinitdata = {
	.id		= "cobalt-lcd",
	.type		= FB_TYPE_TEXT,
	.type_aux	= FB_AUX_TEXT_MDA,
	.visual		= FB_VISUAL_MONO01,
	.line_length	= LCD_XRES_MAX,
	.accel		= FB_ACCEL_NONE,
};

static ssize_t cobalt_lcdfb_read(struct fb_info *info, char __user *buf,
				 size_t count, loff_t *ppos)
{
	char src[LCD_CHARS_MAX];
	unsigned long pos;
	int len, retval = 0;

	pos = *ppos;
	if (pos >= LCD_CHARS_MAX || count == 0)
		return 0;

	if (count > LCD_CHARS_MAX)
		count = LCD_CHARS_MAX;

	if (pos + count > LCD_CHARS_MAX)
		count = LCD_CHARS_MAX - pos;

	for (len = 0; len < count; len++) {
		retval = lcd_busy_wait(info);
		if (retval < 0)
			break;

		lcd_write_control(info, LCD_TEXT_POS(pos));

		retval = lcd_busy_wait(info);
		if (retval < 0)
			break;

		src[len] = lcd_read_data(info);
		if (pos == 0x0f)
			pos = 0x40;
		else
			pos++;
	}

	if (retval < 0 && signal_pending(current))
		return -ERESTARTSYS;

	if (copy_to_user(buf, src, len))
		return -EFAULT;

	*ppos += len;

	return len;
}

static ssize_t cobalt_lcdfb_write(struct fb_info *info, const char __user *buf,
				  size_t count, loff_t *ppos)
{
	char dst[LCD_CHARS_MAX];
	unsigned long pos;
	int len, retval = 0;

	pos = *ppos;
	if (pos >= LCD_CHARS_MAX || count == 0)
		return 0;

	if (count > LCD_CHARS_MAX)
		count = LCD_CHARS_MAX;

	if (pos + count > LCD_CHARS_MAX)
		count = LCD_CHARS_MAX - pos;

	if (copy_from_user(dst, buf, count))
		return -EFAULT;

	for (len = 0; len < count; len++) {
		retval = lcd_busy_wait(info);
		if (retval < 0)
			break;

		lcd_write_control(info, LCD_TEXT_POS(pos));

		retval = lcd_busy_wait(info);
		if (retval < 0)
			break;

		lcd_write_data(info, dst[len]);
		if (pos == 0x0f)
			pos = 0x40;
		else
			pos++;
	}

	if (retval < 0 && signal_pending(current))
		return -ERESTARTSYS;

	*ppos += len;

	return len;
}

static int cobalt_lcdfb_blank(int blank_mode, struct fb_info *info)
{
	int retval;

	retval = lcd_busy_wait(info);
	if (retval < 0)
		return retval;

	switch (blank_mode) {
	case FB_BLANK_UNBLANK:
		lcd_write_control(info, LCD_ON);
		break;
	default:
		lcd_write_control(info, LCD_OFF);
		break;
	}

	return 0;
}

static int cobalt_lcdfb_cursor(struct fb_info *info, struct fb_cursor *cursor)
{
	u32 x, y;
	int retval;

	switch (cursor->set) {
	case FB_CUR_SETPOS:
		x = cursor->image.dx;
		y = cursor->image.dy;
		if (x >= LCD_XRES_MAX || y >= LCD_YRES_MAX)
			return -EINVAL;

		retval = lcd_busy_wait(info);
		if (retval < 0)
			return retval;

		lcd_write_control(info,
				  LCD_TEXT_POS(info->fix.line_length * y + x));
		break;
	default:
		return -EINVAL;
	}

	retval = lcd_busy_wait(info);
	if (retval < 0)
		return retval;

	if (cursor->enable)
		lcd_write_control(info, LCD_CURSOR_ON);
	else
		lcd_write_control(info, LCD_CURSOR_OFF);

	return 0;
}

static struct fb_ops cobalt_lcd_fbops = {
	.owner		= THIS_MODULE,
	.fb_read	= cobalt_lcdfb_read,
	.fb_write	= cobalt_lcdfb_write,
	.fb_blank	= cobalt_lcdfb_blank,
	.fb_cursor	= cobalt_lcdfb_cursor,
};

static int __devinit cobalt_lcdfb_probe(struct platform_device *dev)
{
	struct fb_info *info;
	struct resource *res;
	int retval;

	info = framebuffer_alloc(0, &dev->dev);
	if (!info)
		return -ENOMEM;

	res = platform_get_resource(dev, IORESOURCE_MEM, 0);
	if (!res) {
		framebuffer_release(info);
		return -EBUSY;
	}

	info->screen_size = resource_size(res);
	info->screen_base = ioremap(res->start, info->screen_size);
	info->fbops = &cobalt_lcd_fbops;
	info->fix = cobalt_lcdfb_fix;
	info->fix.smem_start = res->start;
	info->fix.smem_len = info->screen_size;
	info->pseudo_palette = NULL;
	info->par = NULL;
	info->flags = FBINFO_DEFAULT;

	retval = register_framebuffer(info);
	if (retval < 0) {
		iounmap(info->screen_base);
		framebuffer_release(info);
		return retval;
	}

	platform_set_drvdata(dev, info);

	lcd_clear(info);

	printk(KERN_INFO "fb%d: Cobalt server LCD frame buffer device\n",
		info->node);

	return 0;
}

static int __devexit cobalt_lcdfb_remove(struct platform_device *dev)
{
	struct fb_info *info;

	info = platform_get_drvdata(dev);
	if (info) {
		iounmap(info->screen_base);
		unregister_framebuffer(info);
		framebuffer_release(info);
	}

	return 0;
}

static struct platform_driver cobalt_lcdfb_driver = {
	.probe	= cobalt_lcdfb_probe,
	.remove	= __devexit_p(cobalt_lcdfb_remove),
	.driver	= {
		.name	= "cobalt-lcd",
		.owner	= THIS_MODULE,
	},
};

static int __init cobalt_lcdfb_init(void)
{
	return platform_driver_register(&cobalt_lcdfb_driver);
}

static void __exit cobalt_lcdfb_exit(void)
{
	platform_driver_unregister(&cobalt_lcdfb_driver);
}

module_init(cobalt_lcdfb_init);
module_exit(cobalt_lcdfb_exit);

MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Yoichi Yuasa");
MODULE_DESCRIPTION("Cobalt server LCD frame buffer driver");
Commit	Line	Data
5abe3b40 YY	1	/*
	2	* Cobalt server LCD frame buffer driver.
	3	*
ada8e951	4	* Copyright (C) 2008 Yoichi Yuasa <yuasa@linux-mips.org>
5abe3b40 YY	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	19	*/
	20	#include <linux/delay.h>
	21	#include <linux/fb.h>
	22	#include <linux/init.h>
	23	#include <linux/io.h>
	24	#include <linux/ioport.h>
	25	#include <linux/uaccess.h>
	26	#include <linux/platform_device.h>
355b200b	27	#include <linux/module.h>
5abe3b40 YY	28
	29	/*
	30	* Cursor position address
	31	* \X 0 1 2 ... 14 15
	32	* Y+----+----+----+---+----+----+
	33	* 0\|0x00\|0x01\|0x02\|...\|0x0e\|0x0f\|
	34	* +----+----+----+---+----+----+
	35	* 1\|0x40\|0x41\|0x42\|...\|0x4e\|0x4f\|
	36	* +----+----+----+---+----+----+
	37	*/
	38	#define LCD_DATA_REG_OFFSET 0x10
	39	#define LCD_XRES_MAX 16
	40	#define LCD_YRES_MAX 2
	41	#define LCD_CHARS_MAX 32
	42
	43	#define LCD_CLEAR 0x01
	44	#define LCD_CURSOR_MOVE_HOME 0x02
	45	#define LCD_RESET 0x06
	46	#define LCD_OFF 0x08
	47	#define LCD_CURSOR_OFF 0x0c
	48	#define LCD_CURSOR_BLINK_OFF 0x0e
	49	#define LCD_CURSOR_ON 0x0f
	50	#define LCD_ON LCD_CURSOR_ON
	51	#define LCD_CURSOR_MOVE_LEFT 0x10
	52	#define LCD_CURSOR_MOVE_RIGHT 0x14
	53	#define LCD_DISPLAY_LEFT 0x18
	54	#define LCD_DISPLAY_RIGHT 0x1c
	55	#define LCD_PRERESET 0x3f /* execute 4 times continuously */
	56	#define LCD_BUSY 0x80
	57
	58	#define LCD_GRAPHIC_MODE 0x40
	59	#define LCD_TEXT_MODE 0x80
	60	#define LCD_CUR_POS_MASK 0x7f
	61
	62	#define LCD_CUR_POS(x) ((x) & LCD_CUR_POS_MASK)
	63	#define LCD_TEXT_POS(x) ((x) \| LCD_TEXT_MODE)
	64
	65	static inline void lcd_write_control(struct fb_info *info, u8 control)
	66	{
	67	writel((u32)control << 24, info->screen_base);
	68	}
	69
	70	static inline u8 lcd_read_control(struct fb_info *info)
	71	{
	72	return readl(info->screen_base) >> 24;
	73	}
	74
	75	static inline void lcd_write_data(struct fb_info *info, u8 data)
	76	{
	77	writel((u32)data << 24, info->screen_base + LCD_DATA_REG_OFFSET);
	78	}
	79
	80	static inline u8 lcd_read_data(struct fb_info *info)
	81	{
	82	return readl(info->screen_base + LCD_DATA_REG_OFFSET) >> 24;
	83	}
	84
	85	static int lcd_busy_wait(struct fb_info *info)
	86	{
	87	u8 val = 0;
	88	int timeout = 10, retval = 0;
	89
	90	do {
	91	val = lcd_read_control(info);
92	val &= LCD_BUSY;
93	if (val != LCD_BUSY)
94	break;
95
96	if (msleep_interruptible(1))
97	return -EINTR;
98
99	timeout--;
100	} while (timeout);
101
102	if (val == LCD_BUSY)
103	retval = -EBUSY;
104
105	return retval;
106	}
107
108	static void lcd_clear(struct fb_info *info)
109	{
110	int i;
111
112	for (i = 0; i < 4; i++) {
113	udelay(150);
114
115	lcd_write_control(info, LCD_PRERESET);
116	}
117
118	udelay(150);
119
120	lcd_write_control(info, LCD_CLEAR);
121
122	udelay(150);
123
124	lcd_write_control(info, LCD_RESET);
125	}
126
7d7fb0e6	127	static struct fb_fix_screeninfo cobalt_lcdfb_fix __devinitdata = {
5abe3b40 YY	128	.id = "cobalt-lcd",
	129	.type = FB_TYPE_TEXT,
	130	.type_aux = FB_AUX_TEXT_MDA,
	131	.visual = FB_VISUAL_MONO01,
	132	.line_length = LCD_XRES_MAX,
	133	.accel = FB_ACCEL_NONE,
	134	};
	135
	136	static ssize_t cobalt_lcdfb_read(struct fb_info info, char __user buf,
	137	size_t count, loff_t *ppos)
	138	{
	139	char src[LCD_CHARS_MAX];
	140	unsigned long pos;
	141	int len, retval = 0;
	142
	143	pos = *ppos;
	144	if (pos >= LCD_CHARS_MAX \|\| count == 0)
	145	return 0;
	146
	147	if (count > LCD_CHARS_MAX)
	148	count = LCD_CHARS_MAX;
	149
	150	if (pos + count > LCD_CHARS_MAX)
	151	count = LCD_CHARS_MAX - pos;
	152
	153	for (len = 0; len < count; len++) {
	154	retval = lcd_busy_wait(info);
	155	if (retval < 0)
	156	break;
	157
	158	lcd_write_control(info, LCD_TEXT_POS(pos));
	159
	160	retval = lcd_busy_wait(info);
	161	if (retval < 0)
	162	break;
	163
	164	src[len] = lcd_read_data(info);
	165	if (pos == 0x0f)
	166	pos = 0x40;
	167	else
	168	pos++;
	169	}
	170
	171	if (retval < 0 && signal_pending(current))
	172	return -ERESTARTSYS;
	173
	174	if (copy_to_user(buf, src, len))
	175	return -EFAULT;
	176
	177	*ppos += len;
	178
	179	return len;
	180	}
	181
	182	static ssize_t cobalt_lcdfb_write(struct fb_info info, const char __user buf,
	183	size_t count, loff_t *ppos)
	184	{
	185	char dst[LCD_CHARS_MAX];
	186	unsigned long pos;
	187	int len, retval = 0;
	188
	189	pos = *ppos;
	190	if (pos >= LCD_CHARS_MAX \|\| count == 0)
	191	return 0;
192
193	if (count > LCD_CHARS_MAX)
194	count = LCD_CHARS_MAX;
195
196	if (pos + count > LCD_CHARS_MAX)
197	count = LCD_CHARS_MAX - pos;
198
199	if (copy_from_user(dst, buf, count))
200	return -EFAULT;
201
202	for (len = 0; len < count; len++) {
203	retval = lcd_busy_wait(info);
204	if (retval < 0)
205	break;
206
207	lcd_write_control(info, LCD_TEXT_POS(pos));
208
209	retval = lcd_busy_wait(info);
210	if (retval < 0)
211	break;
212
213	lcd_write_data(info, dst[len]);
214	if (pos == 0x0f)
215	pos = 0x40;
216	else
217	pos++;
218	}
219
220	if (retval < 0 && signal_pending(current))
221	return -ERESTARTSYS;
222
223	*ppos += len;
224
225	return len;
226	}
227
228	static int cobalt_lcdfb_blank(int blank_mode, struct fb_info *info)
229	{
230	int retval;
231
232	retval = lcd_busy_wait(info);
233	if (retval < 0)
234	return retval;
235
236	switch (blank_mode) {
237	case FB_BLANK_UNBLANK:
238	lcd_write_control(info, LCD_ON);
239	break;
240	default:
241	lcd_write_control(info, LCD_OFF);
242	break;
243	}
244
245	return 0;
246	}
247
248	static int cobalt_lcdfb_cursor(struct fb_info info, struct fb_cursor cursor)
249	{
250	u32 x, y;
251	int retval;
252
253	switch (cursor->set) {
254	case FB_CUR_SETPOS:
255	x = cursor->image.dx;
256	y = cursor->image.dy;
257	if (x >= LCD_XRES_MAX \|\| y >= LCD_YRES_MAX)
258	return -EINVAL;
259
260	retval = lcd_busy_wait(info);
261	if (retval < 0)
262	return retval;
263
264	lcd_write_control(info,
265	LCD_TEXT_POS(info->fix.line_length * y + x));
266	break;
267	default:
268	return -EINVAL;
269	}
270
271	retval = lcd_busy_wait(info);
272	if (retval < 0)
273	return retval;
274
275	if (cursor->enable)
276	lcd_write_control(info, LCD_CURSOR_ON);
277	else
278	lcd_write_control(info, LCD_CURSOR_OFF);
279
280	return 0;
281	}
282
283	static struct fb_ops cobalt_lcd_fbops = {
284	.owner = THIS_MODULE,
285	.fb_read = cobalt_lcdfb_read,
286	.fb_write = cobalt_lcdfb_write,
287	.fb_blank = cobalt_lcdfb_blank,
288	.fb_cursor = cobalt_lcdfb_cursor,
289	};
290
c2e13037	291	static int __devinit cobalt_lcdfb_probe(struct platform_device *dev)
5abe3b40 YY	292	{
	293	struct fb_info *info;
	294	struct resource *res;
	295	int retval;
	296
	297	info = framebuffer_alloc(0, &dev->dev);
	298	if (!info)
	299	return -ENOMEM;
	300
	301	res = platform_get_resource(dev, IORESOURCE_MEM, 0);
	302	if (!res) {
	303	framebuffer_release(info);
	304	return -EBUSY;
	305	}
	306
28f65c11	307	info->screen_size = resource_size(res);
5abe3b40 YY	308	info->screen_base = ioremap(res->start, info->screen_size);
	309	info->fbops = &cobalt_lcd_fbops;
	310	info->fix = cobalt_lcdfb_fix;
	311	info->fix.smem_start = res->start;
	312	info->fix.smem_len = info->screen_size;
	313	info->pseudo_palette = NULL;
	314	info->par = NULL;
	315	info->flags = FBINFO_DEFAULT;
	316
	317	retval = register_framebuffer(info);
	318	if (retval < 0) {
	319	iounmap(info->screen_base);
	320	framebuffer_release(info);
	321	return retval;
	322	}
	323
	324	platform_set_drvdata(dev, info);
	325
	326	lcd_clear(info);
	327
	328	printk(KERN_INFO "fb%d: Cobalt server LCD frame buffer device\n",
	329	info->node);
	330
	331	return 0;
	332	}
	333
	334	static int __devexit cobalt_lcdfb_remove(struct platform_device *dev)
	335	{
	336	struct fb_info *info;
	337
	338	info = platform_get_drvdata(dev);
	339	if (info) {
	340	iounmap(info->screen_base);
	341	unregister_framebuffer(info);
	342	framebuffer_release(info);
	343	}
	344
	345	return 0;
	346	}
	347
	348	static struct platform_driver cobalt_lcdfb_driver = {
	349	.probe = cobalt_lcdfb_probe,
	350	.remove = __devexit_p(cobalt_lcdfb_remove),
	351	.driver = {
	352	.name = "cobalt-lcd",
	353	.owner = THIS_MODULE,
	354	},
	355	};
	356
	357	static int __init cobalt_lcdfb_init(void)
	358	{
	359	return platform_driver_register(&cobalt_lcdfb_driver);
	360	}
	361
	362	static void __exit cobalt_lcdfb_exit(void)
	363	{
	364	platform_driver_unregister(&cobalt_lcdfb_driver);
	365	}
	366
	367	module_init(cobalt_lcdfb_init);
	368	module_exit(cobalt_lcdfb_exit);
	369
	370	MODULE_LICENSE("GPL v2");
	371	MODULE_AUTHOR("Yoichi Yuasa");
372	MODULE_DESCRIPTION("Cobalt server LCD frame buffer driver");