projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[ixp4xx]: refresh 2.6.36 patches
[openwrt.git] / target / linux / ep93xx / patches-2.6.30 / 002-lcd-linux-hd44780.patch
1 Index: linux-2.6.30.9/arch/arm/Kconfig
2 ===================================================================
3 --- linux-2.6.30.9.orig/arch/arm/Kconfig 2009-10-05 17:38:08.000000000 +0200
4 +++ linux-2.6.30.9/arch/arm/Kconfig 2009-11-24 02:01:42.000000000 +0100
5 @@ -1407,6 +1407,8 @@
6
7 source "drivers/accessibility/Kconfig"
8
9 +source "drivers/lcd-linux/Kconfig"
10 +
11 source "drivers/leds/Kconfig"
12
13 source "drivers/rtc/Kconfig"
14 Index: linux-2.6.30.9/drivers/Makefile
15 ===================================================================
16 --- linux-2.6.30.9.orig/drivers/Makefile 2009-10-05 17:38:08.000000000 +0200
17 +++ linux-2.6.30.9/drivers/Makefile 2009-11-24 02:01:42.000000000 +0100
18 @@ -106,4 +106,5 @@
19 obj-$(CONFIG_SSB) += ssb/
20 obj-$(CONFIG_VIRTIO) += virtio/
21 obj-$(CONFIG_STAGING) += staging/
22 +obj-$(CONFIG_LCD_LINUX) += lcd-linux/
23 obj-y += platform/
24 Index: linux-2.6.30.9/drivers/lcd-linux/Config.in
25 ===================================================================
26 --- /dev/null 1970-01-01 00:00:00.000000000 +0000
27 +++ linux-2.6.30.9/drivers/lcd-linux/Config.in 2009-11-24 02:01:42.000000000 +0100
28 @@ -0,0 +1,8 @@
29 +if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then
30 + mainmenu_option next_comment
31 + comment 'LCD support'
32 +
33 + tristate 'LCD-Linux layer' CONFIG_LCD_LINUX
34 + dep_tristate ' HD44780 controller' CONFIG_LCD_HD44780 $CONFIG_LCD_LINUX
35 + endmenu
36 +fi
37 Index: linux-2.6.30.9/drivers/lcd-linux/Kconfig
38 ===================================================================
39 --- /dev/null 1970-01-01 00:00:00.000000000 +0000
40 +++ linux-2.6.30.9/drivers/lcd-linux/Kconfig 2009-11-24 02:01:42.000000000 +0100
41 @@ -0,0 +1,33 @@
42 +menu "LCD-Linux support"
43 + depends on EXPERIMENTAL
44 +
45 +config LCD_LINUX
46 + tristate "LCD-Linux layer"
47 + default m
48 + help
49 + LCD-Linux provides an easy way to drive LCD displays under
50 + Linux by creating a character which can be read or written.
51 + It features complete VT102 emulation and recognizes
52 + many escape sequences. If you want to use it you must also
53 + choose an appropriate driver, otherwise it will not be
54 + very useful. For more information see
55 + http://lcd-linux.sourceforge.net/
56 +
57 + To compile LCD-Linux as a module, choose M here:
58 + the module will be called lcd-linux.
59 +
60 +config LCD_HD44780
61 + tristate "HD44780 controller"
62 + depends on LCD_LINUX && MACH_SIM_ONE
63 + default m
64 + help
65 + This is a LCD-Linux driver for LCD displays based on the
66 + Hitachi HD44780 (and compatible) controllers connected
67 + to the SimOne LCD port.
68 +
69 + To compile this driver as a module, choose M here:
70 + the module will be called hd44780.
71 +
72 + If unsure, say N.
73 +
74 +endmenu
75 Index: linux-2.6.30.9/drivers/lcd-linux/Makefile
76 ===================================================================
77 --- /dev/null 1970-01-01 00:00:00.000000000 +0000
78 +++ linux-2.6.30.9/drivers/lcd-linux/Makefile 2009-11-24 02:01:42.000000000 +0100
79 @@ -0,0 +1,8 @@
80 +#
81 +#
82 +# Standard Makefile to statically compile LCD-Linux into the kernel
83 +# Linux 2.6
84 +
85 +obj-$(CONFIG_LCD_LINUX) += lcd-linux.o
86 +obj-$(CONFIG_LCD_HD44780) += hd44780.o
87 +
88 Index: linux-2.6.30.9/drivers/lcd-linux/cgram/default.h
89 ===================================================================
90 --- /dev/null 1970-01-01 00:00:00.000000000 +0000
91 +++ linux-2.6.30.9/drivers/lcd-linux/cgram/default.h 2009-11-24 02:01:42.000000000 +0100
92 @@ -0,0 +1,37 @@
93 +/* default.h
94 + *
95 + *
96 + *
97 + * Default user defined characters for lcdmod.
98 + *
99 + * Copyright (C) by Michael McLellan (mikey@cs.auckland.ac.nz)
100 + *
101 + * This program is free software; you can redistribute it and/or modify
102 + * it under the terms of the GNU General Public License as published by
103 + * the Free Software Foundation; either version 2 of the License, or
104 + * (at your option) any later version.
105 + *
106 + * This program is distributed in the hope that it will be useful,
107 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
108 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
109 + * GNU General Public License for more details.
110 + *
111 + * You should have received a copy of the GNU General Public License
112 + * along with this program; if not, write to the Free Software
113 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
114 + *
115 + *
116 + */
117 +
118 +static void init_charmap(void)
119 +{
120 +}
121 +
122 +static unsigned char cg0[] = { 0x1f, 0x1f, 0x11, 0x0f, 0x11, 0x1e, 0x01, 0x1f };
123 +static unsigned char cg1[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f };
124 +static unsigned char cg2[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x1f };
125 +static unsigned char cg3[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x1f, 0x1f };
126 +static unsigned char cg4[] = { 0x00, 0x00, 0x00, 0x00, 0x1f, 0x1f, 0x1f, 0x1f };
127 +static unsigned char cg5[] = { 0x00, 0x00, 0x00, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f };
128 +static unsigned char cg6[] = { 0x00, 0x00, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f };
129 +static unsigned char cg7[] = { 0x00, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f };
130 Index: linux-2.6.30.9/drivers/lcd-linux/charmap.h
131 ===================================================================
132 --- /dev/null 1970-01-01 00:00:00.000000000 +0000
133 +++ linux-2.6.30.9/drivers/lcd-linux/charmap.h 2009-11-24 02:01:42.000000000 +0100
134 @@ -0,0 +1,79 @@
135 +/* charmap.h
136 + *
137 + *
138 + *
139 + * Character mapping for HD44780 devices by Mark Haemmerling <mail@markh.de>.
140 + *
141 + * Translates ISO 8859-1 to HD44780 charset.
142 + * HD44780 charset reference: http://markh.de/hd44780-charset.png
143 + *
144 + * Initial table taken from lcd.o Linux kernel driver by
145 + * Nils Faerber <nilsf@users.sourceforge.net>. Thanks!
146 + *
147 + * This file is released under the GNU General Public License. Refer to the
148 + * COPYING file distributed with this package.
149 + *
150 + * Following translations are being performed:
151 + * - maps umlaut accent characters to the corresponding umlaut characters
152 + * - maps other accent characters to the characters without accents
153 + * - maps beta (=ringel-S), micro and Yen
154 + *
155 + * Alternative mappings:
156 + * - #112 ("p") -> #240 (large "p"), orig. mapped -> #112
157 + * - #113 ("q") -> #241 (large "q"), orig. mapped -> #113
158 + *
159 + * HD44780 misses backslash
160 + *
161 + */
162 +
163 +static unsigned char charmap[] = {
164 +
165 +/* 0 - 31 */
166 + 0, 1, 2, 3, 4, 5, 6, 7,
167 + 8, 9, 10, 11, 12, 13, 14, 15,
168 + 16, 17, 18, 19, 20, 21, 22, 23,
169 + 24, 25, 26, 27, 28, 29, 30, 31,
170 +
171 +/* 32 - 63 */
172 + 32, 33, 34, 35, 36, 37, 38, 39,
173 + 40, 41, 42, 43, 44, 45, 46, 47,
174 + 48, 49, 50, 51, 52, 53, 54, 55,
175 + 56, 57, 58, 59, 60, 61, 62, 63,
176 +
177 +/* 64 - 95 */
178 + 64, 65, 66, 67, 68, 69, 70, 71,
179 + 72, 73, 74, 75, 76, 77, 78, 79,
180 + 80, 81, 82, 83, 84, 85, 86, 87,
181 + 88, 89, 90, 91, 47, 93, 94, 95,
182 +
183 +/* 96 - 127 */
184 + 96, 97, 98, 99, 100, 101, 102, 103,
185 +104, 105, 106, 107, 108, 109, 110, 111,
186 +112, 113, 114, 115, 116, 117, 118, 119,
187 +120, 121, 122, 123, 124, 125, 126, 127,
188 +
189 +/* 128 - 159 */
190 +128, 129, 130, 131, 132, 133, 134, 135,
191 +136, 137, 138, 139, 140, 141, 142, 143,
192 +144, 145, 146, 147, 148, 149, 150, 151,
193 +152, 153, 154, 155, 156, 157, 158, 159,
194 +
195 +/* 160 - 191 */
196 +160, 33, 236, 237, 164, 92, 124, 167,
197 + 34, 169, 170, 171, 172, 173, 174, 175,
198 +223, 177, 178, 179, 39, 249, 247, 165,
199 + 44, 185, 186, 187, 188, 189, 190, 63,
200 +
201 +/* 192 - 223 */
202 + 65, 65, 65, 65, 225, 65, 65, 67,
203 + 69, 69, 69, 69, 73, 73, 73, 73,
204 + 68, 78, 79, 79, 79, 79, 239, 120,
205 + 48, 85, 85, 85, 245, 89, 240, 226,
206 +
207 +/* 224 - 255 */
208 + 97, 97, 97, 97, 225, 97, 97, 99,
209 +101, 101, 101, 101, 105, 105, 105, 105,
210 +111, 110, 111, 111, 111, 111, 239, 253,
211 + 48, 117, 117, 117, 245, 121, 240, 255
212 +
213 +};
214 Index: linux-2.6.30.9/drivers/lcd-linux/commands.h
215 ===================================================================
216 --- /dev/null 1970-01-01 00:00:00.000000000 +0000
217 +++ linux-2.6.30.9/drivers/lcd-linux/commands.h 2009-11-24 02:01:42.000000000 +0100
218 @@ -0,0 +1,77 @@
219 +/* commands.h
220 + *
221 + *
222 + *
223 + * LCD-Linux:
224 + * Driver for HD44780 compatible displays connected to the parallel port.
225 + *
226 + * HD44780 commands.
227 + *
228 + * Copyright (C) 2004 - 2007 Mattia Jona-Lasinio (mjona@users.sourceforge.net)
229 + *
230 + * This program is free software; you can redistribute it and/or modify
231 + * it under the terms of the GNU General Public License as published by
232 + * the Free Software Foundation; either version 2 of the License, or
233 + * (at your option) any later version.
234 + *
235 + * This program is distributed in the hope that it will be useful,
236 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
237 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
238 + * GNU General Public License for more details.
239 + *
240 + * You should have received a copy of the GNU General Public License
241 + * along with this program; if not, write to the Free Software
242 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
243 + *
244 + */
245 +
246 +#ifndef HD44780_COMMANDS_H
247 +#define HD44780_COMMANDS_H
248 +
249 +/*** HD44780 Command Set ***/
250 +
251 +/* Clear Display*/
252 +#define CLR_DISP 0x01 /* Clear entire display; cursor at row 0, column 0 */
253 +
254 +/* Return Home */
255 +#define RET_HOME 0x02 /* Cursor at row 0, column 0; display content doesn't change */
256 +
257 +/* Entry Mode Set */
258 +#define ENTRY_MODE_SET 0x04
259 +#define DISP_SHIFT_ON (ENTRY_MODE_SET | 0x01) /* Shift display, not cursor after data write */
260 +#define DISP_SHIFT_OFF (ENTRY_MODE_SET | 0x00) /* Shift cursor, not display after data write */
261 +#define CURS_INC (ENTRY_MODE_SET | 0x02) /* Shift on the right after data read/write */
262 +#define CURS_DEC (ENTRY_MODE_SET | 0x00) /* Shift on the left after data read/write */
263 +
264 +/* Display on/off Control */
265 +#define DISP_ONOFF_CNTR 0x08
266 +#define BLINK_ON (DISP_ONOFF_CNTR | 0x01) /* Cursor blinking on */
267 +#define BLINK_OFF (DISP_ONOFF_CNTR | 0x00) /* Cursor blinking off */
268 +#define CURS_ON (DISP_ONOFF_CNTR | 0x02) /* Display Cursor */
269 +#define CURS_OFF (DISP_ONOFF_CNTR | 0x00) /* Hide Cursor */
270 +#define DISP_ON (DISP_ONOFF_CNTR | 0x04) /* Turn on display updating */
271 +#define DISP_OFF (DISP_ONOFF_CNTR | 0x00) /* Freeze display content */
272 +
273 +/* Cursor or Display Shift */
274 +#define CURS_DISP_SHIFT 0x10
275 +#define SHIFT_RIGHT (CURS_DISP_SHIFT | 0x04) /* Shift on the right */
276 +#define SHIFT_LEFT (CURS_DISP_SHIFT | 0x00) /* Shift on the left */
277 +#define SHIFT_DISP (CURS_DISP_SHIFT | 0x08) /* Shift display */
278 +#define SHIFT_CURS (CURS_DISP_SHIFT | 0x00) /* Shift cursor */
279 +
280 +/* Function Set */
281 +#define FUNC_SET 0x20
282 +#define FONT_5X10 (FUNC_SET | 0x04) /* Select 5x10 dots font */
283 +#define FONT_5X8 (FUNC_SET | 0x00) /* Select 5x8 dots font */
284 +#define DISP_2_LINES (FUNC_SET | 0x08) /* Select 2 lines display (only 5x8 font allowed) */
285 +#define DISP_1_LINE (FUNC_SET | 0x00) /* Select 1 line display */
286 +#define BUS_8_BITS (FUNC_SET | 0x10) /* Set 8 data bits */
287 +#define BUS_4_BITS (FUNC_SET | 0x00) /* Set 4 data bits */
288 +
289 +/* Set CGRAM Address */
290 +#define CGRAM_IO 0x40 /* Base CGRAM address */
291 +
292 +/* Set DDRAM Address */
293 +#define DDRAM_IO 0x80 /* Base DDRAM address */
294 +
295 +#endif /* commands included */
296 Index: linux-2.6.30.9/drivers/lcd-linux/config.h
297 ===================================================================
298 --- /dev/null 1970-01-01 00:00:00.000000000 +0000
299 +++ linux-2.6.30.9/drivers/lcd-linux/config.h 2009-11-24 02:01:42.000000000 +0100
300 @@ -0,0 +1,73 @@
301 +/* config.h
302 + *
303 + *
304 + *
305 + * Configure file for LCD-Linux. Here you must specify your hardware setup and
306 + * timings constants. The default values will probably be right for you.
307 + *
308 + * Copyright (C) 2005 - 2007 Mattia Jona-Lasinio (mjona@users.sourceforge.net)
309 + *
310 + * This program is free software; you can redistribute it and/or modify
311 + * it under the terms of the GNU General Public License as published by
312 + * the Free Software Foundation; either version 2 of the License, or
313 + * (at your option) any later version.
314 + *
315 + * This program is distributed in the hope that it will be useful,
316 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
317 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
318 + * GNU General Public License for more details.
319 + *
320 + * You should have received a copy of the GNU General Public License
321 + * along with this program; if not, write to the Free Software
322 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
323 + *
324 + *
325 + */
326 +
327 +/* Setup the default user defined characters in CGRAM */
328 +#include "cgram/default.h"
329 +
330 +/* Don't modify the default timing constants
331 + * unless you know what you are doing.
332 + */
333 +
334 +/* Execution times (in microseconds) */
335 +#define T_READ 60 /* Read execution time (min 43 us) */
336 +#define T_WRITE 60 /* Write execution time (min 43 us) */
337 +#define T_BF 2 /* Busy flag polling time (min 1 us) */
338 +
339 +/* Timings in nanoseconds */
340 +#define T_AS 200 /* Address set-up time (min 140 ns) */
341 +#define T_EH 500 /* Enable high time (min 450 ns) */
342 +#define T_EL 600 /* Enable low time (min 500 ns) */
343 +
344 +/* Various constants */
345 +#define DFLT_NUM_CNTR 1 /* Default number of controllers the display has */
346 +#define DFLT_CNTR_ROWS 2 /* Default number of rows per controller */
347 +#define DFLT_CNTR_COLS 16 /* Default number of columns the display has */
348 +#define DFLT_VS_ROWS 25 /* Default number of rows for the virtual screen */
349 +#define DFLT_VS_COLS 80 /* Default number of columns for the virtual screen */
350 +#define DFLT_TABSTOP 3 /* Default length of tabs */
351 +#define DFLT_FLAGS (HD44780_CHECK_BF | HD44780_4BITS_BUS ) /* Default flags */
352 +
353 +#define MAX_CNTR_ROWS 4 /* The HD44780 supports up to 4 lines as a fake 2 lines mode */
354 +#define MAX_CNTR_COLS 80 /* The HD44780 supports up to 80 characters (1*80; 2*40; etc) */
355 +
356 +#define SETUP 4
357 +#define HIGH_NIBBLE_WRITE(x) (((x) >> (4-SETUP)) & (0x0f << SETUP))
358 +#define LOW_NIBBLE_WRITE(x) (((x) << SETUP) & (0x0f << SETUP))
359 +#define HIGH_NIBBLE_READ(x) (((x) & (0x0f << SETUP)) << (4-SETUP))
360 +#define LOW_NIBBLE_READ(x) (((x) & (0x0f << SETUP)) >> SETUP)
361 +
362 +
363 +#define SIMONE_LCD_RS EP93XX_GPIO_LINE_A(2) /* OUT */
364 +#define SIMONE_LCD_RD EP93XX_GPIO_LINE_A(3) /* OUT */
365 +#define SIMONE_LCD_EN EP93XX_GPIO_LINE_B(4) /* EGPIO12 OUT */
366 +#define SIMONE_LCD_BCKLIGHT EP93XX_GPIO_LINE_B(5) /* EGPIO13 OUT */
367 +
368 +#define SIMONE_LCD_DATA0 EP93XX_GPIO_LINE_A(4)
369 +#define SIMONE_LCD_DATA1 EP93XX_GPIO_LINE_A(5)
370 +#define SIMONE_LCD_DATA2 EP93XX_GPIO_LINE_A(6)
371 +#define SIMONE_LCD_DATA3 EP93XX_GPIO_LINE_A(7)
372 +
373 +
374 Index: linux-2.6.30.9/drivers/lcd-linux/hd44780.c
375 ===================================================================
376 --- /dev/null 1970-01-01 00:00:00.000000000 +0000
377 +++ linux-2.6.30.9/drivers/lcd-linux/hd44780.c 2009-11-24 02:05:29.000000000 +0100
378 @@ -0,0 +1,860 @@
379 +/* hd44780.c
380 + *
381 + *
382 + *
383 + * LCD-Linux:
384 + * Driver for HD44780 compatible displays connected to the parallel port.
385 + *
386 + * Copyright (C) 2005 - 2007 Mattia Jona-Lasinio (mjona@users.sourceforge.net)
387 + * Adapted to Sim.One Hardware by Nuccio Raciti (raciti.nuccio@gmail.com)
388 + *
389 + * This program is free software; you can redistribute it and/or modify
390 + * it under the terms of the GNU General Public License as published by
391 + * the Free Software Foundation; either version 2 of the License, or
392 + * (at your option) any later version.
393 + *
394 + * This program is distributed in the hope that it will be useful,
395 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
396 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
397 + * GNU General Public License for more details.
398 + *
399 + * You should have received a copy of the GNU General Public License
400 + * along with this program; if not, write to the Free Software
401 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
402 + *
403 + */
404 +
405 +
406 +#include <linux/autoconf.h>
407 +
408 +
409 +#ifdef CONFIG_PROC_FS
410 +#define USE_PROC
411 +#else
412 +#undef USE_PROC
413 +#endif
414 +
415 +#include <linux/bitops.h>
416 +#include <linux/kernel.h>
417 +#include <linux/module.h>
418 +
419 +#include <linux/delay.h>
420 +#include <linux/fs.h>
421 +
422 +#include <asm/uaccess.h>
423 +#include <linux/init.h>
424 +
425 +#include <asm/io.h>
426 +#include <linux/ioport.h>
427 +#include <asm/gpio.h>
428 +
429 +#ifdef USE_PROC
430 +#include <linux/proc_fs.h>
431 +#endif
432 +
433 +#define LCD_LINUX_MAIN
434 +#include <linux/hd44780.h>
435 +
436 +#include "charmap.h"
437 +#include "commands.h"
438 +#include "config.h"
439 +
440 +/** Function prototypes **/
441 +static void read_display(unsigned char *byte, unsigned char bitmask);
442 +static void write_display(unsigned char byte, unsigned char bitmask);
443 +
444 +/* Initialization */
445 +static int hd44780_validate_driver(void);
446 +static int hd44780_init_port(void);
447 +static int hd44780_cleanup_port(void);
448 +static int hd44780_init_display(void);
449 +static int hd44780_cleanup_display(void);
450 +
451 +/* Write */
452 +static void hd44780_address_mode(int);
453 +static void hd44780_clear_display(void);
454 +static void hd44780_write_char(unsigned int, unsigned short);
455 +static void hd44780_write_cgram_char(unsigned char, unsigned char *);
456 +
457 +/* Read */
458 +static void check_bf(unsigned char);
459 +static void hd44780_read_char(unsigned int, unsigned short *);
460 +static void hd44780_read_cgram_char(unsigned char, unsigned char *);
461 +
462 +/* Input handling */
463 +static int hd44780_handle_custom_char(unsigned int);
464 +static int hd44780_handle_custom_ioctl(unsigned int,unsigned long , unsigned int);
465 +
466 +/* Proc operations */
467 +#ifdef USE_PROC
468 +static void create_proc_entries(void);
469 +static void remove_proc_entries(void);
470 +#endif
471 +
472 +/* hd44780 access */
473 +#define ACCESS_TO_READ 0
474 +#define ACCESS_TO_WRITE 1
475 +#define ACCESS_TO_DATA 2
476 +
477 +/* hd44780_flags */
478 +#define _CHECK_BF 0 /* Do busy-flag checking */
479 +#define _4BITS_BUS 1 /* The bus is 4 bits long */
480 +#define _5X10_FONT 2 /* Use 5x10 font */
481 +#define CURSOR_BLINK 3 /* Make the cursor blinking */
482 +#define SHOW_CURSOR 4 /* Make the cursor visible */
483 +#define DISPLAY_ON 5 /* Display status: on or off */
484 +#define INC_ADDR 6 /* Increment address after data read/write */
485 +#define BACKLIGHT 7 /* Display backlight: on or off */
486 +#define CGRAM_STATE 9 /* Controller status bitmask (bits 9->15): DDRAM or CGRAM access */
487 +#define ESC_MASK 0x00ff0000
488 +#define PROC_MASK 0x0f000000
489 +
490 +#define SET_STATE(state, mask) (hd44780_flags = (hd44780_flags & ~(mask)) | ((state) & (mask)))
491 +#define SET_ESC_STATE(state) SET_STATE((state) << 16, ESC_MASK)
492 +#define SET_PROC_LEVEL(level) SET_STATE((level) << 24, PROC_MASK)
493 +#define ESC_STATE ((hd44780_flags & ESC_MASK) >> 16)
494 +#define PROC_LEVEL ((hd44780_flags & PROC_MASK) >> 24)
495 +
496 +/* globals */
497 +static unsigned int disp_size; /* Display size (rows*columns) */
498 +static unsigned int disp_offset[1]; /* Physical cursor position on the display */
499 +static unsigned long hd44780_flags; /* Driver flags for internal use only */
500 +
501 +static struct lcd_parameters par = {
502 + .name = HD44780_STRING,
503 + .minor = HD44780_MINOR,
504 + .flags = DFLT_FLAGS,
505 + .tabstop = DFLT_TABSTOP,
506 + .num_cntr = 1,
507 + .cntr_rows = DFLT_CNTR_ROWS,
508 + .cntr_cols = DFLT_CNTR_COLS,
509 + .vs_rows = DFLT_VS_ROWS,
510 + .vs_cols = DFLT_VS_COLS,
511 + .cgram_chars = 8,
512 + .cgram_bytes = 8,
513 + .cgram_char0 = 0,
514 +};
515 +/* End of globals */
516 +
517 +#ifdef MODULE
518 +#include <linux/device.h>
519 +MODULE_ALIAS_CHARDEV(LCD_MAJOR, HD44780_MINOR);
520 +#include <linux/kmod.h>
521 +
522 +static unsigned short flags = DFLT_FLAGS;
523 +static unsigned short tabstop = DFLT_TABSTOP;
524 +static unsigned short cntr_rows = DFLT_CNTR_ROWS;
525 +static unsigned short cntr_cols = DFLT_CNTR_COLS;
526 +static unsigned short vs_rows = DFLT_VS_ROWS;
527 +static unsigned short vs_cols = DFLT_VS_COLS;
528 +static unsigned short minor = HD44780_MINOR;
529 +
530 +MODULE_DESCRIPTION("LCD SimOne driver for HD44780 compatible controllers.");
531 +MODULE_AUTHOR("Nuccio Raciti (raciti.nuccio@gmail.com)");
532 +#ifdef MODULE_LICENSE
533 +MODULE_LICENSE("GPL");
534 +#endif
535 +module_param(flags, ushort, 0444);
536 +module_param(cntr_rows, ushort, 0444);
537 +module_param(cntr_cols, ushort, 0444);
538 +module_param(vs_rows, ushort, 0444);
539 +module_param(vs_cols, ushort, 0444);
540 +module_param(tabstop, ushort, 0444);
541 +module_param(minor, ushort, 0444);
542 +
543 +MODULE_PARM_DESC(flags, "Various flags (see Documentation)");
544 +MODULE_PARM_DESC(cntr_rows, "Number of rows per controller on the LCD: 1, 2, 4 (default: " string(DFLT_CNTR_ROWS) ")");
545 +MODULE_PARM_DESC(cntr_cols, "Number of columns on the LCD (default: " string(DFLT_CNTR_COLS) ", max: " string(MAX_CNTR_COLS) ")");
546 +MODULE_PARM_DESC(vs_rows, "Number of rows of the virtual screen (default: " string(DFLT_VS_ROWS) ")");
547 +MODULE_PARM_DESC(vs_cols, "Number of columns of the virtual screen (default: " string(DFLT_VS_COLS) ")");
548 +MODULE_PARM_DESC(tabstop, "Tab character length (default: " string(DFLT_TABSTOP) ")");
549 +MODULE_PARM_DESC(minor, "Assigned minor number (default: " string(HD44780_MINOR) ")");
550 +#else
551 +
552 +/*
553 + * Parse boot command line
554 + *
555 + * hd44780=cntr_rows,cntr_cols,vs_rows,vs_cols,flags,minor,tabstop
556 + */
557 +static int __init hd44780_boot_init(char *cmdline)
558 +{
559 + char *str = cmdline;
560 + int idx = 0;
561 + unsigned short *args[] = {
562 + &par.cntr_rows,
563 + &par.cntr_cols,
564 + &par.vs_rows,
565 + &par.vs_cols,
566 + &par.flags,
567 + &par.num_cntr,
568 + &par.minor,
569 + &par.tabstop,
570 + };
571 +
572 + while (*cmdline && idx < (sizeof(args)/sizeof(unsigned short *))) {
573 + switch (*str) {
574 + case ',':
575 + *str++ = 0;
576 + case 0:
577 + if (strlen(cmdline))
578 + *args[idx] = simple_strtoul(cmdline, NULL, 0);
579 + ++idx;
580 + cmdline = str;
581 + break;
582 + default:
583 + ++str;
584 + break;
585 + }
586 + }
587 +
588 + return (1);
589 +}
590 +
591 +__setup("hd44780=", hd44780_boot_init);
592 +#endif /* MODULE */
593 +
594 +/* Macros for iterator handling */
595 +static inline unsigned int iterator_inc_(unsigned int iterator, const unsigned int module)
596 +{
597 + return ((++iterator)%module);
598 +}
599 +
600 +static inline unsigned int iterator_dec_(unsigned int iterator, const unsigned int module)
601 +{
602 + return (iterator ? --iterator : module-1);
603 +}
604 +
605 +#define iterator_inc(iterator, module) (iterator = iterator_inc_(iterator, module))
606 +#define iterator_dec(iterator, module) (iterator = iterator_dec_(iterator, module))
607 +
608 +static inline void set_lines(unsigned char bitmask)
609 +{
610 + gpio_set_value(SIMONE_LCD_EN, 0); /* Disable */
611 +
612 + if(bitmask & ACCESS_TO_WRITE ) {
613 + gpio_direction_output (SIMONE_LCD_DATA0 , 0);
614 + gpio_direction_output (SIMONE_LCD_DATA1 , 0);
615 + gpio_direction_output (SIMONE_LCD_DATA2 , 0);
616 + gpio_direction_output (SIMONE_LCD_DATA3 , 0);
617 + gpio_set_value(SIMONE_LCD_RD, 0); /* Write */
618 + } else {
619 +
620 + gpio_direction_input (SIMONE_LCD_DATA0);
621 + gpio_direction_input (SIMONE_LCD_DATA1);
622 + gpio_direction_input (SIMONE_LCD_DATA2);
623 + gpio_direction_input (SIMONE_LCD_DATA3);
624 + gpio_set_value(SIMONE_LCD_RD, 1); /* Read */
625 + }
626 +
627 + if(bitmask & ACCESS_TO_DATA )
628 + gpio_set_value(SIMONE_LCD_RS, 1); /* Data */
629 + else
630 + gpio_set_value(SIMONE_LCD_RS, 0); /* Cmds*/
631 +
632 + if(test_bit(BACKLIGHT, &hd44780_flags))
633 + gpio_set_value(SIMONE_LCD_BCKLIGHT, 1);
634 + else
635 + gpio_set_value(SIMONE_LCD_BCKLIGHT, 0);
636 +}
637 +
638 +
639 +/* Low level read from the display */
640 +static inline unsigned char __read_display(unsigned char bitmask)
641 +{
642 + unsigned char byte;
643 +
644 + set_lines (bitmask);
645 +
646 + ndelay(T_AS); /* Address set-up time */
647 + gpio_set_value(SIMONE_LCD_EN, 1); /* Enable */
648 + ndelay(T_EH);/* Enable high time */
649 +
650 + byte = (gpio_get_value(SIMONE_LCD_DATA0) << 4);
651 + byte |= (gpio_get_value(SIMONE_LCD_DATA1) << 5);
652 + byte |= (gpio_get_value(SIMONE_LCD_DATA2) << 6);
653 + byte |= (gpio_get_value(SIMONE_LCD_DATA3) << 7);
654 +
655 + gpio_set_value(SIMONE_LCD_EN, 0); /* Disable */
656 +
657 + ndelay(T_EL); /* Enable low time */
658 +
659 +
660 + return (byte);
661 +
662 +}
663 +
664 +/* Low level write to the display */
665 +static inline void __write_display(unsigned char data, unsigned char bitmask)
666 +{
667 + set_lines(bitmask);
668 +
669 + if(data & 0x10)
670 + gpio_set_value(SIMONE_LCD_DATA0, 1);
671 + else
672 + gpio_set_value(SIMONE_LCD_DATA0, 0);
673 +
674 + if(data & 0x20)
675 + gpio_set_value(SIMONE_LCD_DATA1, 1);
676 + else
677 + gpio_set_value(SIMONE_LCD_DATA1, 0);
678 +
679 + if(data & 0x40)
680 + gpio_set_value(SIMONE_LCD_DATA2, 1);
681 + else
682 + gpio_set_value(SIMONE_LCD_DATA2, 0);
683 +
684 + if(data & 0x80)
685 + gpio_set_value(SIMONE_LCD_DATA3, 1);
686 + else
687 + gpio_set_value(SIMONE_LCD_DATA3, 0);
688 +
689 + ndelay(T_AS); /* Address set-up time */
690 + gpio_set_value(SIMONE_LCD_EN, 1);
691 + ndelay(T_EH); /* Enable high time */
692 +
693 + gpio_set_value(SIMONE_LCD_EN, 0); /* Disable */
694 + ndelay(T_EL); /* Enable low time */
695 +}
696 +
697 +
698 +/* Read data from the display (4 bit bus, check busy flag) */
699 +static void read_display (unsigned char *byte,unsigned char bitmask)
700 +{
701 + if(bitmask) check_bf(bitmask);
702 + *byte = HIGH_NIBBLE_READ(__read_display(bitmask));
703 + if(bitmask) check_bf(bitmask);
704 + *byte |= LOW_NIBBLE_READ(__read_display(bitmask));
705 +}
706 +
707 +
708 +/* Output commands or data to the display (4 bit bus, check busy flag) */
709 +static void write_display(unsigned char byte,unsigned char bitmask)
710 +{
711 + check_bf(bitmask);
712 + __write_display(HIGH_NIBBLE_WRITE(byte),bitmask);
713 + check_bf(bitmask);
714 + __write_display(LOW_NIBBLE_WRITE(byte),bitmask);
715 +}
716 +
717 +
718 +/* Read Address Counter AC from the display */
719 +static unsigned char read_ac(unsigned char bitmask)
720 +{
721 + unsigned char byte;
722 +
723 + read_display(&byte, bitmask);
724 +
725 + return (byte);
726 +}
727 +
728 +
729 +/* Do busy-flag check */
730 +static void check_bf(unsigned char bitmask)
731 +{
732 + unsigned int timeout = 20;
733 + static unsigned char do_check_bf = 5;
734 + gpio_set_value(SIMONE_LCD_EN, 0); /* Disable */
735 +
736 + gpio_direction_input (SIMONE_LCD_DATA0);
737 + gpio_direction_input (SIMONE_LCD_DATA1);
738 + gpio_direction_input (SIMONE_LCD_DATA2);
739 + gpio_direction_input (SIMONE_LCD_DATA3);
740 +
741 + gpio_set_value(SIMONE_LCD_RD, 1); /* Read */
742 + gpio_set_value(SIMONE_LCD_RS, 0); /* Instru */
743 +
744 + ndelay(T_AS); /* Address set-up time */
745 + gpio_set_value(SIMONE_LCD_EN, 1); /* Enable */
746 + ndelay(T_EH);/* Enable high time */
747 +
748 + do{
749 + udelay(T_BF);
750 + } while (gpio_get_value(SIMONE_LCD_DATA3) && --timeout);
751 +
752 + if (! timeout) {
753 + if (! --do_check_bf) {
754 + printk(KERN_NOTICE "hd44780 error: is the LCD connected?\n");
755 + }
756 + }
757 +
758 + gpio_set_value(SIMONE_LCD_EN, 0); /* Disable */
759 +
760 + ndelay(T_EL); /* Enable low time */
761 +}
762 +
763 +/* Send commands to the display */
764 +static void write_command(unsigned char command)
765 +{
766 + write_display(command, ACCESS_TO_WRITE);
767 +
768 + if (command <= 0x03)
769 + mdelay(2);
770 +}
771 +
772 +static inline void set_cursor(unsigned int offset)
773 +{
774 + unsigned int disp_number = offset/disp_size;
775 + unsigned int local_offset = offset%disp_size;
776 +
777 + if (disp_offset[disp_number] != local_offset || test_bit(CGRAM_STATE+disp_number, &hd44780_flags)) {
778 + unsigned int disp_row = local_offset/par.cntr_cols;
779 + unsigned int disp_column = local_offset%par.cntr_cols;
780 +
781 + write_command(DDRAM_IO | ((disp_row%2)*0x40) | (((disp_row >= 2)*par.cntr_cols)+disp_column));
782 + clear_bit(CGRAM_STATE+disp_number, &hd44780_flags);
783 + disp_offset[disp_number] = local_offset;
784 + }
785 +}
786 +
787 +/* HD44780 DDRAM addresses are consecutive only when
788 + * the cursor moves on the same row of the display.
789 + * Every time the row of the cursor changes we invalidate
790 + * the cursor position to force hardware cursor repositioning.
791 + */
792 +static inline void mov_cursor(unsigned int disp_number)
793 +{
794 + if (test_bit(INC_ADDR, &hd44780_flags)) {
795 + iterator_inc(disp_offset[disp_number], disp_size);
796 + if (disp_offset[disp_number]%par.cntr_cols == 0)
797 + disp_offset[disp_number] = disp_size;
798 + } else {
799 + iterator_dec(disp_offset[disp_number], disp_size);
800 + if (disp_offset[disp_number]%par.cntr_cols == par.cntr_cols-1)
801 + disp_offset[disp_number] = disp_size;
802 + }
803 +}
804 +
805 +static struct lcd_driver hd44780 = {
806 + .read_char = hd44780_read_char,
807 + .read_cgram_char = hd44780_read_cgram_char,
808 + .write_char = hd44780_write_char,
809 + .write_cgram_char = hd44780_write_cgram_char,
810 + .address_mode = hd44780_address_mode,
811 + .clear_display = hd44780_clear_display,
812 + .validate_driver = hd44780_validate_driver,
813 + .init_display = hd44780_init_display,
814 + .cleanup_display = hd44780_cleanup_display,
815 + .init_port = hd44780_init_port,
816 + .cleanup_port = hd44780_cleanup_port,
817 + .handle_custom_char = hd44780_handle_custom_char,
818 + .handle_custom_ioctl = hd44780_handle_custom_ioctl,
819 +
820 + .charmap = charmap,
821 +};
822 +
823 +static void hd44780_read_char(unsigned int offset, unsigned short *data)
824 +{
825 + unsigned int disp_number = offset/disp_size;
826 + unsigned char tmp;
827 +
828 + set_cursor(offset);
829 + read_display(&tmp, ACCESS_TO_DATA);
830 + *data = tmp;
831 + mov_cursor(disp_number);
832 +}
833 +
834 +static void hd44780_read_cgram_char(unsigned char index, unsigned char *pixels)
835 +{
836 + unsigned int i;
837 +
838 + write_command(CGRAM_IO | (index << 3));
839 + set_bit(CGRAM_STATE+0, &hd44780_flags);
840 +
841 + for (i = 0; i < 8; ++i) {
842 + read_display(pixels+i, ACCESS_TO_DATA );
843 + pixels[i] &= 0x1f;
844 + }
845 +}
846 +
847 +static void hd44780_write_char(unsigned int offset, unsigned short data)
848 +{
849 + unsigned int disp_number = offset/disp_size;
850 +
851 + set_cursor(offset);
852 + write_display(data & 0xff, ACCESS_TO_WRITE | ACCESS_TO_DATA );
853 + mov_cursor(disp_number);
854 +}
855 +
856 +static void hd44780_write_cgram_char(unsigned char index, unsigned char *pixels)
857 +{
858 + unsigned int i;
859 +
860 + /* Move address pointer to index in CGRAM */
861 + write_command(CGRAM_IO | (index << 3));
862 +
863 + set_bit(CGRAM_STATE+0, &hd44780_flags);
864 +
865 + for (i = 0; i < 8; ++i) {
866 + pixels[i] &= 0x1f;
867 + write_display(pixels[i], ACCESS_TO_WRITE | ACCESS_TO_DATA );
868 + }
869 +}
870 +
871 +/* Increment/decrement address mode after a data read/write */
872 +static void hd44780_address_mode(int mode)
873 +{
874 + if (mode > 0 && ! test_bit(INC_ADDR, &hd44780_flags)) {
875 + write_command(CURS_INC | DISP_SHIFT_OFF);
876 + set_bit(INC_ADDR, &hd44780_flags);
877 + } else if (mode < 0 && test_bit(INC_ADDR, &hd44780_flags)) {
878 + write_command(CURS_DEC | DISP_SHIFT_OFF);
879 + clear_bit(INC_ADDR, &hd44780_flags);
880 + }
881 +}
882 +
883 +static void hd44780_clear_display(void)
884 +{
885 + write_command(CLR_DISP);
886 + if (! test_bit(INC_ADDR, &hd44780_flags))
887 + write_command(CURS_DEC | DISP_SHIFT_OFF);
888 + memset(disp_offset, 0, sizeof(disp_offset));
889 +}
890 +
891 +static int hd44780_validate_driver(void)
892 +{
893 + if (par.cntr_rows != 1 && par.cntr_rows != 2 && par.cntr_rows != 4)
894 + par.cntr_rows = DFLT_CNTR_ROWS;
895 +
896 + if (par.cntr_rows != 1)
897 + par.flags &= ~HD44780_5X10_FONT;
898 +
899 +
900 + if (! par.cntr_cols || par.cntr_cols > MAX_CNTR_COLS/par.cntr_rows)
901 + par.cntr_cols = MAX_CNTR_COLS/par.cntr_rows;
902 +
903 + disp_size = par.cntr_rows*par.cntr_cols;
904 +
905 + /* These parameters depend on the hardware and cannot be changed */
906 + par.cgram_chars = 8;
907 + par.cgram_bytes = 8;
908 + par.cgram_char0 = 0;
909 +
910 + return (0);
911 +}
912 +
913 +/* Send init commands to the display */
914 +static void write_init_command(void)
915 +{
916 + unsigned char command = 0x30;
917 +
918 + __write_display(HIGH_NIBBLE_WRITE(command), ACCESS_TO_WRITE);
919 + mdelay(20); /* Wait more than 4.1 ms */
920 + __write_display(HIGH_NIBBLE_WRITE(command), ACCESS_TO_WRITE);
921 + udelay(200); /* Wait more than 100 us */
922 + __write_display(HIGH_NIBBLE_WRITE(command), ACCESS_TO_WRITE);
923 + udelay(200); /* Wait more than 100 us */
924 + command = BUS_4_BITS;
925 + command |= ((par.cntr_rows == 1) ? DISP_1_LINE : DISP_2_LINES);
926 + command |= (test_bit(_5X10_FONT, &hd44780_flags) ? FONT_5X10 : FONT_5X8);
927 + write_command(command);
928 + /* set_bit(BACKLIGHT, &hd44780_flags); */
929 +}
930 +
931 +static int hd44780_init_display(void)
932 +{
933 + if (par.flags & HD44780_CHECK_BF)
934 + set_bit(_CHECK_BF, &hd44780_flags);
935 + else
936 + clear_bit(_CHECK_BF, &hd44780_flags);
937 +
938 + if (par.flags & HD44780_4BITS_BUS)
939 + set_bit(_4BITS_BUS, &hd44780_flags);
940 + else
941 + clear_bit(_4BITS_BUS, &hd44780_flags);
942 +
943 + if (par.flags & HD44780_5X10_FONT)
944 + set_bit(_5X10_FONT, &hd44780_flags);
945 + else
946 + clear_bit(_5X10_FONT, &hd44780_flags);
947 +
948 + write_init_command();
949 +
950 + hd44780_clear_display();
951 + hd44780_address_mode(1);
952 + write_command(DISP_ON | CURS_OFF | BLINK_OFF);
953 + set_bit(DISPLAY_ON, &hd44780_flags);
954 + clear_bit(SHOW_CURSOR, &hd44780_flags);
955 + clear_bit(CURSOR_BLINK, &hd44780_flags);
956 +
957 + /* Set the CGRAM to default values */
958 + hd44780_write_cgram_char(0, cg0);
959 + hd44780_write_cgram_char(1, cg1);
960 + hd44780_write_cgram_char(2, cg2);
961 + hd44780_write_cgram_char(3, cg3);
962 + hd44780_write_cgram_char(4, cg4);
963 + hd44780_write_cgram_char(5, cg5);
964 + hd44780_write_cgram_char(6, cg6);
965 + hd44780_write_cgram_char(7, cg7);
966 + init_charmap();
967 +
968 + return (0);
969 +}
970 +
971 +static int hd44780_cleanup_display(void)
972 +{
973 + hd44780_clear_display();
974 +
975 + return (0);
976 +}
977 +
978 +static int hd44780_init_port(void)
979 +{
980 + gpio_direction_output (SIMONE_LCD_BCKLIGHT, 0);
981 + gpio_direction_output (SIMONE_LCD_RD , 0);
982 + gpio_direction_output (SIMONE_LCD_RS , 0);
983 + gpio_direction_output (SIMONE_LCD_EN , 0);
984 + gpio_set_value(SIMONE_LCD_EN, 0); /* Disable */
985 +
986 + return (0);
987 +}
988 +
989 +static int hd44780_cleanup_port(void)
990 +{
991 +
992 + gpio_direction_input (SIMONE_LCD_BCKLIGHT);
993 + gpio_direction_input (SIMONE_LCD_RD);
994 + gpio_direction_input (SIMONE_LCD_RS);
995 + gpio_direction_input (SIMONE_LCD_EN);
996 + gpio_direction_input (SIMONE_LCD_DATA0);
997 + gpio_direction_input (SIMONE_LCD_DATA1);
998 + gpio_direction_input (SIMONE_LCD_DATA2);
999 + gpio_direction_input (SIMONE_LCD_DATA3);
1000 + return (0);
1001 +}
1002 +
1003 +static void display_attr(unsigned char input)
1004 +{
1005 + unsigned char command;
1006 +
1007 + switch (ESC_STATE) {
1008 + case 'a': /* Turn on/off the display cursor */
1009 + if (input == '1')
1010 + set_bit(SHOW_CURSOR, &hd44780_flags);
1011 + else if (input == '0')
1012 + clear_bit(SHOW_CURSOR, &hd44780_flags);
1013 + break;
1014 + case 'b': /* Turn on/off the display cursor blinking */
1015 + if (input == '1')
1016 + set_bit(CURSOR_BLINK, &hd44780_flags);
1017 + else if (input == '0')
1018 + clear_bit(CURSOR_BLINK, &hd44780_flags);
1019 + break;
1020 + case 'h': /* Turn on/off the display */
1021 + if (input == '1')
1022 + set_bit(DISPLAY_ON, &hd44780_flags);
1023 + else if (input == '0')
1024 + clear_bit(DISPLAY_ON, &hd44780_flags);
1025 + break;
1026 + }
1027 +
1028 + command = (test_bit(DISPLAY_ON, &hd44780_flags) ? DISP_ON : DISP_OFF);
1029 + command |= (test_bit(SHOW_CURSOR, &hd44780_flags) ? CURS_ON : CURS_OFF);
1030 + command |= (test_bit(CURSOR_BLINK, &hd44780_flags) ? BLINK_ON : BLINK_OFF);
1031 +
1032 + if (ESC_STATE == 'h')
1033 + write_command(command);
1034 +}
1035 +
1036 +static int hd44780_handle_custom_char(unsigned int _input)
1037 +{
1038 + unsigned char input = _input & 0xff;
1039 +
1040 + if (_input & (~0xff)) {
1041 + switch (ESC_STATE) {
1042 + case 'a': /* Turn on/off the display cursor */
1043 + case 'b': /* Turn on/off the display cursor blinking */
1044 + case 'h': /* Turn on/off the the display */
1045 + display_attr(input);
1046 + return (0);
1047 + case 'l': /* Turn on/off the backlight */
1048 + if (input == '1')
1049 + set_bit(BACKLIGHT, &hd44780_flags);
1050 + else if (input == '0')
1051 + clear_bit(BACKLIGHT, &hd44780_flags);
1052 + read_ac(ACCESS_TO_READ);
1053 + return (0);
1054 + }
1055 + }
1056 +
1057 + switch (input) {
1058 + case 'a': /* Turn on/off the display cursor */
1059 + case 'b': /* Turn on/off the display cursor blinking */
1060 + case 'h': /* Turn on/off the display */
1061 + case 'l': /* Turn on/off the backlight */
1062 + SET_ESC_STATE(input);
1063 + return (1);
1064 + case 'd': /* Shift display cursor Right */
1065 + write_command(SHIFT_CURS | SHIFT_RIGHT);
1066 + return (0);
1067 + case 'e': /* Shift display cursor Left */
1068 + write_command(SHIFT_CURS | SHIFT_LEFT);
1069 + return (0);
1070 + case 'f': /* Shift display Right */
1071 + write_command(SHIFT_DISP | SHIFT_RIGHT);
1072 + return (0);
1073 + case 'g': /* Shift display Left */
1074 + write_command(SHIFT_DISP | SHIFT_LEFT);
1075 + return (0);
1076 + }
1077 +
1078 + return (-1);
1079 +}
1080 +
1081 +static int hd44780_handle_custom_ioctl(unsigned int num, unsigned long arg, unsigned int user_space)
1082 +{
1083 + unsigned char *buffer = (unsigned char *)arg;
1084 +
1085 + if (num != HD44780_READ_AC)
1086 + return (-ENOIOCTLCMD);
1087 +
1088 + if (user_space)
1089 + put_user(read_ac(ACCESS_TO_READ), buffer);
1090 + else
1091 + buffer[0] = read_ac(ACCESS_TO_READ);
1092 +
1093 + return (0);
1094 +}
1095 +
1096 +#ifdef USE_PROC
1097 +static int hd44780_proc_status(char *buffer, char **start, off_t offset, int size, int *eof, void *data)
1098 +{
1099 + char *temp = buffer;
1100 +
1101 + /* Print display configuration */
1102 + temp += sprintf(temp,
1103 + "Interface:\t%u bits\n"
1104 + "Display rows:\t%d\n"
1105 + "Display cols:\t%d\n"
1106 + "Screen rows:\t%d\n"
1107 + "Screen cols:\t%d\n"
1108 + "Read:\t\t%sabled\n"
1109 + "Busy flag chk:\t%sabled\n"
1110 + "Assigned minor:\t%u\n",
1111 + (test_bit(_4BITS_BUS, &hd44780_flags) ? 4 : 8),
1112 + par.cntr_rows, par.cntr_cols,
1113 + par.vs_rows, par.vs_cols,
1114 + (hd44780.read_char ? "En" : "Dis"),
1115 + (test_bit(_CHECK_BF, &hd44780_flags) ? "En" : "Dis"),
1116 + par.minor);
1117 +
1118 + return (temp-buffer);
1119 +}
1120 +
1121 +static int hd44780_proc_cgram(char *buffer, char **start, off_t offset, int size, int *eof, void *data)
1122 +{
1123 + char *temp = buffer;
1124 + unsigned int i;
1125 +
1126 + temp += sprintf(temp, "static void init_charmap(void)\n{\n"
1127 + "\t/*\n"
1128 + "\t * charmap[char mapped to cg0] = 0;\n"
1129 + "\t * charmap[char mapped to cg1] = 1;\n"
1130 + "\t * charmap[char mapped to cg2] = 2;\n"
1131 + "\t * charmap[char mapped to cg3] = 3;\n"
1132 + "\t * charmap[char mapped to cg4] = 4;\n"
1133 + "\t * charmap[char mapped to cg5] = 5;\n"
1134 + "\t * charmap[char mapped to cg6] = 6;\n"
1135 + "\t * charmap[char mapped to cg7] = 7;\n"
1136 + "\t */\n"
1137 + "}\n\n");
1138 +
1139 + for (i = 0; i < 8; ++i) {
1140 + unsigned char cgram_buffer[8];
1141 + unsigned int j;
1142 +
1143 + temp += sprintf(temp, "static unsigned char cg%u[] = { ", i);
1144 + hd44780_read_cgram_char(i, cgram_buffer);
1145 + for (j = 0; j < 8; ++j)
1146 + temp += sprintf(temp, "0x%.2x%s", cgram_buffer[j], (j == 7 ? " };\n" : ", "));
1147 + }
1148 +
1149 + return (temp-buffer);
1150 +}
1151 +
1152 +static void create_proc_entries(void)
1153 +{
1154 + int count = 0;
1155 +
1156 + SET_PROC_LEVEL(count);
1157 + if (create_proc_read_entry("status", 0, hd44780.driver_proc_root, hd44780_proc_status, NULL) == NULL) {
1158 + printk(KERN_ERR "hd44780: cannot create /proc/lcd/%s/status\n", par.name);
1159 + return;
1160 + }
1161 + SET_PROC_LEVEL(++count);
1162 + if (hd44780.read_cgram_char) {
1163 + if (create_proc_read_entry("cgram.h", 0, hd44780.driver_proc_root, hd44780_proc_cgram, NULL) == NULL) {
1164 + printk(KERN_ERR "hd44780: cannot create /proc/lcd/%s/cgram.h\n", par.name);
1165 + return;
1166 + }
1167 + SET_PROC_LEVEL(++count);
1168 + }
1169 +}
1170 +
1171 +static void remove_proc_entries(void)
1172 +{
1173 + switch (PROC_LEVEL) {
1174 + case 2:
1175 + remove_proc_entry("cgram.h", hd44780.driver_proc_root);
1176 + case 1:
1177 + remove_proc_entry("status", hd44780.driver_proc_root);
1178 + }
1179 + SET_PROC_LEVEL(0);
1180 +}
1181 +#endif
1182 +
1183 +/* Initialization */
1184 +static int __init hd44780_init_module(void)
1185 +{
1186 + int ret;
1187 +
1188 +#ifdef MODULE
1189 +#ifdef NOT_DEF
1190 + if ((ret = request_module("lcd-linux"))) {
1191 + if (ret != -ENOSYS) {
1192 + printk(KERN_ERR "hd44780: failure while loading module lcd-linux\n");
1193 + return (ret);
1194 + }
1195 + printk(KERN_ERR "hd44780: your kernel does not have kmod or kerneld support;\n");
1196 + printk(KERN_ERR "hd44780: remember to load the lcd-linux module before\n");
1197 + printk(KERN_ERR "hd44780: loading the hd44780 module\n");
1198 + }
1199 +#endif
1200 + if (flags != DFLT_FLAGS) par.flags = flags;
1201 + if (tabstop != DFLT_TABSTOP) par.tabstop = tabstop;
1202 + if (cntr_rows != DFLT_CNTR_ROWS) par.cntr_rows = cntr_rows;
1203 + if (cntr_cols != DFLT_CNTR_COLS) par.cntr_cols = cntr_cols;
1204 + if (vs_rows != DFLT_VS_ROWS) par.vs_rows = vs_rows;
1205 + if (vs_cols != DFLT_VS_COLS) par.vs_cols = vs_cols;
1206 + if (minor != HD44780_MINOR) par.minor = minor;
1207 +#endif
1208 +
1209 + lcd_driver_setup(&hd44780);
1210 + if ((ret = lcd_register_driver(&hd44780, &par)))
1211 + return (ret);
1212 +
1213 +#ifdef USE_PROC
1214 + if (hd44780.driver_proc_root)
1215 + create_proc_entries();
1216 +#endif
1217 +
1218 + printk(KERN_INFO "HD44780 driver (LCD-Linux" HD44780_VERSION ")\n");
1219 + printk(KERN_INFO "Nuccio Raciti <raciti.nuccio@gmail.com>\n");
1220 +
1221 +
1222 + return (0);
1223 +}
1224 +
1225 +/* Cleanup */
1226 +
1227 +static void __exit hd44780_cleanup_module(void)
1228 +{
1229 +#ifdef USE_PROC
1230 + if (hd44780.driver_proc_root)
1231 + remove_proc_entries();
1232 +#endif
1233 +
1234 + lcd_unregister_driver(&hd44780, &par);
1235 +}
1236 +
1237 +module_init(hd44780_init_module)
1238 +module_exit(hd44780_cleanup_module)
1239 Index: linux-2.6.30.9/drivers/lcd-linux/lcd-linux.c
1240 ===================================================================
1241 --- /dev/null 1970-01-01 00:00:00.000000000 +0000
1242 +++ linux-2.6.30.9/drivers/lcd-linux/lcd-linux.c 2009-11-24 02:01:42.000000000 +0100
1243 @@ -0,0 +1,2892 @@
1244 +/* lcd-linux.c
1245 + *
1246 + *
1247 + *
1248 + * Software layer to drive LCD displays under Linux.
1249 + *
1250 + * Copyright (C) 2005 - 2007 Mattia Jona-Lasinio (mjona@users.sourceforge.net)
1251 + *
1252 + * This program is free software; you can redistribute it and/or modify
1253 + * it under the terms of the GNU General Public License as published by
1254 + * the Free Software Foundation; either version 2 of the License, or
1255 + * (at your option) any later version.
1256 + *
1257 + * This program is distributed in the hope that it will be useful,
1258 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
1259 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1260 + * GNU General Public License for more details.
1261 + *
1262 + * You should have received a copy of the GNU General Public License
1263 + * along with this program; if not, write to the Free Software
1264 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
1265 + *
1266 + */
1267 +
1268 +#include <linux/version.h>
1269 +
1270 +#ifndef KERNEL_VERSION
1271 +#define KERNEL_VERSION(a, b, c) (((a) << 16) + ((b) << 8) + (c))
1272 +#endif
1273 +
1274 +#ifndef LINUX_VERSION_CODE
1275 +#error - LINUX_VERSION_CODE undefined in 'linux/version.h'
1276 +#endif
1277 +
1278 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
1279 +#include <linux/autoconf.h>
1280 +#else
1281 +#include <linux/config.h>
1282 +#endif
1283 +#ifdef CONFIG_PROC_FS
1284 +#define USE_PROC
1285 +#else
1286 +#undef USE_PROC
1287 +#endif
1288 +
1289 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26)
1290 +#include <linux/semaphore.h>
1291 +#else
1292 +#include <asm/semaphore.h>
1293 +#endif
1294 +#include <linux/bitops.h>
1295 +#include <linux/kernel.h>
1296 +#include <linux/module.h>
1297 +#include <linux/sched.h>
1298 +
1299 +#include <linux/fs.h>
1300 +
1301 +#include <asm/uaccess.h>
1302 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
1303 +#include <linux/device.h>
1304 +#endif
1305 +#include <linux/init.h>
1306 +#include <linux/list.h>
1307 +#include <linux/slab.h>
1308 +#include <linux/selection.h>
1309 +#include <linux/vmalloc.h>
1310 +
1311 +#ifdef USE_PROC
1312 +#include <linux/proc_fs.h>
1313 +#endif
1314 +
1315 +#define LCD_LINUX_MAIN
1316 +#include <linux/lcd-linux.h>
1317 +
1318 +/*** struct_flags ***/
1319 +#define NEED_WRAP 0 /* Next char will trigger a newline */
1320 +#define DECIM 1 /* Insert mode */
1321 +#define DECAWM 2 /* Autowrap */
1322 +#define DECSCNM 3 /* Inverted screen */
1323 +#define CRLF 4 /* Follow lf, vt, ff, with a cr */
1324 +#define INC_CURS_POS 5 /* Increment cursor position after data read/write */
1325 +#define QUES 6 /* CSI Esc sequence contains a question mark */
1326 +#define USER_SPACE 7 /* If set, the buffer pointed by arg in do_lcd_ioctl() is
1327 + * assumed to be in user space otherwise it is in kernel space */
1328 +#define NULL_CHARMAP 8 /* The driver doesn't provide a charmap so the
1329 + * lcd-linux layer provides one*/
1330 +#define CAN_DO_COLOR 9 /* The display is color capable */
1331 +#define WITH_ATTR 10 /* If set, the void * buffer in do_lcd_read/write() contains
1332 + * attributes and therefore is an unsigned short * otherwise it
1333 + * is an unsigned char *
1334 + */
1335 +
1336 +/*** attributes ***/
1337 +#define I_MASK 0x03 /* Intensity (0 = low, 1 = normal, 2 = bright) */
1338 +#define ULINE 0x04 /* Underlined text */
1339 +#define REVERSE 0x08 /* Reversed video text */
1340 +#define BLINK 0x80 /* Blinking text */
1341 +
1342 +/*** Color attributes ***/
1343 +#define FG_MASK 0x0f /* Foreground color */
1344 +#define BG_MASK 0xf0 /* Background color */
1345 +
1346 +/* input states */
1347 +#define NORMAL 0x00001000 /* Normal mode */
1348 +#define RAW 0x00002000 /* Raw mode (console emulation disabled) */
1349 +#define SYN 0x00003000 /* Synchronous Idle mode */
1350 +#define ESC 0x00004000 /* Escape mode */
1351 +#define CSI 0x00005000 /* CSI escape mode */
1352 +#define ESC_G0 0x00006000 /* G0 character set */
1353 +#define ESC_G1 0x00007000 /* G1 character set */
1354 +#define ESC_HASH 0x00008000 /* ESC # escape sequence */
1355 +#define ESC_PERCENT 0x00009000 /* ESC % escape sequence */
1356 +#define ARG 0x0000a000 /* Waiting for arguments for the lcd-linux layer */
1357 +#define ARG_DRIVER 0x0000b000 /* Waiting for arguments for the display driver */
1358 +#define INPUT_MASK 0x0000f000
1359 +#define ESC_MASK 0x00ff0000
1360 +#define INIT_MASK 0x0f000000
1361 +#define PROC_MASK 0xf0000000
1362 +
1363 +#define SET_STATE(p, state, mask) ((p)->struct_flags = ((p)->struct_flags & ~(mask)) | ((state) & (mask)))
1364 +#define SET_INPUT_STATE(p, state) SET_STATE(p, state, INPUT_MASK)
1365 +#define SET_ESC_STATE(p, state) SET_STATE(p, (state) << 16, ESC_MASK)
1366 +#define SET_INIT_LEVEL(p, level) SET_STATE(p, (level) << 24, INIT_MASK)
1367 +#define SET_PROC_LEVEL(p, level) SET_STATE(p, (level) << 28, PROC_MASK)
1368 +#define INPUT_STATE(p) ((p)->struct_flags & INPUT_MASK)
1369 +#define ESC_STATE(p) (((p)->struct_flags & ESC_MASK) >> 16)
1370 +#define INIT_LEVEL(p) (((p)->struct_flags & INIT_MASK) >> 24)
1371 +#define PROC_LEVEL(p) (((p)->struct_flags & PROC_MASK) >> 28)
1372 +
1373 +#define NPAR 16 /* Max number of parameters in CSI escape sequence */
1374 +#define FLIP_BUF_SIZE (1 << 6) /* Flip buffer size (64 bytes) */
1375 +
1376 +struct lcd_struct {
1377 + struct list_head lcd_list; /* Doubly linked list */
1378 + struct semaphore lcd_sem; /* Locks this structure */
1379 + struct lcd_driver *driver; /* The driver associated to this struct */
1380 + struct lcd_parameters *par; /* The parameters associated to this struct */
1381 + unsigned long struct_flags; /* Flags for internal use only */
1382 + unsigned int refcount; /* Number of references to this struct */
1383 +
1384 + unsigned short *display; /* The display buffer */
1385 +
1386 + unsigned short *fb; /* The virtual screen framebuffer */
1387 + unsigned int fb_size; /* Size of the framebuffer */
1388 + unsigned int frame_base; /* Offset of row 0, column 0 of a frame in fb */
1389 + unsigned int frame_size; /* Size of the frame */
1390 +
1391 + unsigned int row; /* Current row in virtual screen */
1392 + unsigned int col; /* Current column in virtual screen */
1393 + unsigned int s_offset; /* Saved cursor position in virtual screen */
1394 +
1395 + unsigned int top; /* Top scroll row in virtual screen */
1396 + unsigned int bot; /* Bottom scroll row in virtual screen */
1397 +
1398 + int esc_args; /* Number of arguments for a normal escape sequence */
1399 + unsigned int csi_args[NPAR]; /* CSI parameters */
1400 + unsigned int index; /* Index in csi_args and counter for cgram characters generation */
1401 + unsigned char cgram_index; /* Index of the cgram character to be created */
1402 + unsigned char *cgram_buffer; /* Buffer for cgram operations in this driver */
1403 +
1404 + unsigned short erase_char; /* Character to be used when erasing */
1405 + unsigned char attr; /* Current attributes */
1406 + unsigned char color; /* Color for normal intensity mode */
1407 + unsigned char s_color; /* Saved color for normal intensity mode */
1408 + unsigned char defcolor; /* Default color for normal intensity mode */
1409 + unsigned char ulcolor; /* Color for underline mode */
1410 + unsigned char halfcolor; /* Color for low intensity mode */
1411 + unsigned char attributes; /* Packed attributes */
1412 + unsigned char s_attributes; /* Saved packed attributes */
1413 +
1414 + unsigned char *s_charmap; /* Saved character map for this driver */
1415 + unsigned char *flip_buf; /* High speed flip buffer */
1416 +};
1417 +
1418 +/** Function prototypes **/
1419 +
1420 +/* Init/Cleanup the driver */
1421 +static int init_driver(struct lcd_struct *);
1422 +static int cleanup_driver(struct lcd_struct *);
1423 +
1424 +/* Read from/Write to the driver */
1425 +static void read_data(struct lcd_struct *, unsigned short *);
1426 +static void read_cgram(struct lcd_struct *, unsigned char, unsigned char *);
1427 +static void write_data(struct lcd_struct *, unsigned short);
1428 +static void write_cgram(struct lcd_struct *, unsigned char, unsigned char *);
1429 +
1430 +/* Input handlers */
1431 +static void cr(struct lcd_struct *);
1432 +static void lf(struct lcd_struct *);
1433 +static void control_char(struct lcd_struct *, unsigned char);
1434 +static void handle_csi(struct lcd_struct *, unsigned char);
1435 +static int handle_custom_esc(struct lcd_struct *, unsigned int);
1436 +static int handle_esc(struct lcd_struct *, unsigned char);
1437 +static void handle_input(struct lcd_struct *, unsigned short);
1438 +
1439 +/* Low level file operations */
1440 +static ssize_t do_lcd_read(struct lcd_struct *, void *, size_t);
1441 +static ssize_t do_lcd_write(struct lcd_struct *, const void *, size_t);
1442 +static int do_lcd_open(struct lcd_struct *);
1443 +static int do_lcd_release(struct lcd_struct *);
1444 +static int do_lcd_ioctl(struct lcd_struct *, unsigned int, unsigned long);
1445 +
1446 +/* Proc functions */
1447 +#ifdef USE_PROC
1448 +static void create_driver_proc_entries(struct lcd_struct *);
1449 +static void remove_driver_proc_entries(struct lcd_struct *);
1450 +#endif
1451 +
1452 +/* globals */
1453 +static unsigned int major = LCD_MAJOR; /* Major number for LCD-Linux device */
1454 +static unsigned short minors = LCD_MINORS; /* Minor numbers allocated for LCD-Linux */
1455 +static LIST_HEAD(lcd_drivers); /* Registered lcd drivers */
1456 +static struct semaphore drivers_sem; /* Locks the lcd_drivers list */
1457 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 13)
1458 +static struct class *lcd_linux_class;
1459 +#endif
1460 +#ifdef USE_PROC
1461 +static struct proc_dir_entry *lcd_proc_root;
1462 +#endif
1463 +/* End of globals */
1464 +
1465 +#ifdef MODULE
1466 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
1467 +#include <linux/device.h>
1468 +MODULE_ALIAS_CHARDEV_MAJOR(LCD_MAJOR);
1469 +#endif
1470 +MODULE_DESCRIPTION("Software layer to drive LCD displays under Linux.");
1471 +MODULE_AUTHOR("Mattia Jona-Lasinio <mjona@users.sourceforge.net>");
1472 +#ifdef MODULE_LICENSE
1473 +MODULE_LICENSE("GPL");
1474 +#endif
1475 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
1476 +module_param(minors, ushort, 0444);
1477 +#else
1478 +MODULE_PARM(minors, "h");
1479 +#endif
1480 +MODULE_PARM_DESC(minors, "Minor numbers allocated for LCD-Linux (default: " string(LCD_MINORS) ")");
1481 +#else
1482 +
1483 +/*
1484 + * Parse boot command line
1485 + *
1486 + * lcd=minors
1487 + */
1488 +static int __init lcd_linux_boot_init(char *cmdline)
1489 +{
1490 + unsigned short args;
1491 +
1492 + if ((args = simple_strtoul(cmdline, NULL, 0)))
1493 + minors = args;
1494 +
1495 + return (1);
1496 +}
1497 +
1498 +__setup("lcd=", lcd_linux_boot_init);
1499 +#endif /* MODULE */
1500 +
1501 +/* Macros for iterator handling */
1502 +static inline unsigned int iterator_inc_(unsigned int iterator, const unsigned int module)
1503 +{
1504 + return ((++iterator)%module);
1505 +}
1506 +
1507 +static inline unsigned int iterator_dec_(unsigned int iterator, const unsigned int module)
1508 +{
1509 + return (iterator ? --iterator : module-1);
1510 +}
1511 +
1512 +#define iterator_inc(iterator, module) (iterator = iterator_inc_(iterator, module))
1513 +#define iterator_dec(iterator, module) (iterator = iterator_dec_(iterator, module))
1514 +
1515 +/* Uncomment the following two lines
1516 + * for non-atomic set_bit and clear_bit
1517 +#define set_bit __set_bit
1518 +#define clear_bit __clear_bit
1519 +*/
1520 +
1521 +/************************************
1522 + * Low level routines and utilities *
1523 + ************************************/
1524 +/*
1525 + * Set whether the address counter should be incremented
1526 + * or decremented after a Read/Write
1527 + */
1528 +static void address_mode(struct lcd_struct *p, int mode)
1529 +{
1530 + struct lcd_driver *driver = p->driver;
1531 +
1532 + if (mode > 0 && ! test_bit(INC_CURS_POS, &p->struct_flags)) {
1533 + if (driver->address_mode)
1534 + driver->address_mode(mode);
1535 + set_bit(INC_CURS_POS, &p->struct_flags);
1536 + } else if (mode < 0 && test_bit(INC_CURS_POS, &p->struct_flags)) {
1537 + if (driver->address_mode)
1538 + driver->address_mode(mode);
1539 + clear_bit(INC_CURS_POS, &p->struct_flags);
1540 + }
1541 +}
1542 +
1543 +/* WARNING!! This function returns an int because if iterator is not
1544 + * within the visible area of the frame it returns -1
1545 + */
1546 +static inline int vs_to_frame_(struct lcd_struct *p, unsigned int iterator)
1547 +{
1548 + unsigned int vs_cols = p->par->vs_cols;
1549 + unsigned int row = iterator/vs_cols;
1550 + unsigned int col = iterator%vs_cols;
1551 + unsigned int frame_base_row = p->frame_base/vs_cols;
1552 + unsigned int frame_base_col = p->frame_base%vs_cols;
1553 + unsigned int frame_rows = p->par->cntr_rows*p->par->num_cntr;
1554 + unsigned int frame_cols = p->par->cntr_cols;
1555 +
1556 + if (row < frame_base_row || row >= frame_base_row+frame_rows)
1557 + return (-1);
1558 + if (col < frame_base_col || col >= frame_base_col+frame_cols)
1559 + return (-1);
1560 +
1561 + return ((row-frame_base_row)*frame_cols+(col-frame_base_col));
1562 +}
1563 +
1564 +/* Given 'iterator' in vs, returns the offset in vs corresponding to the nearest
1565 + * visible offset in vs, or returns 'iterator' if it is already visible.
1566 + */
1567 +static unsigned int round_vs_(struct lcd_struct *p, unsigned int iterator)
1568 +{
1569 + unsigned int vs_cols = p->par->vs_cols;
1570 + unsigned int row = iterator/vs_cols;
1571 + unsigned int col = iterator%vs_cols;
1572 + unsigned int frame_base_row = p->frame_base/vs_cols;
1573 + unsigned int frame_base_col = p->frame_base%vs_cols;
1574 + unsigned int frame_rows = p->par->cntr_rows*p->par->num_cntr;
1575 + unsigned int frame_cols = p->par->cntr_cols;
1576 +
1577 + if (row < frame_base_row)
1578 + row = frame_base_row;
1579 + else if (row >= frame_base_row+frame_rows)
1580 + row = frame_base_row+(frame_rows-1);
1581 +
1582 + if (col < frame_base_col)
1583 + col = frame_base_col;
1584 + else if (col >= frame_base_col+frame_cols)
1585 + col = frame_base_col+(frame_cols-1);
1586 +
1587 + return ((row*vs_cols)+col);
1588 +}
1589 +
1590 +#define round_vs(p, iterator) (iterator = round_vs_(p, iterator))
1591 +
1592 +/*
1593 + * Sync the frame area starting at offset s, ending at offset e with fb content.
1594 + */
1595 +static void redraw_screen(struct lcd_struct *p, unsigned int s, unsigned int e)
1596 +{
1597 + unsigned int len;
1598 + unsigned int row = p->row, col = p->col;
1599 + unsigned int inc_set = test_bit(INC_CURS_POS, &p->struct_flags);
1600 + unsigned int frame_cols = p->par->cntr_cols;
1601 + unsigned int vs_cols = p->par->vs_cols;
1602 + unsigned long flags;
1603 +
1604 + if (s >= p->fb_size || e >= p->fb_size || e < s || e < p->frame_base)
1605 + return;
1606 +
1607 + round_vs(p, s);
1608 + round_vs(p, e);
1609 +
1610 + len = 1+e-s;
1611 +
1612 + if (! inc_set)
1613 + s = e;
1614 +
1615 + p->row = s/vs_cols;
1616 + p->col = s%vs_cols;
1617 +
1618 + flags = p->struct_flags;
1619 + clear_bit(NEED_WRAP, &p->struct_flags);
1620 + clear_bit(DECIM, &p->struct_flags);
1621 + set_bit(DECAWM, &p->struct_flags);
1622 + SET_INPUT_STATE(p, RAW);
1623 + if (inc_set)
1624 + while (len--)
1625 + if (vs_to_frame_(p, (p->row*vs_cols)+p->col) < 0) {
1626 + s += vs_cols-frame_cols;
1627 + len -= vs_cols-frame_cols-1;
1628 + p->row = s/vs_cols;
1629 + p->col = s%vs_cols;
1630 + } else {
1631 + write_data(p, p->fb[s++]);
1632 + if (test_bit(NEED_WRAP, &p->struct_flags)) {
1633 + cr(p);
1634 + lf(p);
1635 + }
1636 + }
1637 + else
1638 + while (len--)
1639 + if (vs_to_frame_(p, (p->row*vs_cols)+p->col) < 0) {
1640 + s -= vs_cols-frame_cols;
1641 + len -= vs_cols-frame_cols-1;
1642 + p->row = s/vs_cols;
1643 + p->col = s%vs_cols;
1644 + } else {
1645 + write_data(p, p->fb[s--]);
1646 + if (test_bit(NEED_WRAP, &p->struct_flags)) {
1647 + cr(p);
1648 + lf(p);
1649 + }
1650 + }
1651 + p->struct_flags = flags;
1652 +
1653 + p->row = row; p->col = col;
1654 +}
1655 +
1656 +static int make_cursor_visible(struct lcd_struct *p)
1657 +{
1658 + unsigned int vs_rows = p->par->vs_rows;
1659 + unsigned int vs_cols = p->par->vs_cols;
1660 + unsigned int frame_base, frame_base_row, frame_base_col;
1661 + unsigned int frame_rows = p->par->cntr_rows*p->par->num_cntr;
1662 + unsigned int frame_cols = p->par->cntr_cols;
1663 + unsigned int tmp = frame_cols/2;
1664 +
1665 + if (test_bit(INC_CURS_POS, &p->struct_flags)) {
1666 + /* cursor always on the lowest row of the display */
1667 + frame_base_row = 0;
1668 + frame_base_col = 0;
1669 + if (p->row >= frame_rows)
1670 + frame_base_row = p->row-(frame_rows-1);
1671 + if (p->col >= frame_cols) {
1672 + frame_base_col = p->col-(frame_cols-1);
1673 + if (tmp) {
1674 + tmp = (tmp-(frame_base_col%tmp))%tmp;
1675 + if (frame_base_col+tmp <= vs_cols-frame_cols)
1676 + frame_base_col += tmp;
1677 + }
1678 + }
1679 + } else {
1680 + /* cursor always on the uppermost row of the display */
1681 + frame_base_row = vs_rows-frame_rows;
1682 + frame_base_col = vs_cols-frame_cols;
1683 + if (p->row < vs_rows-frame_rows)
1684 + frame_base_row = p->row;
1685 + if (p->col < vs_cols-frame_cols) {
1686 + frame_base_col = p->col;
1687 + if (tmp) {
1688 + tmp = frame_base_col%tmp;
1689 + if (frame_base_col >= tmp)
1690 + frame_base_col -= tmp;
1691 + }
1692 + }
1693 + }
1694 +
1695 + frame_base = p->frame_base;
1696 + p->frame_base = (frame_base_row*vs_cols)+frame_base_col;
1697 +
1698 + return (frame_base != p->frame_base);
1699 +}
1700 +
1701 +/*
1702 + * Move the visible screen area at user's wish
1703 + */
1704 +static void browse_screen(struct lcd_struct *p, unsigned char dir)
1705 +{
1706 + unsigned int vs_rows = p->par->vs_rows;
1707 + unsigned int vs_cols = p->par->vs_cols;
1708 + unsigned int frame_base_row = p->frame_base/vs_cols;
1709 + unsigned int frame_base_col = p->frame_base%vs_cols;
1710 + unsigned int frame_rows = p->par->cntr_rows*p->par->num_cntr;
1711 + unsigned int frame_cols = p->par->cntr_cols;
1712 +
1713 + switch (dir) {
1714 + case '1': /* Up */
1715 + if (! frame_base_row)
1716 + return;
1717 + --frame_base_row;
1718 + break;
1719 + case '2': /* Down */
1720 + if (frame_base_row >= vs_rows-frame_rows)
1721 + return;
1722 + ++frame_base_row;
1723 + break;
1724 + case '3': /* Left */
1725 + if (! frame_base_col)
1726 + return;
1727 + --frame_base_col;
1728 + break;
1729 + case '4': /* Right */
1730 + if (frame_base_col >= vs_cols-frame_cols)
1731 + return;
1732 + ++frame_base_col;
1733 + break;
1734 + default:
1735 + return;
1736 + }
1737 +
1738 + p->frame_base = (frame_base_row*vs_cols)+frame_base_col;
1739 + redraw_screen(p, 0, p->fb_size-1);
1740 +}
1741 +
1742 +static inline void __memset_short(unsigned short *buf, unsigned short c, unsigned int len)
1743 +{
1744 + while (len--)
1745 + *buf++ = c;
1746 +}
1747 +
1748 +/*
1749 + * A memset implementation writing to LCD instead of memory locations.
1750 + */
1751 +static void lcd_memset(struct lcd_struct *p, unsigned int d, unsigned short c, unsigned int len)
1752 +{
1753 + unsigned int inc_set = test_bit(INC_CURS_POS, &p->struct_flags);
1754 +
1755 + if (! len || d >= p->fb_size)
1756 + return;
1757 +
1758 + if (inc_set && d+len > p->fb_size)
1759 + len = p->fb_size-d;
1760 + else if (! inc_set && len > d+1)
1761 + len = d+1;
1762 +
1763 + if (! inc_set)
1764 + d -= len-1;
1765 + __memset_short(p->fb+d, c, len);
1766 +
1767 + if (make_cursor_visible(p))
1768 + redraw_screen(p, 0, p->fb_size-1);
1769 + else
1770 + redraw_screen(p, d, d+(len-1));
1771 +}
1772 +
1773 +static inline void __memcpy_short(unsigned short *d, unsigned short *s, unsigned int len, int dir)
1774 +{
1775 + if (dir > 0)
1776 + while (len--)
1777 + *d++ = *s++;
1778 + else
1779 + while (len--)
1780 + *d-- = *s--;
1781 +}
1782 +
1783 +/*
1784 + * A memmove implementation writing to LCD instead of memory locations.
1785 + * Copy is done in a non destructive way. Display regions may overlap.
1786 + */
1787 +static void lcd_memmove(struct lcd_struct *p, unsigned int d, unsigned int s, unsigned int len)
1788 +{
1789 + if (! len || d == s || d >= p->fb_size || s >= p->fb_size)
1790 + return;
1791 +
1792 + if (d < s) {
1793 + if (test_bit(INC_CURS_POS, &p->struct_flags)) {
1794 + if (s+len > p->fb_size)
1795 + len = p->fb_size-s;
1796 + } else {
1797 + if (len > d+1)
1798 + len = d+1;
1799 + d -= len-1;
1800 + s -= len-1;
1801 + }
1802 + __memcpy_short(p->fb+d, p->fb+s, len, 1);
1803 + if (make_cursor_visible(p))
1804 + redraw_screen(p, 0, p->fb_size-1);
1805 + else
1806 + redraw_screen(p, d, d+(len-1));
1807 + } else {
1808 + if (test_bit(INC_CURS_POS, &p->struct_flags)) {
1809 + if (d+len > p->fb_size)
1810 + len = p->fb_size-d;
1811 + d += len-1;
1812 + s += len-1;
1813 + } else {
1814 + if (len > s+1)
1815 + len = s+1;
1816 + }
1817 + __memcpy_short(p->fb+d, p->fb+s, len, -1);
1818 + if (make_cursor_visible(p))
1819 + redraw_screen(p, 0, p->fb_size-1);
1820 + else
1821 + redraw_screen(p, d-(len-1), d);
1822 + }
1823 +}
1824 +
1825 +static void scrup(struct lcd_struct *p, unsigned int t, unsigned int b, unsigned int nr)
1826 +{
1827 + unsigned int vs_rows = p->par->vs_rows;
1828 + unsigned int vs_cols = p->par->vs_cols;
1829 + unsigned int d, s;
1830 +
1831 + if (t+nr >= b)
1832 + nr = b-t-1;
1833 + if (b > vs_rows || t >= b || nr < 1)
1834 + return;
1835 + d = t*vs_cols;
1836 + s = (t+nr)*vs_cols;
1837 + if (test_bit(INC_CURS_POS, &p->struct_flags)) {
1838 + lcd_memmove(p, d, s, (b-t-nr)*vs_cols);
1839 + lcd_memset(p, d+(b-t-nr)*vs_cols, p->erase_char, nr*vs_cols);
1840 + } else {
1841 + lcd_memmove(p, d+(b-t-nr)*vs_cols-1, s+(b-t-nr)*vs_cols-1, (b-t-nr)*vs_cols);
1842 + lcd_memset(p, d+(b-t)*vs_cols-1, p->erase_char, nr*vs_cols);
1843 + }
1844 +}
1845 +
1846 +static void scrdown(struct lcd_struct *p, unsigned int t, unsigned int b, unsigned int nr)
1847 +{
1848 + unsigned int vs_rows = p->par->vs_rows;
1849 + unsigned int vs_cols = p->par->vs_cols;
1850 + unsigned int d, s;
1851 +
1852 + if (t+nr >= b)
1853 + nr = b-t-1;
1854 + if (b > vs_rows || t >= b || nr < 1)
1855 + return;
1856 + s = t*vs_cols;
1857 + d = (t+nr)*vs_cols;
1858 + if (test_bit(INC_CURS_POS, &p->struct_flags)) {
1859 + lcd_memmove(p, d, s, (b-t-nr)*vs_cols);
1860 + lcd_memset(p, s, p->erase_char, nr*vs_cols);
1861 + } else {
1862 + lcd_memmove(p, d+(b-t-nr)*vs_cols-1, s+(b-t-nr)*vs_cols-1, (b-t-nr)*vs_cols);
1863 + lcd_memset(p, s+nr*vs_cols-1, p->erase_char, nr*vs_cols);
1864 + }
1865 +}
1866 +
1867 +static void lcd_insert_char(struct lcd_struct *p, unsigned int nr)
1868 +{
1869 + unsigned int vs_cols = p->par->vs_cols;
1870 + unsigned int pos = (p->row*vs_cols)+p->col;
1871 +
1872 + clear_bit(NEED_WRAP, &p->struct_flags);
1873 + if (test_bit(INC_CURS_POS, &p->struct_flags))
1874 + lcd_memmove(p, pos+nr, pos, vs_cols-p->col-nr);
1875 + else
1876 + lcd_memmove(p, pos-nr, pos, p->col-(nr-1));
1877 + lcd_memset(p, pos, p->erase_char, nr);
1878 +}
1879 +
1880 +static void lcd_delete_char(struct lcd_struct *p, unsigned int nr)
1881 +{
1882 + unsigned int vs_cols = p->par->vs_cols;
1883 + unsigned int pos = (p->row*vs_cols)+p->col;
1884 +
1885 + clear_bit(NEED_WRAP, &p->struct_flags);
1886 + if (test_bit(INC_CURS_POS, &p->struct_flags)) {
1887 + lcd_memmove(p, pos, pos+nr, vs_cols-(p->col+nr));
1888 + lcd_memset(p, (p->row+1)*vs_cols-nr, p->erase_char, nr);
1889 + } else {
1890 + lcd_memmove(p, pos, pos-nr, p->col-(nr-1));
1891 + lcd_memset(p, (p->row*vs_cols)+(nr-1), p->erase_char, nr);
1892 + }
1893 +}
1894 +
1895 +
1896 +
1897 +
1898 +
1899 +/******************************************************************************
1900 + ************************* VT 102 Emulation *************************
1901 + ******************************************************************************/
1902 +
1903 +/**********************
1904 + * Control characters *
1905 + **********************/
1906 +static void bs(struct lcd_struct *p)
1907 +{
1908 + clear_bit(NEED_WRAP, &p->struct_flags);
1909 + if (test_bit(INC_CURS_POS, &p->struct_flags)) {
1910 + if (p->col)
1911 + --p->col;
1912 + } else {
1913 + if (p->col+1 < p->par->vs_cols)
1914 + ++p->col;
1915 + }
1916 +}
1917 +
1918 +static void cr(struct lcd_struct *p)
1919 +{
1920 + clear_bit(NEED_WRAP, &p->struct_flags);
1921 + p->col = (test_bit(INC_CURS_POS, &p->struct_flags) ? 0 : p->par->vs_cols-1);
1922 +}
1923 +
1924 +static void lf(struct lcd_struct *p)
1925 +{
1926 + clear_bit(NEED_WRAP, &p->struct_flags);
1927 + if (test_bit(INC_CURS_POS, &p->struct_flags)) {
1928 + if (p->row+1 == p->bot && INPUT_STATE(p) != RAW) {
1929 + make_cursor_visible(p);
1930 + scrup(p, p->top, p->bot, 1);
1931 + } else if (p->row+1 < p->par->vs_rows)
1932 + ++p->row;
1933 + } else {
1934 + if (p->row == p->top && INPUT_STATE(p) != RAW) {
1935 + make_cursor_visible(p);
1936 + scrdown(p, p->top, p->bot, 1);
1937 + } else if (p->row)
1938 + --p->row;
1939 + }
1940 +}
1941 +
1942 +static void ri(struct lcd_struct *p)
1943 +{
1944 + clear_bit(NEED_WRAP, &p->struct_flags);
1945 + if (test_bit(INC_CURS_POS, &p->struct_flags)) {
1946 + if (p->row == p->top) {
1947 + make_cursor_visible(p);
1948 + scrdown(p, p->top, p->bot, 1);
1949 + } else if (p->row)
1950 + --p->row;
1951 + } else {
1952 + if (p->row+1 == p->bot) {
1953 + make_cursor_visible(p);
1954 + scrup(p, p->top, p->bot, 1);
1955 + } else if (p->row+1 < p->par->vs_rows)
1956 + ++p->row;
1957 + }
1958 +}
1959 +
1960 +static void ff(struct lcd_struct *p)
1961 +{
1962 + unsigned int vs_rows = p->par->vs_rows;
1963 + unsigned int vs_cols = p->par->vs_cols;
1964 +
1965 + clear_bit(NEED_WRAP, &p->struct_flags);
1966 + if (p->driver->clear_display) {
1967 + p->driver->clear_display();
1968 + __memset_short(p->fb, p->erase_char, p->fb_size);
1969 + __memset_short(p->display, p->erase_char, p->frame_size);
1970 + p->frame_base = 0;
1971 + } else if (test_bit(INC_CURS_POS, &p->struct_flags))
1972 + lcd_memset(p, 0, p->erase_char, p->fb_size);
1973 + else
1974 + lcd_memset(p, p->fb_size-1, p->erase_char, p->fb_size);
1975 +
1976 + if (test_bit(INC_CURS_POS, &p->struct_flags))
1977 + p->row = p->col = 0;
1978 + else {
1979 + p->row = vs_rows-1;
1980 + p->col = vs_cols-1;
1981 + }
1982 +}
1983 +
1984 +static void tab(struct lcd_struct *p)
1985 +{
1986 + struct lcd_parameters *par = p->par;
1987 + unsigned int i, vs_cols = par->vs_cols;
1988 +
1989 + clear_bit(NEED_WRAP, &p->struct_flags);
1990 +
1991 + if (! par->tabstop)
1992 + return;
1993 +
1994 + if (test_bit(INC_CURS_POS, &p->struct_flags)) {
1995 + i = par->tabstop-(p->col%par->tabstop);
1996 + if (p->col+i < vs_cols)
1997 + p->col += i;
1998 + } else {
1999 + i = p->col%par->tabstop;
2000 + i = (i == 0 ? par->tabstop : i);
2001 + if (p->col >= i)
2002 + p->col -= i;
2003 + }
2004 +}
2005 +
2006 +/*
2007 + * Control character handler.
2008 + */
2009 +static void control_char(struct lcd_struct *p, unsigned char val)
2010 +{
2011 + switch (val) {
2012 + case 0x08: /* BS: Back Space (^H) */
2013 + case 0x7f: /* DEL: Delete */
2014 + bs(p);
2015 + return;
2016 +
2017 + case 0x09: /* HT: Horizontal Tab (^I) */
2018 + tab(p);
2019 + return;
2020 +
2021 + case 0x0c: /* FF: Form Feed (^L) */
2022 + ff(p);
2023 + return;
2024 +
2025 + case 0x0a: /* LF: Line Feed (^J) */
2026 + case 0x0b: /* VT: Vertical Tab (^K) */
2027 + lf(p);
2028 + if (! test_bit(CRLF, &p->struct_flags))
2029 + return;
2030 +
2031 + case 0x0d: /* CR: Carriage Return (^M) */
2032 + cr(p);
2033 + return;
2034 +
2035 + case 0x16: /* SYN: Synchronous Idle (^V) */
2036 + SET_INPUT_STATE(p, SYN);
2037 + return;
2038 +
2039 + case 0x1b: /* ESC: Start of escape sequence */
2040 + SET_INPUT_STATE(p, ESC);
2041 + return;
2042 +
2043 + case 0x9b: /* CSI: Start of CSI escape sequence */
2044 + memset(p->csi_args, 0, sizeof(p->csi_args));
2045 + p->index = 0;
2046 + SET_INPUT_STATE(p, CSI);
2047 + return;
2048 + }
2049 +}
2050 +
2051 +static void gotoxy(struct lcd_struct *p, int new_col, int new_row)
2052 +{
2053 + unsigned int vs_rows = p->par->vs_rows;
2054 + unsigned int vs_cols = p->par->vs_cols;
2055 +
2056 + clear_bit(NEED_WRAP, &p->struct_flags);
2057 + if (new_row < 0)
2058 + p->row = 0;
2059 + else if (new_row >= vs_rows)
2060 + p->row = vs_rows-1;
2061 + else
2062 + p->row = new_row;
2063 +
2064 + if (new_col < 0)
2065 + p->col = 0;
2066 + else if (new_col >= vs_cols)
2067 + p->col = vs_cols-1;
2068 + else
2069 + p->col = new_col;
2070 +
2071 + if (make_cursor_visible(p))
2072 + redraw_screen(p, 0, p->fb_size-1);
2073 +}
2074 +
2075 +
2076 +/******************************
2077 + * ECMA-48 CSI ESC- sequences *
2078 + ******************************/
2079 +static void csi_at(struct lcd_struct *p, unsigned int nr)
2080 +{
2081 + unsigned int vs_cols = p->par->vs_cols;
2082 +
2083 + if (p->col+nr > vs_cols)
2084 + nr = vs_cols-p->col;
2085 + else if (! nr)
2086 + ++nr;
2087 + lcd_insert_char(p, nr);
2088 +}
2089 +
2090 +static void csi_J(struct lcd_struct *p, unsigned int action)
2091 +{
2092 + unsigned int vs_cols = p->par->vs_cols;
2093 + unsigned int pos = (p->row*vs_cols)+p->col;
2094 +
2095 + clear_bit(NEED_WRAP, &p->struct_flags);
2096 + switch (action) {
2097 + case 0: /* From cursor to end of display */
2098 + lcd_memset(p, pos, p->erase_char, p->fb_size-pos);
2099 + return;
2100 +
2101 + case 1: /* From start of display to cursor */
2102 + lcd_memset(p, 0, p->erase_char, pos+1);
2103 + return;
2104 +
2105 + case 2: /* Whole display */
2106 + lcd_memset(p, 0, p->erase_char, p->fb_size);
2107 + return;
2108 + }
2109 +}
2110 +
2111 +static void csi_K(struct lcd_struct *p, unsigned int action)
2112 +{
2113 + unsigned int vs_cols = p->par->vs_cols;
2114 + unsigned int row_start = p->row*vs_cols;
2115 +
2116 + clear_bit(NEED_WRAP, &p->struct_flags);
2117 + switch (action) {
2118 + case 0: /* From cursor to end of line */
2119 + lcd_memset(p, row_start+p->col, p->erase_char, vs_cols-p->col);
2120 + return;
2121 +
2122 + case 1: /* From start of line to cursor */
2123 + lcd_memset(p, row_start, p->erase_char, p->col+1);
2124 + return;
2125 +
2126 + case 2: /* Whole line */
2127 + lcd_memset(p, row_start, p->erase_char, vs_cols);
2128 + return;
2129 + }
2130 +}
2131 +
2132 +static void csi_L(struct lcd_struct *p, unsigned int nr)
2133 +{
2134 + unsigned int vs_rows = p->par->vs_rows;
2135 + unsigned int vs_cols = p->par->vs_cols;
2136 +
2137 + clear_bit(NEED_WRAP, &p->struct_flags);
2138 + if (p->row+nr > vs_rows)
2139 + nr = vs_rows-p->row;
2140 + else if (! nr)
2141 + ++nr;;
2142 + lcd_memmove(p, (p->row+nr)*vs_cols, p->row*vs_cols, (vs_rows-p->row-nr)*vs_cols);
2143 + lcd_memset(p, p->row*vs_cols, p->erase_char, nr*vs_cols);
2144 +}
2145 +
2146 +static void csi_M(struct lcd_struct *p, unsigned int nr)
2147 +{
2148 + unsigned int vs_rows = p->par->vs_rows;
2149 + unsigned int vs_cols = p->par->vs_cols;
2150 +
2151 + clear_bit(NEED_WRAP, &p->struct_flags);
2152 + if (p->row+nr > vs_rows)
2153 + nr = vs_rows-p->row;
2154 + else if (! nr)
2155 + ++nr;;
2156 + lcd_memmove(p, p->row*vs_cols, (p->row+nr)*vs_cols, (vs_rows-p->row-nr)*vs_cols);
2157 + lcd_memset(p, (vs_rows-nr)*vs_cols, p->erase_char, nr*vs_cols);
2158 +}
2159 +
2160 +static void csi_P(struct lcd_struct *p, unsigned int nr)
2161 +{
2162 + unsigned int vs_cols = p->par->vs_cols;
2163 +
2164 + if (p->col+nr > vs_cols)
2165 + nr = vs_cols-p->col;
2166 + else if (! nr)
2167 + ++nr;
2168 + lcd_delete_char(p, nr);
2169 +}
2170 +
2171 +static void csi_X(struct lcd_struct *p, unsigned int nr)
2172 +{
2173 + unsigned int vs_cols = p->par->vs_cols;
2174 +
2175 + clear_bit(NEED_WRAP, &p->struct_flags);
2176 + if (p->col+nr > vs_cols)
2177 + nr = vs_cols-p->col;
2178 + else if (! nr)
2179 + ++nr;
2180 + lcd_memset(p, (p->row*vs_cols)+p->col, p->erase_char, nr);
2181 +}
2182 +
2183 +static void csi_su(struct lcd_struct *p, unsigned char input)
2184 +{
2185 + unsigned int vs_cols = p->par->vs_cols;
2186 +
2187 + clear_bit(NEED_WRAP, &p->struct_flags);
2188 + if (input == 'u') {
2189 + p->row = p->s_offset/vs_cols;
2190 + p->col = p->s_offset%vs_cols;
2191 + p->color = p->s_color;
2192 + p->attributes = p->s_attributes;
2193 + return;
2194 + }
2195 + p->s_offset = (p->row*vs_cols)+p->col;
2196 + p->s_color = p->color;
2197 + p->s_attributes = p->attributes;
2198 +}
2199 +
2200 +static unsigned char build_attr(struct lcd_struct *p, unsigned char color, unsigned char intensity,
2201 + unsigned char blink, unsigned char underline, unsigned char reverse)
2202 +{
2203 + unsigned char attr;
2204 +
2205 + if (test_bit(CAN_DO_COLOR, &p->struct_flags)) {
2206 + attr = color;
2207 + if (underline)
2208 + attr = (attr & BG_MASK) | p->ulcolor;
2209 + else if (intensity == 0)
2210 + attr = (attr & BG_MASK) | p->halfcolor;
2211 + if (reverse)
2212 + attr = (attr & 0x88) | ((attr & 0x70) >> 4) | ((attr & 0x07) << 4);
2213 + if (blink)
2214 + attr ^= 0x80;
2215 + if (intensity == 2)
2216 + attr ^= 0x08;
2217 + } else {
2218 + attr = intensity;
2219 + attr |= (underline ? ULINE : 0x00);
2220 + attr |= (reverse ? REVERSE : 0x00);
2221 + attr |= (blink ? BLINK : 0x00);
2222 + }
2223 +
2224 + return (attr);
2225 +}
2226 +
2227 +static void update_attr(struct lcd_struct *p)
2228 +{
2229 + unsigned char intensity = p->attributes & 0x03;
2230 + unsigned char underline = (p->attributes >> 2) & 0x01;
2231 + unsigned char reverse = (p->attributes >> 3) & 0x01;
2232 + unsigned char blink = (p->attributes >> 7) & 0x01;
2233 + unsigned char decscnm = (p->struct_flags >> DECSCNM) & 0x01;
2234 +
2235 + p->attr = build_attr(p, p->color, intensity, blink, underline, reverse^decscnm);
2236 + p->erase_char = (build_attr(p, p->color, 1, blink, 0, decscnm) << 8) | ' ';
2237 +}
2238 +
2239 +static void default_attr(struct lcd_struct *p)
2240 +{
2241 + p->attributes = 0x01;
2242 + p->color = p->defcolor;
2243 +}
2244 +
2245 +static void lcd_invert_screen(struct lcd_struct *p, unsigned int offset, unsigned int len)
2246 +{
2247 + if (test_bit(CAN_DO_COLOR, &p->struct_flags))
2248 + while (len--) {
2249 + p->fb[offset] = (p->fb[offset] & 0x88ff) | ((p->fb[offset] & 0x7000) >> 4) | ((p->fb[offset] & 0x0700) << 4);
2250 + ++offset;
2251 + }
2252 + else
2253 + while (len--) {
2254 + p->fb[offset] ^= 0x0800;
2255 + ++offset;
2256 + }
2257 +}
2258 +
2259 +static void csi_m(struct lcd_struct *p, unsigned int n)
2260 +{
2261 + int i, arg;
2262 +
2263 + for (i = 0; i <= n; ++i)
2264 + switch ((arg = p->csi_args[i]))
2265 + {
2266 + case 0:
2267 + default_attr(p);
2268 + break;
2269 +
2270 + case 1:
2271 + p->attributes = (p->attributes & ~I_MASK) | 2;
2272 + break;
2273 +
2274 + case 2:
2275 + p->attributes = (p->attributes & ~I_MASK) | 0;
2276 + break;
2277 +
2278 + case 4:
2279 + p->attributes |= ULINE;
2280 + break;
2281 +
2282 + case 5:
2283 + p->attributes |= BLINK;
2284 + break;
2285 +
2286 + case 7:
2287 + p->attributes |= REVERSE;
2288 + break;
2289 +
2290 + case 21: case 22:
2291 + p->attributes = (p->attributes & ~I_MASK) | 1;
2292 + break;
2293 +
2294 + case 24:
2295 + p->attributes &= ~ULINE;
2296 + break;
2297 +
2298 + case 25:
2299 + p->attributes &= ~BLINK;
2300 + break;
2301 +
2302 + case 27:
2303 + p->attributes &= ~REVERSE;
2304 + break;
2305 +
2306 + case 38:
2307 + p->attributes |= ULINE;
2308 + p->color = (p->color & BG_MASK) | (p->defcolor & FG_MASK);
2309 + break;
2310 +
2311 + case 39:
2312 + p->attributes &= ~ULINE;
2313 + p->color = (p->color & BG_MASK) | (p->defcolor & FG_MASK);
2314 + break;
2315 +
2316 + case 49:
2317 + p->color = (p->defcolor & BG_MASK) | (p->color & FG_MASK);
2318 + break;
2319 +
2320 + default:
2321 + if (arg >= 30 && arg <= 37)
2322 + p->color = (p->color & BG_MASK) | color_table[arg-30];
2323 + else if (arg >= 40 && arg <= 47)
2324 + p->color = (p->color & FG_MASK) | (color_table[arg-40] << 4);
2325 + break;
2326 + }
2327 +
2328 + update_attr(p);
2329 +}
2330 +
2331 +static void csi_h(struct lcd_struct *p, unsigned char n)
2332 +{
2333 + switch (n) {
2334 + case 4: /* Set insert mode */
2335 + set_bit(DECIM, &p->struct_flags);
2336 + return;
2337 +
2338 + case 5: /* Inverted screen mode */
2339 + if (test_bit(QUES, &p->struct_flags) && ! test_bit(DECSCNM, &p->struct_flags)) {
2340 + set_bit(DECSCNM, &p->struct_flags);
2341 + lcd_invert_screen(p, 0, p->fb_size);
2342 + update_attr(p);
2343 + redraw_screen(p, 0, p->fb_size-1);
2344 + }
2345 + return;
2346 +
2347 + case 7: /* Set autowrap */
2348 + if (test_bit(QUES, &p->struct_flags))
2349 + set_bit(DECAWM, &p->struct_flags);
2350 + return;
2351 +
2352 + case 20: /* Set cr lf */
2353 + set_bit(CRLF, &p->struct_flags);
2354 + return;
2355 + }
2356 +}
2357 +
2358 +static void csi_l(struct lcd_struct *p, unsigned char n)
2359 +{
2360 + switch (n) {
2361 + case 4: /* Reset insert mode */
2362 + clear_bit(DECIM, &p->struct_flags);
2363 + return;
2364 +
2365 + case 5: /* Normal screen mode */
2366 + if (test_bit(QUES, &p->struct_flags) && test_bit(DECSCNM, &p->struct_flags)) {
2367 + clear_bit(DECSCNM, &p->struct_flags);
2368 + lcd_invert_screen(p, 0, p->fb_size);
2369 + update_attr(p);
2370 + redraw_screen(p, 0, p->fb_size-1);
2371 + }
2372 + return;
2373 +
2374 + case 7: /* Reset autowrap */
2375 + if (test_bit(QUES, &p->struct_flags))
2376 + clear_bit(DECAWM, &p->struct_flags);
2377 + return;
2378 +
2379 + case 20: /* Reset cr lf */
2380 + clear_bit(CRLF, &p->struct_flags);
2381 + return;
2382 + }
2383 +}
2384 +
2385 +static void csi_linux(struct lcd_struct *p)
2386 +{
2387 + switch (p->csi_args[0]) {
2388 + case 1:
2389 + if (test_bit(CAN_DO_COLOR, &p->struct_flags) && p->csi_args[1] < 16) {
2390 + p->ulcolor = color_table[p->csi_args[1]];
2391 + if (p->attributes & ULINE)
2392 + update_attr(p);
2393 + }
2394 + return;
2395 +
2396 + case 2:
2397 + if (test_bit(CAN_DO_COLOR, &p->struct_flags) && p->csi_args[1] < 16) {
2398 + p->halfcolor = color_table[p->csi_args[1]];
2399 + if ((p->attributes & I_MASK) == 0)
2400 + update_attr(p);
2401 + }
2402 + return;
2403 +
2404 + case 8:
2405 + p->defcolor = p->color;
2406 + default_attr(p);
2407 + update_attr(p);
2408 + return;
2409 + }
2410 +}
2411 +
2412 +static void csi_r(struct lcd_struct *p, unsigned int top, unsigned int bot)
2413 +{
2414 + /* Minimum allowed region is 2 lines */
2415 + if (top < bot) {
2416 + p->top = top-1;
2417 + p->bot = bot;
2418 + gotoxy(p, 0, 0);
2419 + }
2420 +}
2421 +
2422 +/*
2423 + * ECMA-48 CSI ESC- sequence handler.
2424 + */
2425 +static void handle_csi(struct lcd_struct *p, unsigned char input)
2426 +{
2427 + if (p->index >= NPAR) {
2428 + SET_INPUT_STATE(p, NORMAL);
2429 + printk(KERN_NOTICE "LCD: too many parameters in CSI escape sequence\n");
2430 + } else if (input == '?') {
2431 + set_bit(QUES, &p->struct_flags);
2432 + } else if (input == ';') {
2433 + ++p->index;
2434 + } else if (input >= '0' && input <= '9') {
2435 + p->csi_args[p->index] = (p->csi_args[p->index]*10)+(input-'0');
2436 + } else {
2437 + SET_INPUT_STATE(p, NORMAL);
2438 + if (! test_bit(INC_CURS_POS, &p->struct_flags))
2439 + return;
2440 + switch (input) {
2441 + case 'h': /* DECSET sequences and mode switches */
2442 + csi_h(p, p->csi_args[0]);
2443 + clear_bit(QUES, &p->struct_flags);
2444 + return;
2445 +
2446 + case 'l': /* DECRST sequences and mode switches */
2447 + csi_l(p, p->csi_args[0]);
2448 + clear_bit(QUES, &p->struct_flags);
2449 + return;
2450 + }
2451 + clear_bit(QUES, &p->struct_flags);
2452 + switch (input) {
2453 + case '@': /* Insert # Blank character */
2454 + csi_at(p, p->csi_args[0]);
2455 + return;
2456 +
2457 + case 'G': case '`': /* Cursor to indicated column in current row */
2458 + if (p->csi_args[0])
2459 + --p->csi_args[0];
2460 + gotoxy(p, p->csi_args[0], p->row);
2461 + return;
2462 +
2463 + case 'A': /* Cursor # rows Up */
2464 + if (! p->csi_args[0])
2465 + ++p->csi_args[0];
2466 + gotoxy(p, p->col, p->row-p->csi_args[0]);
2467 + return;
2468 +
2469 + case 'B': case 'e': /* Cursor # rows Down */
2470 + if (! p->csi_args[0])
2471 + ++p->csi_args[0];
2472 + gotoxy(p, p->col, p->row+p->csi_args[0]);
2473 + return;
2474 +
2475 + case 'C': case 'a': /* Cursor # columns Right */
2476 + if (! p->csi_args[0])
2477 + ++p->csi_args[0];
2478 + gotoxy(p, p->col+p->csi_args[0], p->row);
2479 + return;
2480 +
2481 + case 'D': /* Cursor # columns Left */
2482 + if (! p->csi_args[0])
2483 + ++p->csi_args[0];
2484 + gotoxy(p, p->col-p->csi_args[0], p->row);
2485 + return;
2486 +
2487 + case 'E': /* Cursor # rows Down, column 1 */
2488 + if (! p->csi_args[0])
2489 + ++p->csi_args[0];
2490 + gotoxy(p, 0, p->row+p->csi_args[0]);
2491 + return;
2492 +
2493 + case 'F': /* Cursor # rows Up, column 1 */
2494 + if (! p->csi_args[0])
2495 + ++p->csi_args[0];
2496 + gotoxy(p, 0, p->row-p->csi_args[0]);
2497 + return;
2498 +
2499 + case 'd': /* Cursor to indicated row in current column */
2500 + if (p->csi_args[0])
2501 + --p->csi_args[0];
2502 + gotoxy(p, p->col, p->csi_args[0]);
2503 + return;
2504 +
2505 + case 'H': case 'f': /* Cursor to indicated row, column (origin 1, 1) */
2506 + if (p->csi_args[0])
2507 + --p->csi_args[0];
2508 + if (p->csi_args[1])
2509 + --p->csi_args[1];
2510 + gotoxy(p, p->csi_args[1], p->csi_args[0]);
2511 + return;
2512 +
2513 + case 'J': /* Erase display */
2514 + csi_J(p, p->csi_args[0]);
2515 + return;
2516 +
2517 + case 'K': /* Erase line */
2518 + csi_K(p, p->csi_args[0]);
2519 + return;
2520 +
2521 + case 'L': /* Insert # blank lines */
2522 + csi_L(p, p->csi_args[0]);
2523 + return;
2524 +
2525 + case 'M': /* Delete # blank lines */
2526 + csi_M(p, p->csi_args[0]);
2527 + return;
2528 +
2529 + case 'P': /* Delete # characters on the current line */
2530 + csi_P(p, p->csi_args[0]);
2531 + return;
2532 +
2533 + case 'X': /* Erase # characters on the current line */
2534 + csi_X(p, p->csi_args[0]);
2535 + return;
2536 +
2537 + case 'm': /* Set video attributes */
2538 + csi_m(p, p->index);
2539 + return;
2540 +
2541 + case 's': /* Save cursor position */
2542 + case 'u': /* Restore cursor position */
2543 + csi_su(p, input);
2544 + return;
2545 +
2546 + case ']': /* Linux private ESC [ ] sequence */
2547 + csi_linux(p);
2548 + return;
2549 +
2550 + case 'r': /* Set the scrolling region */
2551 + if (! p->csi_args[0])
2552 + ++p->csi_args[0];
2553 + if (! p->csi_args[1] || p->csi_args[1] > p->par->vs_rows)
2554 + p->csi_args[1] = p->par->vs_rows;
2555 + csi_r(p, p->csi_args[0], p->csi_args[1]);
2556 + return;
2557 +
2558 + /* Ignored escape sequences */
2559 + case 'c':
2560 + case 'g':
2561 + case 'n':
2562 + case 'q':
2563 + return;
2564 +
2565 + default:
2566 + printk(KERN_NOTICE "LCD: unrecognized CSI escape sequence: ESC [ %u\n", input);
2567 + return;
2568 + }
2569 + }
2570 +}
2571 +
2572 +/*
2573 + * Custom ESC- sequence handler.
2574 + */
2575 +static int handle_custom_esc(struct lcd_struct *p, unsigned int _input)
2576 +{
2577 + unsigned char input = _input & 0xff;
2578 + struct lcd_parameters *par = p->par;
2579 +
2580 + if (_input & (~0xff)) {
2581 + switch (ESC_STATE(p)) {
2582 + case 's':
2583 + if (p->index++) {
2584 + unsigned char *buf = p->cgram_buffer+(p->cgram_index-par->cgram_char0)*par->cgram_bytes;
2585 +
2586 + buf[p->index-2] = input;
2587 + if (p->index == par->cgram_bytes+1)
2588 + write_cgram(p, p->cgram_index, buf);
2589 + } else {
2590 + if (! p->driver->write_cgram_char) {
2591 + printk(KERN_ERR "LCD: %s: missing function to write to CGRAM\n", p->par->name);
2592 + return (-1);
2593 + }
2594 + if (input >= par->cgram_char0 && input < par->cgram_char0+par->cgram_chars)
2595 + p->cgram_index = input;
2596 + else {
2597 + printk(KERN_NOTICE "LCD: bad CGRAM index\n");
2598 + return (-1);
2599 + }
2600 + }
2601 + return (0);
2602 +
2603 + case 'G':
2604 + if (input >= par->cgram_char0 && input < par->cgram_char0+par->cgram_chars)
2605 + write_data(p, (p->attr << 8) | p->driver->charmap[input]);
2606 + else {
2607 + SET_INPUT_STATE(p, NORMAL);
2608 + handle_input(p, (p->attr << 8) | input);
2609 + }
2610 + return (0);
2611 +
2612 + case 'r':
2613 + if (input == '1')
2614 + address_mode(p, -1);
2615 + else if (input == '0')
2616 + address_mode(p, 1);
2617 + return (0);
2618 +
2619 + case 'A':
2620 + scrup(p, p->top, p->bot, input);
2621 + return (0);
2622 +
2623 + case 'B':
2624 + scrdown(p, p->top, p->bot, input);
2625 + return (0);
2626 +
2627 + case 'C':
2628 + browse_screen(p, input);
2629 + return (0);
2630 + }
2631 + }
2632 +
2633 + /* These are the custom ESC- sequences */
2634 + switch (input) {
2635 + case 's': /* CGRAM select */
2636 + if (p->cgram_buffer) {
2637 + SET_ESC_STATE(p, input);
2638 + p->index = 0;
2639 + return (par->cgram_bytes+1);
2640 + } else {
2641 + printk(KERN_NOTICE "LCD: driver %s does not support CGRAM chars\n", par->name);
2642 + return (0);
2643 + }
2644 +
2645 + case 'A': /* Scroll up */
2646 + case 'B': /* Scroll down */
2647 + case 'C': /* Browse screen */
2648 + case 'G': /* Enter cgram mode */
2649 + case 'r': /* Decrement counter after data read/write */
2650 + SET_ESC_STATE(p, input);
2651 + return (1);
2652 + }
2653 +
2654 + return (-1);
2655 +}
2656 +
2657 +/*
2658 + * ESC- but not CSI sequence handler.
2659 + */
2660 +static int handle_esc(struct lcd_struct *p, unsigned char input)
2661 +{
2662 + int ret;
2663 +
2664 + SET_INPUT_STATE(p, NORMAL);
2665 + switch (input) {
2666 + case 'c': /* Reset */
2667 + set_bit(DECAWM, &p->struct_flags);
2668 + set_bit(INC_CURS_POS, &p->struct_flags);
2669 + ff(p);
2670 + return (0);
2671 +
2672 + case 'D': /* Line Feed */
2673 + lf(p);
2674 + return (0);
2675 +
2676 + case 'E': /* New Line */
2677 + cr(p);
2678 + lf(p);
2679 + return (0);
2680 +
2681 + case 'M': /* Reverse Line Feed */
2682 + ri(p);
2683 + return (0);
2684 +
2685 + case '7':
2686 + case '8':
2687 + csi_su(p, (input == '7' ? 's' : 'u'));
2688 + return (0);
2689 +
2690 + /* CSI: Start of CSI escape sequence */
2691 + case '[':
2692 + memset(p->csi_args, 0, sizeof(p->csi_args));
2693 + p->index = 0;
2694 + SET_INPUT_STATE(p, CSI);
2695 + return (0);
2696 +
2697 + /* Ignored escape sequences */
2698 + case '(':
2699 + SET_INPUT_STATE(p, ESC_G0);
2700 + return (1);
2701 +
2702 + case ')':
2703 + SET_INPUT_STATE(p, ESC_G1);
2704 + return (1);
2705 +
2706 + case '#':
2707 + SET_INPUT_STATE(p, ESC_HASH);
2708 + return (1);
2709 +
2710 + case '%':
2711 + SET_INPUT_STATE(p, ESC_PERCENT);
2712 + return (1);
2713 +
2714 + case 'H':
2715 + case 'Z':
2716 + case '>':
2717 + case '=':
2718 + case ']':
2719 + return (0);
2720 + }
2721 +
2722 + /* These are the custom ESC- sequences */
2723 + if ((ret = handle_custom_esc(p, input)) > 0) {
2724 + SET_INPUT_STATE(p, ARG);
2725 + return (ret);
2726 + }
2727 +
2728 + if (ret < 0 && p->driver->handle_custom_char)
2729 + if ((ret = p->driver->handle_custom_char(input)) > 0) {
2730 + SET_INPUT_STATE(p, ARG_DRIVER);
2731 + return (ret);
2732 + }
2733 +
2734 + if (ret < 0)
2735 + printk(KERN_NOTICE "LCD: unrecognized escape sequence: ESC %u\n", input);
2736 +
2737 + return (0);
2738 +}
2739 +
2740 +/*
2741 + * Main input handler.
2742 + */
2743 +static void handle_input(struct lcd_struct *p, unsigned short _input)
2744 +{
2745 + unsigned char input = _input & 0xff;
2746 + struct lcd_driver *driver = p->driver;
2747 +
2748 + switch (INPUT_STATE(p)) {
2749 + case NORMAL:
2750 + if (input < 0x20 || input == 0x9b)
2751 + control_char(p, input);
2752 + else
2753 + write_data(p, (_input & 0xff00) | driver->charmap[input]);
2754 + return;
2755 +
2756 + case RAW:
2757 + write_data(p, (_input & 0xff00) | driver->charmap[input]);
2758 + return;
2759 +
2760 + case SYN:
2761 + write_data(p, _input);
2762 + SET_INPUT_STATE(p, NORMAL);
2763 + return;
2764 +
2765 + case ESC:
2766 + p->esc_args = handle_esc(p, input);
2767 + return;
2768 +
2769 + case ESC_G0:
2770 + case ESC_G1:
2771 + case ESC_HASH:
2772 + case ESC_PERCENT:
2773 + if (! --p->esc_args)
2774 + SET_INPUT_STATE(p, NORMAL);
2775 + return;
2776 +
2777 + case CSI:
2778 + handle_csi(p, input);
2779 + return;
2780 +
2781 + case ARG:
2782 + if (handle_custom_esc(p, 0x100 | input) || ! --p->esc_args)
2783 + SET_INPUT_STATE(p, NORMAL);
2784 + return;
2785 +
2786 + case ARG_DRIVER:
2787 + if (driver->handle_custom_char(0x100 | input) || ! --p->esc_args)
2788 + SET_INPUT_STATE(p, NORMAL);
2789 + return;
2790 + }
2791 +}
2792 +
2793 +
2794 +
2795 +
2796 +
2797 +/***************************************
2798 + * Read from/Write to display routines *
2799 + ***************************************/
2800 +
2801 +/*
2802 + * Write character data to the display.
2803 + */
2804 +static void write_data(struct lcd_struct *p, unsigned short data)
2805 +{
2806 + unsigned int vs_cols = p->par->vs_cols;
2807 + unsigned int pos;
2808 + int frame_pos;
2809 +
2810 + if (test_bit(NEED_WRAP, &p->struct_flags)) {
2811 + cr(p);
2812 + lf(p);
2813 + }
2814 +
2815 + if (test_bit(DECIM, &p->struct_flags))
2816 + lcd_insert_char(p, 1);
2817 +
2818 + pos = (p->row*vs_cols)+p->col;
2819 + if ((frame_pos = vs_to_frame_(p, pos)) < 0) {
2820 + make_cursor_visible(p);
2821 + redraw_screen(p, 0, p->fb_size-1);
2822 + frame_pos = vs_to_frame_(p, pos);
2823 + }
2824 +
2825 + if (p->display[frame_pos] != data) {
2826 + p->driver->write_char(frame_pos, data);
2827 + p->display[frame_pos] = data;
2828 + }
2829 +
2830 + p->fb[pos] = data;
2831 +
2832 + if (test_bit(INC_CURS_POS, &p->struct_flags)) {
2833 + if (p->col+1 < vs_cols)
2834 + iterator_inc(p->col, vs_cols);
2835 + else if (test_bit(DECAWM, &p->struct_flags))
2836 + set_bit(NEED_WRAP, &p->struct_flags);
2837 + } else {
2838 + if (p->col)
2839 + iterator_dec(p->col, vs_cols);
2840 + else if (test_bit(DECAWM, &p->struct_flags))
2841 + set_bit(NEED_WRAP, &p->struct_flags);
2842 + }
2843 +}
2844 +
2845 +/*
2846 + * Write an entire CGRAM character to the display.
2847 + */
2848 +static void write_cgram(struct lcd_struct *p, unsigned char index, unsigned char *pixels)
2849 +{
2850 + unsigned int inc_set = test_bit(INC_CURS_POS, &p->struct_flags);
2851 +
2852 + if (! inc_set)
2853 + address_mode(p, 1);
2854 +
2855 + p->driver->write_cgram_char(index, pixels);
2856 +
2857 + if (! inc_set)
2858 + address_mode(p, -1);
2859 +}
2860 +
2861 +/*
2862 + * Read character data from the display.
2863 + */
2864 +static void read_data(struct lcd_struct *p, unsigned short *data)
2865 +{
2866 + unsigned int vs_rows = p->par->vs_rows;
2867 + unsigned int vs_cols = p->par->vs_cols;
2868 + unsigned int pos = (p->row*vs_cols)+p->col;
2869 + int frame_pos;
2870 +
2871 + if ((frame_pos = vs_to_frame_(p, pos)) < 0) {
2872 + make_cursor_visible(p);
2873 + redraw_screen(p, 0, p->fb_size-1);
2874 + frame_pos = vs_to_frame_(p, pos);
2875 + }
2876 +
2877 + p->driver->read_char(frame_pos, data);
2878 +
2879 + if (test_bit(INC_CURS_POS, &p->struct_flags)) {
2880 + iterator_inc(p->col, vs_cols);
2881 + if (! p->col) {
2882 + if (p->row+1 < vs_rows)
2883 + ++p->row;
2884 + }
2885 + } else {
2886 + iterator_dec(p->col, vs_cols);
2887 + if (p->col+1 == vs_cols) {
2888 + if (p->row)
2889 + --p->row;
2890 + }
2891 + }
2892 +}
2893 +
2894 +/*
2895 + * Read an entire CGRAM character from the display.
2896 + */
2897 +static void read_cgram(struct lcd_struct *p, unsigned char index, unsigned char *pixels)
2898 +{
2899 + unsigned int inc_set = test_bit(INC_CURS_POS, &p->struct_flags);
2900 +
2901 + if (! inc_set)
2902 + address_mode(p, 1);
2903 +
2904 + p->driver->read_cgram_char(index, pixels);
2905 +
2906 + if (! inc_set)
2907 + address_mode(p, -1);
2908 +}
2909 +
2910 +
2911 +
2912 +
2913 +
2914 +/****************************
2915 + * Proc filesystem routines *
2916 + ****************************/
2917 +#ifdef USE_PROC
2918 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 0)
2919 +/* create_proc_read_entry is missing in 2.2.x kernels */
2920 +static struct proc_dir_entry *create_proc_read_entry(const char *name, mode_t mode,
2921 + struct proc_dir_entry *parent, read_proc_t *read_proc, void *data)
2922 +{
2923 + struct proc_dir_entry *res = create_proc_entry(name, mode, parent);
2924 +
2925 + if (res) {
2926 + res->read_proc = read_proc;
2927 + res->data = data;
2928 + }
2929 +
2930 + return (res);
2931 +}
2932 +#endif
2933 +
2934 +static int proc_fb_read(char *buffer, char **start, off_t offset, int size, int *eof, void *data)
2935 +{
2936 + char *temp = buffer;
2937 + struct lcd_struct *p = (struct lcd_struct *)data;
2938 + unsigned int vs_cols;
2939 + static unsigned int nr, need_wrap;
2940 + static off_t _offset;
2941 +
2942 + down(&p->lcd_sem);
2943 + if (! offset)
2944 + _offset = 0;
2945 + if ((*eof = (_offset >= p->fb_size))) {
2946 + up(&p->lcd_sem);
2947 + return (0);
2948 + }
2949 + vs_cols = p->par->vs_cols;
2950 + if (size && need_wrap) {
2951 + need_wrap = 0;
2952 + temp += sprintf(temp, "\n");
2953 + --size;
2954 + }
2955 + if (! nr)
2956 + nr = vs_cols;
2957 + *start = (char *)0;
2958 + while (size && nr) {
2959 + unsigned char c = (p->fb[_offset] & 0xff);
2960 +
2961 + temp += sprintf(temp, "%c", (c < 0x20 ? '·' : c));
2962 + --size;
2963 + --nr;
2964 + ++*start;
2965 + ++_offset;
2966 + }
2967 + if (! nr) {
2968 + if (size) {
2969 + temp += sprintf(temp, "\n");
2970 + --size;
2971 + } else
2972 + need_wrap = 1;
2973 + }
2974 + up(&p->lcd_sem);
2975 +
2976 + return (temp-buffer);
2977 +}
2978 +
2979 +static int proc_display_read(char *buffer, char **start, off_t offset, int size, int *eof, void *data)
2980 +{
2981 + char *temp = buffer;
2982 + struct lcd_struct *p = (struct lcd_struct *)data;
2983 + unsigned int i, frame_cols;
2984 + int frame_pos;
2985 +
2986 + down(&p->lcd_sem);
2987 + frame_cols = p->par->cntr_cols;
2988 + frame_pos = vs_to_frame_(p, (p->row*p->par->vs_cols)+p->col);
2989 + temp += sprintf(temp, " ");
2990 + for (i = 2; i <= frame_cols; i += 2)
2991 + temp += sprintf(temp, " %d", i%10);
2992 + temp += sprintf(temp, "\n");
2993 +
2994 + temp += sprintf(temp, " +");
2995 + for (i = 0; i < frame_cols; ++i)
2996 + temp += sprintf(temp, "-");
2997 + temp += sprintf(temp, "+\n");
2998 +
2999 + for (i = 0; i < p->frame_size; ++i) {
3000 + unsigned char c = (p->display[i] & 0xff);
3001 +
3002 + if (! (i%frame_cols))
3003 + temp += sprintf(temp, "%2d |", 1+i/frame_cols);
3004 + if (frame_pos--)
3005 + temp += sprintf(temp, "%c", (c < 0x20 ? '·' : c));
3006 + else
3007 + temp += sprintf(temp, "_");
3008 + if (! ((i+1)%frame_cols))
3009 + temp += sprintf(temp, "|\n");
3010 + }
3011 +
3012 + temp += sprintf(temp, " +");
3013 + for (i = 0; i < frame_cols; ++i)
3014 + temp += sprintf(temp, "-");
3015 + temp += sprintf(temp, "+\n");
3016 + up(&p->lcd_sem);
3017 +
3018 + return (temp-buffer);
3019 +}
3020 +
3021 +static int proc_charmap_read(char *buffer, char **start, off_t offset, int size, int *eof, void *data)
3022 +{
3023 + char *temp = buffer;
3024 + struct lcd_struct *p = (struct lcd_struct *)data;
3025 + unsigned char *charmap;
3026 + unsigned int i;
3027 +
3028 + down(&p->lcd_sem);
3029 + charmap = p->driver->charmap;
3030 + temp += sprintf(temp, "static unsigned char charmap[] = {");
3031 + for (i = 0; i < 255; ++i) {
3032 + if (! (i & 7)) {
3033 + temp += sprintf(temp, "\n");
3034 + if (! (i & 31))
3035 + temp += sprintf(temp, "\n/* %d - %d */\n", i, i+31);
3036 + }
3037 + temp += sprintf(temp, "0x%.2x, ", *charmap++);
3038 + }
3039 + temp += sprintf(temp, "0x%.2x\n\n};\n", *charmap);
3040 + up(&p->lcd_sem);
3041 +
3042 + return (temp-buffer);
3043 +}
3044 +
3045 +static int proc_registered_drivers(char *buffer, char **start, off_t offset, int size, int *eof, void *data)
3046 +{
3047 + char *temp = buffer;
3048 + struct list_head *entry;
3049 +
3050 + down(&drivers_sem);
3051 + temp += sprintf(temp, "Registered drivers:\n");
3052 + list_for_each(entry, &lcd_drivers) {
3053 + struct lcd_struct *p = list_entry(entry, struct lcd_struct, lcd_list);
3054 +
3055 + down(&p->lcd_sem);
3056 + temp += sprintf(temp, "%3d %s\n", p->par->minor, p->par->name);
3057 + up(&p->lcd_sem);
3058 + }
3059 + up(&drivers_sem);
3060 +
3061 + return (temp-buffer);
3062 +}
3063 +
3064 +static void create_driver_proc_entries(struct lcd_struct *p)
3065 +{
3066 + struct proc_dir_entry *driver_proc_root = p->driver->driver_proc_root;
3067 + int proc_level = 0;
3068 +
3069 + SET_PROC_LEVEL(p, proc_level);
3070 + if (create_proc_read_entry("framebuffer", 0, driver_proc_root, proc_fb_read, p) == NULL) {
3071 + printk(KERN_ERR "LCD: cannot create /proc/lcd/%s/framebuffer\n", p->par->name);
3072 + return;
3073 + }
3074 + SET_PROC_LEVEL(p, ++proc_level);
3075 + if (create_proc_read_entry("display", 0, driver_proc_root, proc_display_read, p) == NULL) {
3076 + printk(KERN_ERR "LCD: cannot create /proc/lcd/%s/display\n", p->par->name);
3077 + return;
3078 + }
3079 + SET_PROC_LEVEL(p, ++proc_level);
3080 + if (create_proc_read_entry("charmap.h", 0, driver_proc_root, proc_charmap_read, p) == NULL) {
3081 + printk(KERN_ERR "LCD: cannot create /proc/lcd/%s/charmap.h\n", p->par->name);
3082 + return;
3083 + }
3084 + SET_PROC_LEVEL(p, ++proc_level);
3085 +}
3086 +
3087 +static void remove_driver_proc_entries(struct lcd_struct *p)
3088 +{
3089 + struct proc_dir_entry *driver_proc_root = p->driver->driver_proc_root;
3090 +
3091 + switch (PROC_LEVEL(p)) {
3092 + case 3:
3093 + remove_proc_entry("charmap.h", driver_proc_root);
3094 + case 2:
3095 + remove_proc_entry("display", driver_proc_root);
3096 + case 1:
3097 + remove_proc_entry("framebuffer", driver_proc_root);
3098 + }
3099 + SET_PROC_LEVEL(p, 0);
3100 +}
3101 +#endif
3102 +
3103 +
3104 +
3105 +
3106 +
3107 +/*****************************
3108 + * Low level file operations *
3109 + *****************************/
3110 +static ssize_t do_lcd_read(struct lcd_struct *p, void *buffer, size_t length)
3111 +{
3112 + unsigned int i;
3113 + unsigned short tmp;
3114 +
3115 + if (! p->refcount)
3116 + return (-ENXIO);
3117 +
3118 + if (! p->driver->read_char) {
3119 + printk(KERN_NOTICE "LCD: driver %s doesn't support reading\n", p->par->name);
3120 + return (-ENOSYS);
3121 + }
3122 +
3123 + if (test_bit(WITH_ATTR, &p->struct_flags))
3124 + for (i = 0; i < length; ++i) {
3125 + read_data(p, &tmp);
3126 + ((unsigned short *)buffer)[i] = tmp;
3127 + }
3128 + else
3129 + for (i = 0; i < length; ++i) {
3130 + read_data(p, &tmp);
3131 + ((unsigned char *)buffer)[i] = tmp & 0xff;
3132 + }
3133 +
3134 + return (length);
3135 +}
3136 +
3137 +static ssize_t do_lcd_write(struct lcd_struct *p, const void *buffer, size_t length)
3138 +{
3139 + unsigned int i;
3140 +
3141 + if (! p->refcount)
3142 + return (-ENXIO);
3143 +
3144 + if (test_bit(WITH_ATTR, &p->struct_flags))
3145 + for (i = 0; i < length; ++i)
3146 + handle_input(p, ((const unsigned short *)buffer)[i]);
3147 + else
3148 + for (i = 0; i < length; ++i)
3149 + handle_input(p, (p->attr << 8) | ((const unsigned char *)buffer)[i]);
3150 +
3151 + return (length);
3152 +}
3153 +
3154 +static int do_lcd_open(struct lcd_struct *p)
3155 +{
3156 + if (! p->refcount) {
3157 + if (p->driver->driver_module) {
3158 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
3159 + if (! try_module_get(p->driver->driver_module))
3160 + return (-EBUSY);
3161 +#else
3162 + if (__MOD_IN_USE(p->driver->driver_module))
3163 + return (-EBUSY);
3164 +
3165 + __MOD_INC_USE_COUNT(p->driver->driver_module);
3166 +#endif
3167 + }
3168 + }
3169 +
3170 + ++p->refcount;
3171 +
3172 + return (0);
3173 +}
3174 +
3175 +static int do_lcd_release(struct lcd_struct *p)
3176 +{
3177 + if (! p->refcount)
3178 + return (0);
3179 +
3180 + if (p->refcount == 1) {
3181 + if (p->driver->driver_module)
3182 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
3183 + module_put(p->driver->driver_module);
3184 +#else
3185 + __MOD_DEC_USE_COUNT(p->driver->driver_module);
3186 +#endif
3187 + }
3188 +
3189 + --p->refcount;
3190 +
3191 + return (0);
3192 +}
3193 +
3194 +static int cgram_ioctl(struct lcd_struct *p, unsigned int cmd, unsigned char *argp)
3195 +{
3196 + struct lcd_parameters *par = p->par;
3197 + unsigned int length = par->cgram_bytes;
3198 + unsigned char index = argp[0];
3199 + unsigned char *buffer = argp+1;
3200 + unsigned char *cgram_buffer = p->cgram_buffer+(index-par->cgram_char0)*length;
3201 +
3202 + if (index < par->cgram_char0 || index >= par->cgram_char0+par->cgram_chars)
3203 + return (-EINVAL);
3204 +
3205 + if (cmd == LCDL_SET_CGRAM_CHAR) {
3206 + if (! p->driver->write_cgram_char) {
3207 + printk(KERN_ERR "LCD: %s: missing function to write to CGRAM\n", p->par->name);
3208 + return (-ENOSYS);
3209 + }
3210 + if (test_bit(USER_SPACE, &p->struct_flags)) {
3211 + if (copy_from_user(cgram_buffer, buffer, length))
3212 + return (-EFAULT);
3213 + } else
3214 + memcpy(cgram_buffer, buffer, length);
3215 + write_cgram(p, index, cgram_buffer);
3216 + } else {
3217 + if (! p->driver->read_cgram_char) {
3218 + printk(KERN_ERR "LCD: %s: missing function to read from CGRAM or unable to read\n", p->par->name);
3219 + return (-ENOSYS);
3220 + }
3221 + read_cgram(p, index, cgram_buffer);
3222 + if (test_bit(USER_SPACE, &p->struct_flags)) {
3223 + if (copy_to_user(buffer, cgram_buffer, length))
3224 + return (-EFAULT);
3225 + } else
3226 + memcpy(buffer, cgram_buffer, length);
3227 + }
3228 +
3229 + return (0);
3230 +}
3231 +
3232 +static int do_lcd_ioctl(struct lcd_struct *p, unsigned int cmd, unsigned long arg)
3233 +{
3234 + int i;
3235 + struct lcd_driver *driver = p->driver;
3236 + struct lcd_parameters *par = p->par;
3237 + unsigned char *argp = (unsigned char *)arg;
3238 +
3239 + if (! p->refcount)
3240 + return (-ENXIO);
3241 +
3242 + switch (cmd) {
3243 + case LCDL_SET_PARAM:
3244 + if ((i = cleanup_driver(p)))
3245 + return (i);
3246 + i = par->minor;
3247 + if (test_bit(USER_SPACE, &p->struct_flags)) {
3248 + if (copy_from_user(par, argp, sizeof(struct lcd_parameters)))
3249 + return (-EFAULT);
3250 + } else
3251 + memcpy(par, argp, sizeof(struct lcd_parameters));
3252 + par->minor = i;
3253 + return (init_driver(p));
3254 +
3255 + case LCDL_GET_PARAM:
3256 + if (test_bit(USER_SPACE, &p->struct_flags)) {
3257 + if (copy_to_user(argp, par, sizeof(struct lcd_parameters)))
3258 + return (-EFAULT);
3259 + } else
3260 + memcpy(argp, par, sizeof(struct lcd_parameters));
3261 + return (0);
3262 +
3263 + case LCDL_RESET_CHARMAP:
3264 + for (i = 0; i < 256; ++i)
3265 + driver->charmap[i] = i;
3266 + return (0);
3267 +
3268 + case LCDL_CHARSUBST:
3269 + if (test_bit(USER_SPACE, &p->struct_flags)) {
3270 + get_user(i, argp);
3271 + get_user(driver->charmap[i], argp+1);
3272 + } else {
3273 + i = argp[0];
3274 + driver->charmap[i] = argp[1];
3275 + }
3276 + return (0);
3277 +
3278 + case LCDL_SAVE_CHARMAP:
3279 + memcpy(p->s_charmap, driver->charmap, 256);
3280 + return (0);
3281 +
3282 + case LCDL_RESTORE_CHARMAP:
3283 + memcpy(driver->charmap, p->s_charmap, 256);
3284 + return (0);
3285 +
3286 + case LCDL_SWAP_CHARMAP:
3287 + {
3288 + unsigned char *tmp;
3289 +
3290 + tmp = driver->charmap;
3291 + driver->charmap = p->s_charmap;
3292 + p->s_charmap = tmp;
3293 + }
3294 + return (0);
3295 +
3296 + case LCDL_RAW_MODE:
3297 + if (arg) {
3298 + clear_bit(NEED_WRAP, &p->struct_flags);
3299 + clear_bit(DECIM, &p->struct_flags);
3300 + clear_bit(DECAWM, &p->struct_flags);
3301 + SET_INPUT_STATE(p, RAW);
3302 + } else {
3303 + set_bit(DECAWM, &p->struct_flags);
3304 + SET_INPUT_STATE(p, NORMAL);
3305 + }
3306 + return (0);
3307 +
3308 + case LCDL_CLEAR_DISP:
3309 + ff(p);
3310 + return (0);
3311 +
3312 + case LCDL_SET_CGRAM_CHAR:
3313 + case LCDL_GET_CGRAM_CHAR:
3314 + if (p->cgram_buffer)
3315 + return (cgram_ioctl(p, cmd, argp));
3316 + else
3317 + printk(KERN_NOTICE "LCD: driver %s does not support CGRAM chars\n", par->name);
3318 + return (0);
3319 +
3320 + case LCDL_SET_CHARMAP:
3321 + if (test_bit(USER_SPACE, &p->struct_flags)) {
3322 + if (copy_from_user(driver->charmap, argp, 256))
3323 + return (-EFAULT);
3324 + } else
3325 + memcpy(driver->charmap, argp, 256);
3326 + return (0);
3327 +
3328 + case LCDL_GET_CHARMAP:
3329 + if (test_bit(USER_SPACE, &p->struct_flags)) {
3330 + if (copy_to_user(argp, driver->charmap, 256))
3331 + return (-EFAULT);
3332 + } else
3333 + memcpy(argp, driver->charmap, 256);
3334 + return (0);
3335 +
3336 + case LCDL_MEMSET:
3337 + case LCDL_MEMMOVE:
3338 + {
3339 + int buf[3];
3340 +
3341 + if (test_bit(USER_SPACE, &p->struct_flags)) {
3342 + if (copy_from_user(buf, argp, sizeof(buf)))
3343 + return (-EFAULT);
3344 + } else
3345 + memcpy(buf, argp, sizeof(buf));
3346 +
3347 + if (cmd == LCDL_MEMSET)
3348 + lcd_memset(p, buf[0], buf[1], buf[2]);
3349 + else
3350 + lcd_memmove(p, buf[0], buf[1], buf[2]);
3351 +
3352 + return (0);
3353 + }
3354 +
3355 + default:
3356 + if (driver->handle_custom_ioctl)
3357 + return (driver->handle_custom_ioctl(cmd, arg, test_bit(USER_SPACE, &p->struct_flags)));
3358 + }
3359 +
3360 + return (-ENOIOCTLCMD);
3361 +}
3362 +
3363 +
3364 +
3365 +
3366 +
3367 +/**************************************************
3368 + * Kernel register/unregister lcd driver routines *
3369 + **************************************************/
3370 +/*
3371 + * Find a driver in lcd_drivers linked list
3372 + */
3373 +static struct lcd_struct *find_lcd_struct(unsigned short minor)
3374 +{
3375 + struct list_head *entry;
3376 +
3377 + list_for_each(entry, &lcd_drivers) {
3378 + struct lcd_struct *p = list_entry(entry, struct lcd_struct, lcd_list);
3379 +
3380 + if (p->par->minor == minor)
3381 + return (p);
3382 + }
3383 +
3384 + return (NULL);
3385 +}
3386 +
3387 +static void list_add_sorted(struct list_head *new)
3388 +{
3389 + struct list_head *entry;
3390 + unsigned short new_minor = (list_entry(new, struct lcd_struct, lcd_list))->par->minor;
3391 +
3392 + list_for_each(entry, &lcd_drivers) {
3393 + struct lcd_struct *p = list_entry(entry, struct lcd_struct, lcd_list);
3394 +
3395 + if (p->par->minor > new_minor)
3396 + break;
3397 + }
3398 + list_add_tail(new, entry);
3399 +}
3400 +
3401 +/* Exported function */
3402 +int lcd_register_driver(struct lcd_driver *driver, struct lcd_parameters *par)
3403 +{
3404 + int ret;
3405 + struct lcd_struct *p;
3406 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19)
3407 + struct device *lcd_device;
3408 +#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 13)
3409 + struct class_device *lcd_class_device;
3410 +#endif
3411 +
3412 + if (! driver || ! par || par->minor >= minors)
3413 + return (-EINVAL);
3414 + if (! driver->write_char || ! driver->init_port || ! driver->cleanup_port) {
3415 + printk(KERN_ERR "LCD: missing functions\n");
3416 + return (-EINVAL);
3417 + }
3418 +
3419 + down(&drivers_sem);
3420 +
3421 + if (find_lcd_struct(par->minor)) {
3422 + up(&drivers_sem);
3423 + return (-EBUSY);
3424 + }
3425 +
3426 + if ((p = (struct lcd_struct *)kmalloc(sizeof(struct lcd_struct), GFP_KERNEL)) == NULL) {
3427 + printk(KERN_ERR "LCD: memory allocation failed (kmalloc)\n");
3428 + up(&drivers_sem);
3429 + return (-ENOMEM);
3430 + }
3431 + memset(p, 0, sizeof(struct lcd_struct));
3432 +
3433 + p->driver = driver;
3434 + p->par = par;
3435 + p->refcount = 0;
3436 + SET_INIT_LEVEL(p, 0);
3437 + SET_INPUT_STATE(p, NORMAL);
3438 + set_bit(DECAWM, &p->struct_flags);
3439 + set_bit(INC_CURS_POS, &p->struct_flags);
3440 +
3441 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19)
3442 + lcd_device = device_create(lcd_linux_class, NULL, MKDEV(major, par->minor), "%s", par->name);
3443 + if (IS_ERR(lcd_device)) {
3444 + kfree(p);
3445 + up(&drivers_sem);
3446 + return (PTR_ERR(lcd_device));
3447 + }
3448 +#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 15)
3449 + lcd_class_device = class_device_create(lcd_linux_class, NULL, MKDEV(major, par->minor), NULL, "%s", par->name);
3450 + if (IS_ERR(lcd_class_device)) {
3451 + kfree(p);
3452 + up(&drivers_sem);
3453 + return (PTR_ERR(lcd_class_device));
3454 + }
3455 +#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 13)
3456 + lcd_class_device = class_device_create(lcd_linux_class, MKDEV(major, par->minor), NULL, "%s", par->name);
3457 + if (IS_ERR(lcd_class_device)) {
3458 + kfree(p);
3459 + up(&drivers_sem);
3460 + return (PTR_ERR(lcd_class_device));
3461 + }
3462 +#endif
3463 +
3464 +#ifdef USE_PROC
3465 + if (lcd_proc_root && (driver->driver_proc_root = proc_mkdir(par->name, lcd_proc_root)) == NULL)
3466 + printk(KERN_ERR "LCD: cannot create /proc/lcd/%s/\n", par->name);
3467 +#endif
3468 +
3469 + if ((ret = init_driver(p))) {
3470 +#ifdef USE_PROC
3471 + if (driver->driver_proc_root)
3472 + remove_proc_entry(p->par->name, lcd_proc_root);
3473 +#endif
3474 + kfree(p);
3475 + up(&drivers_sem);
3476 + return (ret);
3477 + }
3478 +
3479 + init_MUTEX(&p->lcd_sem);
3480 +
3481 + list_add_sorted(&p->lcd_list);
3482 +
3483 + up(&drivers_sem);
3484 +
3485 +#ifdef MODULE
3486 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
3487 + try_module_get(THIS_MODULE);
3488 +#else
3489 + MOD_INC_USE_COUNT;
3490 +#endif
3491 +#endif
3492 +
3493 + return (0);
3494 +}
3495 +EXPORT_SYMBOL(lcd_register_driver);
3496 +
3497 +/* Exported function */
3498 +int lcd_unregister_driver(struct lcd_driver *driver, struct lcd_parameters *par)
3499 +{
3500 + int ret;
3501 + struct lcd_struct *p;
3502 +
3503 + if (! driver || ! par || par->minor >= minors)
3504 + return (-EINVAL);
3505 +
3506 + down(&drivers_sem);
3507 +
3508 + if ((p = find_lcd_struct(par->minor)) == NULL || p->driver != driver) {
3509 + printk(KERN_ERR "LCD: driver not found; lcd_unregister_driver failed\n");
3510 + up(&drivers_sem);
3511 + return (-ENODEV);
3512 + }
3513 +
3514 + down(&p->lcd_sem);
3515 +
3516 + if (p->refcount) {
3517 + printk(KERN_ERR "LCD: driver busy; lcd_unregister_driver failed\n");
3518 + up(&p->lcd_sem);
3519 + up(&drivers_sem);
3520 + return (-EBUSY);
3521 + }
3522 +
3523 + if ((ret = cleanup_driver(p))) {
3524 + up(&p->lcd_sem);
3525 + up(&drivers_sem);
3526 + return (ret);
3527 + }
3528 +
3529 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19)
3530 + device_destroy(lcd_linux_class, MKDEV(major, par->minor));
3531 +#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 13)
3532 + class_device_destroy(lcd_linux_class, MKDEV(major, par->minor));
3533 +#endif
3534 +
3535 +#ifdef USE_PROC
3536 + if (p->driver->driver_proc_root)
3537 + remove_proc_entry(p->par->name, lcd_proc_root);
3538 +#endif
3539 +
3540 + list_del(&p->lcd_list);
3541 + kfree(p);
3542 +
3543 + up(&drivers_sem);
3544 +
3545 +#ifdef MODULE
3546 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
3547 + module_put(THIS_MODULE);
3548 +#else
3549 + MOD_DEC_USE_COUNT;
3550 +#endif
3551 +#endif
3552 +
3553 + return (0);
3554 +}
3555 +EXPORT_SYMBOL(lcd_unregister_driver);
3556 +
3557 +
3558 +
3559 +
3560 +
3561 +/************************
3562 + * Kernel I/O interface *
3563 + ************************/
3564 +/* Exported function */
3565 +int lcd_open(unsigned short minor, struct lcd_struct **pp)
3566 +{
3567 + int ret;
3568 + struct lcd_struct *p;
3569 +
3570 + down(&drivers_sem);
3571 +
3572 + if (minor >= minors || (*pp = p = find_lcd_struct(minor)) == NULL) {
3573 + printk(KERN_ERR "LCD: lcd_open failed. Device not found.\n");
3574 + up(&drivers_sem);
3575 + return (-ENODEV);
3576 + }
3577 +
3578 + down(&p->lcd_sem);
3579 + up(&drivers_sem);
3580 +
3581 + ret = do_lcd_open(p);
3582 +
3583 + up(&p->lcd_sem);
3584 +
3585 + return (ret);
3586 +}
3587 +EXPORT_SYMBOL(lcd_open);
3588 +
3589 +/* Exported function */
3590 +int lcd_close(struct lcd_struct **pp)
3591 +{
3592 + int ret;
3593 + struct lcd_struct *p;
3594 +
3595 + if (! pp || ! (p = *pp)) {
3596 + printk(KERN_ERR "LCD: NULL pointer in lcd_close\n");
3597 + return (-ENODEV);
3598 + }
3599 +
3600 + down(&p->lcd_sem);
3601 +
3602 + if (! (ret = do_lcd_release(p)))
3603 + *pp = NULL;
3604 +
3605 + up(&p->lcd_sem);
3606 +
3607 + return (ret);
3608 +}
3609 +EXPORT_SYMBOL(lcd_close);
3610 +
3611 +static inline loff_t offset_to_row_col(struct lcd_struct *p, loff_t offset)
3612 +{
3613 + unsigned long _offset = offset;
3614 + unsigned int vs_cols = p->par->vs_cols;
3615 +
3616 + gotoxy(p, _offset%vs_cols, _offset/vs_cols);
3617 +
3618 + return ((p->row*vs_cols)+p->col);
3619 +}
3620 +
3621 +/* Exported function */
3622 +ssize_t lcd_read(struct lcd_struct *p, void *bufp, size_t length, loff_t offset, unsigned int with_attr)
3623 +{
3624 + ssize_t ret = 0;
3625 +
3626 + if (! p) {
3627 + printk(KERN_ERR "LCD: NULL pointer in lcd_read\n");
3628 + return (-ENODEV);
3629 + }
3630 + if (! bufp)
3631 + return (-EFAULT);
3632 + if (offset < 0 || offset >= p->fb_size)
3633 + return (-EINVAL);
3634 +
3635 + if (length+offset > p->fb_size)
3636 + length = p->fb_size-offset;
3637 +
3638 + if (with_attr)
3639 + set_bit(WITH_ATTR, &p->struct_flags);
3640 +
3641 + offset_to_row_col(p, offset);
3642 + ret = do_lcd_read(p, bufp, length);
3643 +
3644 + if (with_attr)
3645 + clear_bit(WITH_ATTR, &p->struct_flags);
3646 +
3647 + return (ret);
3648 +}
3649 +EXPORT_SYMBOL(lcd_read);
3650 +
3651 +/* Exported function */
3652 +ssize_t lcd_write(struct lcd_struct *p, const void *bufp, size_t length, loff_t offset, unsigned int with_attr)
3653 +{
3654 + ssize_t ret;
3655 +
3656 + if (! p) {
3657 + printk(KERN_ERR "LCD: NULL pointer in lcd_write\n");
3658 + return (-ENODEV);
3659 + }
3660 + if (! bufp)
3661 + return (-EFAULT);
3662 + if (offset < 0 || offset >= p->fb_size)
3663 + return (-EINVAL);
3664 +
3665 + if (with_attr)
3666 + set_bit(WITH_ATTR, &p->struct_flags);
3667 +
3668 + offset_to_row_col(p, offset);
3669 + ret = do_lcd_write(p, bufp, length);
3670 +
3671 + if (with_attr)
3672 + clear_bit(WITH_ATTR, &p->struct_flags);
3673 +
3674 + return (ret);
3675 +}
3676 +EXPORT_SYMBOL(lcd_write);
3677 +
3678 +/* Exported function */
3679 +int lcd_ioctl(struct lcd_struct *p, unsigned int cmd, ...)
3680 +{
3681 + int ret;
3682 + unsigned long arg;
3683 + va_list ap;
3684 +
3685 + if (! p) {
3686 + printk(KERN_ERR "LCD: NULL pointer in lcd_ioctl\n");
3687 + return (-ENODEV);
3688 + }
3689 +
3690 + down(&p->lcd_sem);
3691 + va_start(ap, cmd);
3692 + arg = va_arg(ap, unsigned long);
3693 + ret = do_lcd_ioctl(p, cmd, arg);
3694 + va_end(ap);
3695 + up(&p->lcd_sem);
3696 +
3697 + return (ret);
3698 +}
3699 +EXPORT_SYMBOL(lcd_ioctl);
3700 +
3701 +
3702 +
3703 +
3704 +
3705 +/*******************
3706 + * File operations *
3707 + *******************/
3708 +static loff_t lcd_fops_llseek(struct file *filp, loff_t offset, int orig)
3709 +{
3710 + struct lcd_struct *p;
3711 +
3712 + if (! (p = filp->private_data))
3713 + return (-ENODEV);
3714 +
3715 + down(&p->lcd_sem);
3716 +
3717 + switch (orig) {
3718 + case 0:
3719 + filp->f_pos = offset;
3720 + break;
3721 +
3722 + case 1:
3723 + filp->f_pos += offset;
3724 + break;
3725 +
3726 + default:
3727 + up(&p->lcd_sem);
3728 + return (-EINVAL); /* SEEK_END not supported */
3729 + }
3730 +
3731 + filp->f_pos = offset_to_row_col(p, filp->f_pos);
3732 +
3733 + up(&p->lcd_sem);
3734 +
3735 + return (filp->f_pos);
3736 +}
3737 +
3738 +static ssize_t lcd_fops_read(struct file *filp, char *buffer, size_t length, loff_t *offp)
3739 +{
3740 + ssize_t ret = 0;
3741 + char *bufp = buffer;
3742 + struct lcd_struct *p;
3743 +
3744 + if (! bufp)
3745 + return (-EFAULT);
3746 + if (! (p = filp->private_data))
3747 + return (-ENODEV);
3748 +
3749 + down(&p->lcd_sem);
3750 +
3751 + if (*offp < 0 || *offp >= p->fb_size) {
3752 + up(&p->lcd_sem);
3753 + return (-EINVAL);
3754 + }
3755 +
3756 + if (length+(*offp) > p->fb_size)
3757 + length = p->fb_size-(*offp);
3758 +
3759 + while (length) {
3760 + ret = (length > FLIP_BUF_SIZE ? FLIP_BUF_SIZE : length);
3761 + if ((ret = do_lcd_read(p, p->flip_buf, ret)) < 0)
3762 + break;
3763 + *offp = (p->row*p->par->vs_cols)+p->col;
3764 + if (copy_to_user(bufp, p->flip_buf, ret)) {
3765 + ret = -EFAULT;
3766 + break;
3767 + }
3768 + length -= ret;
3769 + bufp += ret;
3770 + ret = bufp-buffer;
3771 + if (length)
3772 + schedule();
3773 + }
3774 +
3775 + up(&p->lcd_sem);
3776 +
3777 + return (ret);
3778 +}
3779 +
3780 +static ssize_t lcd_fops_write(struct file *filp, const char *buffer, size_t length, loff_t *offp)
3781 +{
3782 + ssize_t ret = 0;
3783 + const char *bufp = buffer;
3784 + struct lcd_struct *p;
3785 +
3786 + if (! bufp)
3787 + return (-EFAULT);
3788 + if (! (p = filp->private_data))
3789 + return (-ENODEV);
3790 +
3791 + down(&p->lcd_sem);
3792 +
3793 + if (*offp < 0 || *offp >= p->fb_size) {
3794 + up(&p->lcd_sem);
3795 + return (-EINVAL);
3796 + }
3797 +
3798 + while (length) {
3799 + ret = (length > FLIP_BUF_SIZE ? FLIP_BUF_SIZE : length);
3800 + if (copy_from_user(p->flip_buf, bufp, ret)) {
3801 + ret = -EFAULT;
3802 + break;
3803 + }
3804 + if ((ret = do_lcd_write(p, p->flip_buf, ret)) < 0)
3805 + break;
3806 + *offp = (p->row*p->par->vs_cols)+p->col;
3807 + length -= ret;
3808 + bufp += ret;
3809 + ret = bufp-buffer;
3810 + if (length)
3811 + schedule();
3812 + }
3813 +
3814 + up(&p->lcd_sem);
3815 +
3816 + return (ret);
3817 +}
3818 +
3819 +static int lcd_fops_open(struct inode *inop, struct file *filp)
3820 +{
3821 + unsigned short minor;
3822 + int ret;
3823 + struct lcd_struct *p;
3824 +
3825 + down(&drivers_sem);
3826 +
3827 + if ((minor = MINOR(inop->i_rdev)) >= minors || (filp->private_data = p = find_lcd_struct(minor)) == NULL) {
3828 + up(&drivers_sem);
3829 + return (-ENODEV);
3830 + }
3831 +
3832 + down(&p->lcd_sem);
3833 + up(&drivers_sem);
3834 +
3835 + ret = do_lcd_open(p);
3836 +
3837 + up(&p->lcd_sem);
3838 +
3839 + return (ret);
3840 +}
3841 +
3842 +static int lcd_fops_release(struct inode *inop, struct file *filp)
3843 +{
3844 + struct lcd_struct *p;
3845 + int ret;
3846 +
3847 + if (! (p = filp->private_data))
3848 + return (-ENODEV);
3849 +
3850 + down(&p->lcd_sem);
3851 +
3852 + if (! (ret = do_lcd_release(p)))
3853 + filp->private_data = NULL;
3854 +
3855 + up(&p->lcd_sem);
3856 +
3857 + return (ret);
3858 +}
3859 +
3860 +static int lcd_fops_ioctl(struct inode *inop, struct file *filp, unsigned int cmd, unsigned long arg)
3861 +{
3862 + struct lcd_struct *p;
3863 + int ret;
3864 +
3865 + if (! (p = filp->private_data))
3866 + return (-ENODEV);
3867 +
3868 + down(&p->lcd_sem);
3869 +
3870 + set_bit(USER_SPACE, &p->struct_flags);
3871 + ret = do_lcd_ioctl(p, cmd, arg);
3872 + clear_bit(USER_SPACE, &p->struct_flags);
3873 +
3874 + up(&p->lcd_sem);
3875 +
3876 + return (ret);
3877 +}
3878 +
3879 +static struct file_operations lcd_linux_fops = {
3880 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 0)
3881 + .owner = THIS_MODULE,
3882 +#endif
3883 + .llseek = lcd_fops_llseek,
3884 + .read = lcd_fops_read,
3885 + .write = lcd_fops_write,
3886 + .open = lcd_fops_open,
3887 + .release = lcd_fops_release,
3888 + .ioctl = lcd_fops_ioctl,
3889 +};
3890 +
3891 +
3892 +
3893 +
3894 +
3895 +/********************************
3896 + * Init/Cleanup driver routines *
3897 + ********************************/
3898 +static int do_init_driver(struct lcd_struct *p)
3899 +{
3900 + int ret, init_level;
3901 + struct lcd_driver *driver = p->driver;
3902 + struct lcd_parameters *par = p->par;
3903 + unsigned int frame_rows = par->cntr_rows*par->num_cntr;
3904 + unsigned int frame_cols = par->cntr_cols;
3905 +
3906 + switch ((init_level = INIT_LEVEL(p))) {
3907 + case 0:
3908 + if (frame_rows == 0 || frame_cols == 0 || ! par->name) {
3909 + printk(KERN_ERR "LCD: wrong lcd parameters\n");
3910 + return (-EINVAL);
3911 + }
3912 + if (driver->validate_driver) {
3913 + if ((ret = driver->validate_driver()) < 0) {
3914 + printk(KERN_ERR "LCD: validate_driver failed\n");
3915 + return (-EINVAL);
3916 + } else if (ret > 0) {
3917 + set_bit(CAN_DO_COLOR, &p->struct_flags);
3918 + p->defcolor = 0x07;
3919 + p->ulcolor = 0x0f;
3920 + p->halfcolor = 0x08;
3921 + }
3922 + }
3923 + default_attr(p);
3924 + update_attr(p);
3925 + p->frame_size = frame_rows*frame_cols;
3926 + if (par->vs_rows < frame_rows)
3927 + par->vs_rows = frame_rows;
3928 + if (par->vs_cols < frame_cols)
3929 + par->vs_cols = frame_cols;
3930 + p->fb_size = par->vs_rows*par->vs_cols;
3931 +
3932 + ret = sizeof(short)*p->fb_size;
3933 + ret += sizeof(short)*p->frame_size;
3934 + ret += FLIP_BUF_SIZE;
3935 + ret += (p->driver->charmap ? 256 : 512);
3936 + ret += par->cgram_chars*par->cgram_bytes;
3937 + if ((p->fb = (unsigned short *)vmalloc(ret)) == NULL) {
3938 + printk(KERN_ERR "LCD: memory allocation failed (vmalloc)\n");
3939 + return (-ENOMEM);
3940 + }
3941 + __memset_short(p->fb, p->erase_char, p->fb_size+p->frame_size);
3942 +
3943 + p->display = p->fb+p->fb_size;
3944 + p->flip_buf = (unsigned char *)(p->display+p->frame_size);
3945 +
3946 + if (! p->driver->charmap) {
3947 + set_bit(NULL_CHARMAP, &p->struct_flags);
3948 + p->driver->charmap = p->flip_buf+FLIP_BUF_SIZE;
3949 + for (ret = 0; ret < 256; ++ret)
3950 + p->driver->charmap[ret] = ret;
3951 + p->s_charmap = p->driver->charmap+256;
3952 + } else
3953 + p->s_charmap = p->flip_buf+FLIP_BUF_SIZE;
3954 + memset(p->s_charmap, 0, 256);
3955 +
3956 + if (par->cgram_chars*par->cgram_bytes) {
3957 + p->cgram_buffer = p->s_charmap+256;
3958 + memset(p->cgram_buffer, 0, par->cgram_chars*par->cgram_bytes);
3959 + } else
3960 + p->cgram_buffer = NULL;
3961 +
3962 + p->frame_base = 0;
3963 + p->row = p->col = 0;
3964 + p->top = 0;
3965 + p->bot = par->vs_rows;
3966 + SET_INIT_LEVEL(p, ++init_level);
3967 +
3968 + case 1:
3969 + /* Initialize the communication port */
3970 + if ((ret = driver->init_port())) {
3971 + printk(KERN_ERR "LCD: failure while initializing the communication port\n");
3972 + return (ret);
3973 + }
3974 + SET_INIT_LEVEL(p, ++init_level);
3975 +
3976 + case 2:
3977 + /* Initialize LCD display */
3978 + if (driver->init_display && (ret = driver->init_display())) {
3979 + printk(KERN_ERR "LCD: failure while initializing the display\n");
3980 + return (ret);
3981 + }
3982 +
3983 +#ifdef USE_PROC
3984 + /* Create entries in /proc/lcd/"driver" */
3985 + if (driver->driver_proc_root)
3986 + create_driver_proc_entries(p);
3987 +#endif
3988 + SET_INIT_LEVEL(p, ++init_level);
3989 + }
3990 +
3991 + return (0);
3992 +}
3993 +
3994 +static int do_cleanup_driver(struct lcd_struct *p)
3995 +{
3996 + int ret, init_level;
3997 + struct lcd_driver *driver = p->driver;
3998 +
3999 + switch ((init_level = INIT_LEVEL(p))) {
4000 + case 3:
4001 +#ifdef USE_PROC
4002 + if (driver->driver_proc_root)
4003 + remove_driver_proc_entries(p);
4004 +#endif
4005 + if (driver->cleanup_display && (ret = driver->cleanup_display())) {
4006 + printk(KERN_ERR "LCD: failure while cleaning the display\n");
4007 + return (ret);
4008 + }
4009 + SET_INIT_LEVEL(p, --init_level);
4010 +
4011 + case 2:
4012 + if ((ret = driver->cleanup_port())) {
4013 + printk(KERN_ERR "LCD: failure while cleaning the communication port\n");
4014 + return (ret);
4015 + }
4016 + SET_INIT_LEVEL(p, --init_level);
4017 +
4018 + case 1:
4019 + if (test_bit(NULL_CHARMAP, &p->struct_flags)) {
4020 + p->driver->charmap = NULL;
4021 + clear_bit(NULL_CHARMAP, &p->struct_flags);
4022 + }
4023 + vfree(p->fb);
4024 + p->fb = NULL;
4025 + SET_INIT_LEVEL(p, --init_level);
4026 + }
4027 +
4028 + return (0);
4029 +}
4030 +
4031 +static int init_driver(struct lcd_struct *p)
4032 +{
4033 + int ret;
4034 +
4035 + if ((ret = do_init_driver(p))) {
4036 + do_cleanup_driver(p);
4037 + printk(KERN_ERR "LCD: init_driver failed\n");
4038 + }
4039 +
4040 + return (ret);
4041 +}
4042 +
4043 +static int cleanup_driver(struct lcd_struct *p)
4044 +{
4045 + int ret;
4046 +
4047 + if ((ret = do_cleanup_driver(p))) {
4048 + do_init_driver(p);
4049 + printk(KERN_ERR "LCD: cleanup_driver failed\n");
4050 + }
4051 +
4052 + return (ret);
4053 +}
4054 +
4055 +
4056 +
4057 +
4058 +
4059 +/********************************
4060 + * Init/Cleanup module routines *
4061 + ********************************/
4062 +static int __init lcd_linux_init_module(void)
4063 +{
4064 + int ret;
4065 +
4066 + if (! minors || minors > 256)
4067 + minors = LCD_MINORS;
4068 +
4069 + init_MUTEX(&drivers_sem);
4070 +
4071 + if ((ret = register_chrdev(major, LCD_LINUX_STRING, &lcd_linux_fops)) < 0) {
4072 + printk(KERN_ERR "LCD: register_chrdev failed\n");
4073 + return (ret);
4074 + }
4075 + if (major == 0)
4076 + major = ret;
4077 +
4078 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 13)
4079 + if (IS_ERR((lcd_linux_class = class_create(THIS_MODULE, "lcd")))) {
4080 + ret = PTR_ERR(lcd_linux_class);
4081 + unregister_chrdev(major, LCD_LINUX_STRING);
4082 + return (ret);
4083 + }
4084 +#endif
4085 +
4086 +#ifdef USE_PROC
4087 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26)
4088 + if ((lcd_proc_root = proc_mkdir("lcd", NULL)) == NULL)
4089 +#else
4090 + if ((lcd_proc_root = proc_mkdir("lcd", &proc_root)) == NULL)
4091 +#endif
4092 + printk(KERN_ERR "LCD: cannot create /proc/lcd/\n");
4093 + else if (create_proc_read_entry("drivers", 0, lcd_proc_root, proc_registered_drivers, NULL) == NULL)
4094 + printk(KERN_ERR "LCD: cannot create /proc/lcd/drivers\n");
4095 +#endif
4096 +
4097 + printk(KERN_INFO "LCD: --> LCD-Linux " LCD_LINUX_VERSION " <--\n");
4098 + printk(KERN_INFO "LCD: --> Mattia Jona-Lasinio <mjona@users.sourceforge.net> <--\n" );
4099 +
4100 +
4101 + return (0);
4102 +}
4103 +
4104 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 0)
4105 +static void __exit lcd_linux_cleanup_module(void)
4106 +#else
4107 +/* __exit is not defined in 2.2.x kernels */
4108 +static void lcd_linux_cleanup_module(void)
4109 +#endif
4110 +{
4111 +#ifdef USE_PROC
4112 + if (lcd_proc_root) {
4113 + remove_proc_entry("drivers", lcd_proc_root);
4114 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26)
4115 + remove_proc_entry("lcd", NULL);
4116 +#else
4117 + remove_proc_entry("lcd", &proc_root);
4118 +#endif
4119 + }
4120 +#endif
4121 +
4122 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 13)
4123 + class_destroy(lcd_linux_class);
4124 +#endif
4125 +
4126 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 23)
4127 + unregister_chrdev(major, LCD_LINUX_STRING);
4128 +#else
4129 + if (unregister_chrdev(major, LCD_LINUX_STRING))
4130 + printk(KERN_ERR "LCD: unregister_chrdev failed\n");
4131 +#endif
4132 +}
4133 +
4134 +module_init(lcd_linux_init_module)
4135 +module_exit(lcd_linux_cleanup_module)
4136 Index: linux-2.6.30.9/include/linux/hd44780.h
4137 ===================================================================
4138 --- /dev/null 1970-01-01 00:00:00.000000000 +0000
4139 +++ linux-2.6.30.9/include/linux/hd44780.h 2009-11-24 02:01:42.000000000 +0100
4140 @@ -0,0 +1,46 @@
4141 +/* hd44780.h
4142 + *
4143 + *
4144 + * LCD-Linux:
4145 + * Driver for HD44780 compatible displays connected to the parallel port.
4146 + *
4147 + * HD44780 header file.
4148 + *
4149 + * Copyright (C) 2004 - 2007 Mattia Jona-Lasinio (mjona@users.sourceforge.net)
4150 + *
4151 + * This program is free software; you can redistribute it and/or modify
4152 + * it under the terms of the GNU General Public License as published by
4153 + * the Free Software Foundation; either version 2 of the License, or
4154 + * (at your option) any later version.
4155 + *
4156 + * This program is distributed in the hope that it will be useful,
4157 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
4158 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4159 + * GNU General Public License for more details.
4160 + *
4161 + * You should have received a copy of the GNU General Public License
4162 + * along with this program; if not, write to the Free Software
4163 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
4164 + *
4165 + */
4166 +
4167 +#ifndef HD44780_H
4168 +#define HD44780_H
4169 +
4170 +#include <linux/lcd-linux.h>
4171 +
4172 +#define HD44780_VERSION LCD_LINUX_VERSION /* Version number */
4173 +#define HD44780_STRING "hd44780"
4174 +
4175 +#define HD44780_MINOR 0 /* Minor number for the hd44780 driver */
4176 +
4177 +
4178 +/* flags */
4179 +#define HD44780_CHECK_BF 0x00000001 /* Do busy flag checking */
4180 +#define HD44780_4BITS_BUS 0x00000002 /* Set the bus length to 4 bits */
4181 +#define HD44780_5X10_FONT 0x00000004 /* Use 5x10 dots fonts */
4182 +
4183 +/* IOCTLs */
4184 +#define HD44780_READ_AC _IOR(LCD_MAJOR, 0x00, unsigned char *)
4185 +
4186 +#endif /* HD44780 included */
4187 Index: linux-2.6.30.9/include/linux/lcd-linux.h
4188 ===================================================================
4189 --- /dev/null 1970-01-01 00:00:00.000000000 +0000
4190 +++ linux-2.6.30.9/include/linux/lcd-linux.h 2009-11-24 02:01:42.000000000 +0100
4191 @@ -0,0 +1,151 @@
4192 +/* lcd-linux.h
4193 + *
4194 + *
4195 + * Software layer to drive LCD displays under Linux.
4196 + *
4197 + * External interface header file.
4198 + *
4199 + * Copyright (C) 2005 - 2007 Mattia Jona-Lasinio (mjona@users.sourceforge.net)
4200 + *
4201 + * This program is free software; you can redistribute it and/or modify
4202 + * it under the terms of the GNU General Public License as published by
4203 + * the Free Software Foundation; either version 2 of the License, or
4204 + * (at your option) any later version.
4205 + *
4206 + * This program is distributed in the hope that it will be useful,
4207 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
4208 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4209 + * GNU General Public License for more details.
4210 + *
4211 + * You should have received a copy of the GNU General Public License
4212 + * along with this program; if not, write to the Free Software
4213 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
4214 + *
4215 + */
4216 +
4217 +#ifndef LCD_LINUX_H
4218 +#define LCD_LINUX_H
4219 +
4220 +#ifndef LCD_LINUX_MAIN
4221 +#warning
4222 +#warning LCD-Linux is still in development stage and
4223 +#warning aims at speed and optimization. For these
4224 +#warning reasons there is no guarantee of backward
4225 +#warning compatibility between different LCD-Linux
4226 +#warning versions. Be sure to use the lcd-linux.h
4227 +#warning file of the same version as the module.
4228 +#warning "http://lcd-linux.sourceforge.net/"
4229 +#warning
4230 +#endif
4231 +
4232 +#define LCD_LINUX_VERSION "0.13.6" /* Version number */
4233 +#define LCD_LINUX_STRING "lcd"
4234 +
4235 +#define LCD_MAJOR 120 /* Major number for this device
4236 + * Set this to 0 for dynamic allocation
4237 + */
4238 +#define LCD_MINORS 8 /* Minors allocated for LCD-Linux*/
4239 +
4240 +#include <linux/types.h>
4241 +
4242 +#define str(s) #s
4243 +#define string(s) str(s)
4244 +
4245 +struct lcd_parameters {
4246 + const char *name; /* Driver's name */
4247 + unsigned long flags; /* Flags (see documentation) */
4248 + unsigned short minor; /* Minor number of the char device */
4249 + unsigned short tabstop; /* Tab character length */
4250 + unsigned short num_cntr; /* Controllers to drive */
4251 + unsigned short cntr_rows; /* Rows per controller */
4252 + unsigned short cntr_cols; /* Display columns */
4253 + unsigned short vs_rows; /* Virtual screen rows */
4254 + unsigned short vs_cols; /* Virtual screen columns */
4255 + unsigned short cgram_chars; /* Number of user definable characters */
4256 + unsigned short cgram_bytes; /* Number of bytes required to define a
4257 + * user definable character */
4258 + unsigned char cgram_char0; /* Ascii of first user definable character */
4259 +};
4260 +
4261 +/* IOCTLs */
4262 +#include <asm/ioctl.h>
4263 +#define LCDL_SET_PARAM _IOW(LCD_MAJOR, 0x80, struct lcd_parameters *)
4264 +#define LCDL_GET_PARAM _IOR(LCD_MAJOR, 0x81, struct lcd_parameters *)
4265 +#define LCDL_CHARSUBST _IOW(LCD_MAJOR, 0x82, unsigned char *)
4266 +#define LCDL_RAW_MODE _IOW(LCD_MAJOR, 0x83, unsigned int)
4267 +#define LCDL_RESET_CHARMAP _IO(LCD_MAJOR, 0x84)
4268 +#define LCDL_SAVE_CHARMAP _IO(LCD_MAJOR, 0x85)
4269 +#define LCDL_RESTORE_CHARMAP _IO(LCD_MAJOR, 0x86)
4270 +#define LCDL_SWAP_CHARMAP _IO(LCD_MAJOR, 0x87)
4271 +#define LCDL_CLEAR_DISP _IO(LCD_MAJOR, 0x88)
4272 +#define LCDL_SET_CGRAM_CHAR _IOW(LCD_MAJOR, 0x89, unsigned char *)
4273 +#define LCDL_GET_CGRAM_CHAR _IOR(LCD_MAJOR, 0x8a, unsigned char *)
4274 +#define LCDL_SET_CHARMAP _IOW(LCD_MAJOR, 0x8b, unsigned char *)
4275 +#define LCDL_GET_CHARMAP _IOR(LCD_MAJOR, 0x8c, unsigned char *)
4276 +#define LCDL_MEMSET _IOW(LCD_MAJOR, 0x8d, unsigned int *)
4277 +#define LCDL_MEMMOVE _IOW(LCD_MAJOR, 0x8e, unsigned int *)
4278 +
4279 +
4280 +
4281 +#ifdef __KERNEL__ /* The rest is for kernel only */
4282 +
4283 +#include <linux/kernel.h>
4284 +#include <linux/module.h>
4285 +
4286 +
4287 +struct lcd_driver {
4288 + void (*read_char)(unsigned int offset, unsigned short *data);
4289 + void (*read_cgram_char)(unsigned char index, unsigned char *pixmap);
4290 + void (*write_char)(unsigned int offset, unsigned short data);
4291 + void (*write_cgram_char)(unsigned char index, unsigned char *pixmap);
4292 + void (*clear_display)(void);
4293 + void (*address_mode)(int mode);
4294 + int (*validate_driver)(void);
4295 + int (*init_display)(void);
4296 + int (*cleanup_display)(void);
4297 + int (*init_port)(void);
4298 + int (*cleanup_port)(void);
4299 + int (*handle_custom_char)(unsigned int data);
4300 + int (*handle_custom_ioctl)(unsigned int cmd, unsigned long arg, unsigned int arg_in_userspace);
4301 +
4302 + /* The character map to be used */
4303 + unsigned char *charmap;
4304 +
4305 + /* The root where the driver can create its own proc files.
4306 + * Will be filled by the lcd-linux layer.
4307 + */
4308 + struct proc_dir_entry *driver_proc_root;
4309 +
4310 + /* Set this field to 'driver_module_init' or call lcd_driver_setup
4311 + * just before registering the driver with lcd_register_driver.
4312 + */
4313 + struct module *driver_module;
4314 +};
4315 +
4316 +#ifdef MODULE
4317 +#define driver_module_init THIS_MODULE
4318 +#else
4319 +#define driver_module_init NULL
4320 +#endif
4321 +
4322 +/* Always call lcd_driver_setup just before registering the driver
4323 + * with lcd_register_driver.
4324 + */
4325 +static inline void lcd_driver_setup(struct lcd_driver *p)
4326 +{
4327 + p->driver_module = driver_module_init;
4328 +}
4329 +
4330 +/* External interface */
4331 +struct lcd_struct;
4332 +int lcd_register_driver(struct lcd_driver *drv, struct lcd_parameters *par);
4333 +int lcd_unregister_driver(struct lcd_driver *drv, struct lcd_parameters *par);
4334 +int lcd_open(unsigned short minor, struct lcd_struct **lcd);
4335 +int lcd_close(struct lcd_struct **lcd);
4336 +int lcd_ioctl(struct lcd_struct *lcd, unsigned int cmd, ...);
4337 +ssize_t lcd_write(struct lcd_struct *lcd, const void *buffer, size_t length, loff_t offset, unsigned int);
4338 +ssize_t lcd_read(struct lcd_struct *lcd, void *buffer, size_t length, loff_t offset, unsigned int);
4339 +
4340 +#endif /* __KERNEL__ */
4341 +
4342 +#endif /* External interface included */
Personal OpenWRT clone
This page took 0.215466 seconds and 5 git commands to generate.