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 440