style: compare return value of getopt() against -1 rather than EOF
[games.git] / share / examples / ppi / ppilcd.c
1 /*
2  * Control LCD module hung off parallel port using the
3  * ppi 'geek port' interface.
4  *
5  * $FreeBSD: src/share/examples/ppi/ppilcd.c,v 1.2.2.1 2003/01/05 19:45:29 semenu Exp $
6  * $DragonFly: src/share/examples/ppi/ppilcd.c,v 1.3 2008/07/10 18:29:51 swildner Exp $
7  */
8
9 #include <stdio.h>
10 #include <stdlib.h>
11 #include <string.h>
12 #include <ctype.h>
13 #include <fcntl.h>
14 #include <unistd.h>
15 #include <err.h>
16 #include <sysexits.h>
17
18 #include <dev/ppbus/ppbconf.h>
19 #include <dev/ppbus/ppi.h>
20
21 #define debug(lev, fmt, args...)        if (debuglevel >= lev) fprintf(stderr, fmt "\n" , ## args);
22
23 static void     usage(void);
24 static char     *progname;
25
26 #define DEFAULT_DEVICE  "/dev/ppi0"
27
28 /* Driver functions */
29 static void     hd44780_prepare(char *devname, char *options);
30 static void     hd44780_finish(void);
31 static void     hd44780_command(int cmd);
32 static void     hd44780_putc(int c);
33
34 /* 
35  * Commands 
36  * Note that unrecognised command escapes are passed through with
37  * the command value set to the ASCII value of the escaped character.
38  */
39 #define CMD_RESET       0
40 #define CMD_BKSP        1
41 #define CMD_CLR         2
42 #define CMD_NL          3
43 #define CMD_CR          4
44 #define CMD_HOME        5
45
46 #define MAX_DRVOPT      10      /* maximum driver-specific options */
47
48 struct lcd_driver
49 {
50     char        *l_code;
51     char        *l_name;
52     char        *l_options[MAX_DRVOPT];
53     void        (* l_prepare)(char *name, char *options);
54     void        (* l_finish)(void);
55     void        (* l_command)(int cmd);
56     void        (* l_putc)(int c);
57 };
58
59 static struct lcd_driver lcd_drivertab[] = {
60     {
61         "hd44780", 
62         "Hitachi HD44780 and compatibles", 
63         {
64             "Reset options:",
65             "    1     1-line display (default 2)",
66             "    B     Cursor blink enable",
67             "    C     Cursor enable",
68             "    F     Large font select",
69             NULL
70         },
71         hd44780_prepare, 
72         hd44780_finish,
73         hd44780_command, 
74         hd44780_putc
75     },
76     {
77         NULL, 
78         NULL, 
79         {
80             NULL
81         }, 
82         NULL, 
83         NULL
84     }
85 };
86
87 static void     do_char(struct lcd_driver *driver, char ch);
88
89 int     debuglevel = 0;
90 int     vflag = 0;
91
92 int
93 main(int argc, char *argv[]) 
94 {
95     extern char         *optarg;
96     extern int          optind;
97     struct lcd_driver   *driver = &lcd_drivertab[0];
98     char                *drivertype, *cp;
99     char                *devname = DEFAULT_DEVICE;
100     char                *drvopts = NULL;
101     int                 ch, i;
102
103     if ((progname = strrchr(argv[0], '/'))) {
104         progname++;
105     } else {
106         progname = argv[0];
107     }
108
109     drivertype = getenv("LCD_TYPE");
110     
111     while ((ch = getopt(argc, argv, "Dd:f:o:v")) != -1) {
112         switch(ch) {
113         case 'D':
114             debuglevel++;
115             break;
116         case 'd':
117             drivertype = optarg;
118             break;
119         case 'f':
120             devname = optarg;
121             break;
122         case 'o':
123             drvopts = optarg;
124             break;
125         case 'v':
126             vflag = 1;
127             break;
128         default:
129             usage();
130         }
131     }
132     argc -= optind;
133     argv += optind;
134     
135     /* If an LCD type was specified, look it up */
136     if (drivertype != NULL) {
137         driver = NULL;
138         for (i = 0; lcd_drivertab[i].l_code != NULL; i++) {
139             if (!strcmp(drivertype, lcd_drivertab[i].l_code)) {
140                 driver = &lcd_drivertab[i];
141                 break;
142             }
143         }
144         if (driver == NULL) {
145             warnx("LCD driver '%s' not known", drivertype);
146             usage();
147         }
148     }
149     debug(1, "Driver selected for %s", driver->l_name);
150     driver->l_prepare(devname, drvopts);
151     atexit(driver->l_finish);
152
153     if (argc > 0) {
154         debug(2, "reading input from %d argument%s", argc, (argc > 1) ? "s" : "");
155         for (i = 0; i < argc; i++)
156             for (cp = argv[i]; *cp; cp++)
157                 do_char(driver, *cp);
158     } else {
159         debug(2, "reading input from stdin");
160         setvbuf(stdin, NULL, _IONBF, 0);
161         while ((ch = fgetc(stdin)) != EOF)
162             do_char(driver, (char)ch);
163     }
164     exit(EX_OK);
165 }
166
167 static void
168 usage(void) 
169 {
170     int         i, j;
171     
172     fprintf(stderr, "usage: %s [-v] [-d drivername] [-f device] [-o options] [args...]\n", progname);
173     fprintf(stderr, "   -D      Increase debugging\n");
174     fprintf(stderr, "   -f      Specify device, default is '%s'\n", DEFAULT_DEVICE);
175     fprintf(stderr, "   -d      Specify driver, one of:\n");
176     for (i = 0; lcd_drivertab[i].l_code != NULL; i++) {
177         fprintf(stderr, "              %-10s (%s)%s\n", 
178                 lcd_drivertab[i].l_code, lcd_drivertab[i].l_name, (i == 0) ? " *default*" : "");
179         if (lcd_drivertab[i].l_options[0] != NULL) {
180             
181             for (j = 0; lcd_drivertab[i].l_options[j] != NULL; j++)
182                 fprintf(stderr, "                  %s\n", lcd_drivertab[i].l_options[j]);
183         }
184     }
185     fprintf(stderr, "  -o       Specify driver option string\n");
186     fprintf(stderr, "  args     Message strings.  Embedded escapes supported:\n");
187     fprintf(stderr, "                  \\b      Backspace\n");
188     fprintf(stderr, "                  \\f      Clear display, home cursor\n");
189     fprintf(stderr, "                  \\n      Newline\n");
190     fprintf(stderr, "                  \\r      Carriage return\n");
191     fprintf(stderr, "                  \\R      Reset display\n");
192     fprintf(stderr, "                  \\v      Home cursor\n");
193     fprintf(stderr, "                  \\\\     Literal \\\n");
194     fprintf(stderr, "           If args not supplied, strings are read from standard input\n");
195     exit(EX_USAGE);
196 }
197
198 static void
199 do_char(struct lcd_driver *driver, char ch)
200 {
201     static int  esc = 0;
202     
203     if (esc) {
204         switch(ch) {
205         case 'b':
206             driver->l_command(CMD_BKSP);
207             break;
208         case 'f':
209             driver->l_command(CMD_CLR);
210             break;
211         case 'n':
212             driver->l_command(CMD_NL);
213             break;
214         case 'r':
215             driver->l_command(CMD_CR);
216             break;
217         case 'R':
218             driver->l_command(CMD_RESET);
219             break;
220         case 'v':
221             driver->l_command(CMD_HOME);
222             break;
223         case '\\':
224             driver->l_putc('\\');
225             break;
226         default:
227             driver->l_command(ch);
228             break;
229         }
230         esc = 0;
231     } else {
232         if (ch == '\\') {
233             esc = 1;
234         } else {
235             if (vflag || isprint(ch))
236                 driver->l_putc(ch);
237         }
238     }
239 }
240
241
242 /******************************************************************************
243  * Driver for the Hitachi HD44780.  This is probably *the* most common driver
244  * to be found on one- and two-line alphanumeric LCDs.
245  *
246  * This driver assumes the following connections :
247  *
248  * Parallel Port        LCD Module
249  * --------------------------------
250  * Strobe (1)           Enable (6)
251  * Data (2-9)           Data (7-14)
252  * Select(13)           RS (4)
253  * Auto Feed (14)       R/W (5)
254  *
255  * In addition, power must be supplied to the module, normally with
256  * a circuit similar to this:
257  *
258  * VCC (+5V) O------o-------o--------O Module pin 2
259  *                  |       | +
260  *                  /      ---
261  *                  \      --- 1uF
262  *                  /       | -
263  *                  \ <-----o--------O Module pin 3
264  *                  /
265  *                  \
266  *                  |
267  * GND       O------o----------------O Module pin 1
268  *
269  * The ground line should also be connected to the parallel port, on
270  * one of the ground pins (eg. pin 25).
271  *
272  * Note that the pinning on some LCD modules has the odd and even pins
273  * arranged as though reversed; check carefully before conecting a module
274  * as it is possible to toast the HD44780 if the power is reversed.
275  */
276
277 static int      hd_fd;
278 static u_int8_t hd_cbits;
279 static int      hd_lines = 2;
280 static int      hd_blink = 0;
281 static int      hd_cursor = 0;
282 static int      hd_font = 0;
283
284 #define HD_COMMAND      SELECTIN
285 #define HD_DATA         0
286 #define HD_READ         0
287 #define HD_WRITE        AUTOFEED
288
289 #define HD_BF           0x80            /* internal busy flag */
290 #define HD_ADDRMASK     0x7f            /* DDRAM address mask */
291
292 #define hd_sctrl(v)     {u_int8_t _val; _val = hd_cbits | v; ioctl(hd_fd, PPISCTRL, &_val);}
293 #define hd_sdata(v)     {u_int8_t _val; _val = v; ioctl(hd_fd, PPISDATA, &_val);}
294 #define hd_gdata(v)     ioctl(hd_fd, PPIGDATA, &v)
295
296 static void
297 hd44780_output(int type, int data)
298 {
299     debug(3, "%s -> 0x%02x", (type == HD_COMMAND) ? "cmd " : "data", data);
300     hd_sctrl(type | HD_WRITE | STROBE); /* set direction, address */
301     hd_sctrl(type | HD_WRITE);          /* raise E */
302     hd_sdata((u_int8_t) data);          /* drive data */
303     hd_sctrl(type | HD_WRITE | STROBE); /* lower E */
304 }
305
306 static int
307 hd44780_input(int type) 
308 {
309     u_int8_t    val;
310
311     hd_sctrl(type | HD_READ | STROBE);  /* set direction, address */ 
312     hd_sctrl(type | HD_READ);           /* raise E */
313     hd_gdata(val);                      /* read data */
314     hd_sctrl(type | HD_READ | STROBE);  /* lower E */
315
316     debug(3, "0x%02x -> %s", val, (type == HD_COMMAND) ? "cmd " : "data");
317     return(val);
318 }
319
320 static void
321 hd44780_prepare(char *devname, char *options) 
322 {
323     char        *cp = options;
324     
325     if ((hd_fd = open(devname, O_RDWR, 0)) == -1)
326         err(EX_OSFILE, "can't open '%s'", devname);
327
328     /* parse options */
329     while (cp && *cp) {
330         switch (*cp++) {
331         case '1':
332             hd_lines = 1;
333             break;
334         case 'B':
335             hd_blink = 1;
336             break;
337         case 'C':
338             hd_cursor = 1;
339             break;
340         case 'F':
341             hd_font = 1;
342             break;
343         default:
344             errx(EX_USAGE, "hd44780: unknown option code '%c'", *(cp-1));
345         }
346     }
347
348     /* Put LCD in idle state */
349     if (ioctl(hd_fd, PPIGCTRL, &hd_cbits))              /* save other control bits */
350         err(EX_IOERR, "ioctl PPIGCTRL failed (not a ppi device?)");
351     hd_cbits &= ~(STROBE | SELECTIN | AUTOFEED);        /* set strobe, RS, R/W low */
352     debug(2, "static control bits 0x%x", hd_cbits);
353     hd_sctrl(STROBE);
354     hd_sdata(0);
355
356 }
357
358 static void
359 hd44780_finish(void) 
360 {
361     close(hd_fd);
362 }
363
364 static void
365 hd44780_command(int cmd) 
366 {
367     u_int8_t    val;
368
369     switch (cmd) {
370     case CMD_RESET:     /* full manual reset and reconfigure as per datasheet */
371         debug(1, "hd44780: reset to %d lines, %s font,%s%s cursor", 
372               hd_lines, hd_font ? "5x10" : "5x7", hd_cursor ? "" : " no", hd_blink ? " blinking" : "");
373         val = 0x30;
374         if (hd_lines == 2)
375             val |= 0x08;
376         if (hd_font)
377             val |= 0x04;
378         hd44780_output(HD_COMMAND, val);
379         usleep(10000);
380         hd44780_output(HD_COMMAND, val);
381         usleep(1000);
382         hd44780_output(HD_COMMAND, val);
383         usleep(1000);
384         val = 0x08;                             /* display off */
385         hd44780_output(HD_COMMAND, val);
386         usleep(1000);
387         val |= 0x04;                            /* display on */
388         if (hd_cursor)
389             val |= 0x02;
390         if (hd_blink)
391             val |= 0x01;
392         hd44780_output(HD_COMMAND, val);
393         usleep(1000);
394         hd44780_output(HD_COMMAND, 0x06);       /* shift cursor by increment */
395         usleep(1000);
396         /* FALLTHROUGH */
397
398     case CMD_CLR:
399         hd44780_output(HD_COMMAND, 0x01);
400         usleep(2000);
401         break;
402
403     case CMD_BKSP:
404         hd44780_output(HD_DATA, 0x10);          /* shift cursor left one */
405         break;
406         
407     case CMD_NL:
408         if (hd_lines == 2)
409             hd44780_output(HD_COMMAND, 0xc0);   /* beginning of second line */
410         break;
411         
412     case CMD_CR:
413         /* XXX will not work in 4-line mode, or where readback fails */
414         val = hd44780_input(HD_COMMAND) & 0x3f; /* mask character position, save line pos */
415         hd44780_output(HD_COMMAND, 0x80 | val);
416         break;
417         
418     case CMD_HOME:
419         hd44780_output(HD_COMMAND, 0x02);
420         usleep(2000);
421         break;
422         
423     default:
424         if (isprint(cmd)) {
425             warnx("unknown command %c", cmd);
426         } else {
427             warnx("unknown command 0x%x", cmd);
428         }
429     }
430     usleep(40);
431 }
432
433 static void
434 hd44780_putc(int c)
435 {
436     hd44780_output(HD_DATA, c);
437     usleep(40);
438 }
439