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