1 /* $NetBSD: hd44780_subr.c,v 1.24 2023/08/08 17:31:13 nat Exp $ */
2
3 /*
4 * Copyright (c) 2002 Dennis I. Chernoivanov
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 /*
31 * Subroutines for Hitachi HD44870 style displays
32 */
33
34 #include <sys/cdefs.h>
35 __KERNEL_RCSID(0, "$NetBSD: hd44780_subr.c,v 1.24 2023/08/08 17:31:13 nat Exp $");
36
37 #include <sys/param.h>
38 #include <sys/systm.h>
39 #include <sys/conf.h>
40 #include <sys/kernel.h>
41 #include <sys/malloc.h>
42 #include <sys/types.h>
43 #include <sys/ioccom.h>
44
45 #include <machine/autoconf.h>
46 #include <sys/intr.h>
47 #include <sys/bus.h>
48
49 #include <dev/wscons/wsdisplayvar.h>
50 #include <dev/wscons/wsconsio.h>
51 #include <dev/wscons/wscons_callbacks.h>
52
53 #include <dev/ic/hd44780reg.h>
54 #include <dev/ic/hd44780var.h>
55
56 #define COORD_TO_IDX(x, y) ((y) * sc->sc_cols + (x))
57 #define COORD_TO_DADDR(x, y) ((y) * HD_ROW2_ADDR + (x))
58 #define IDX_TO_ROW(idx) ((idx) / sc->sc_cols)
59 #define IDX_TO_COL(idx) ((idx) % sc->sc_cols)
60 #define IDX_TO_DADDR(idx) (IDX_TO_ROW((idx)) * HD_ROW2_ADDR + \
61 IDX_TO_COL((idx)))
62 #define DADDR_TO_ROW(daddr) ((daddr) / HD_ROW2_ADDR)
63 #define DADDR_TO_COL(daddr) ((daddr) % HD_ROW2_ADDR)
64 #define DADDR_TO_CHIPDADDR(daddr) ((daddr) % (HD_ROW2_ADDR * 2))
65 #define DADDR_TO_CHIPNO(daddr) ((daddr) / (HD_ROW2_ADDR * 2))
66
67 static void hlcd_cursor(void *, int, int, int);
68 static int hlcd_mapchar(void *, int, unsigned int *);
69 static void hlcd_putchar(void *, int, int, u_int, long);
70 static void hlcd_copycols(void *, int, int, int,int);
71 static void hlcd_erasecols(void *, int, int, int, long);
72 static void hlcd_copyrows(void *, int, int, int);
73 static void hlcd_eraserows(void *, int, int, long);
74 static int hlcd_allocattr(void *, int, int, int, long *);
75 static void hlcd_updatechar(struct hd44780_chip *, int, int);
76 static void hlcd_redraw(void *);
77
78 const struct wsdisplay_emulops hlcd_emulops = {
79 hlcd_cursor,
80 hlcd_mapchar,
81 hlcd_putchar,
82 hlcd_copycols,
83 hlcd_erasecols,
84 hlcd_copyrows,
85 hlcd_eraserows,
86 hlcd_allocattr
87 };
88
89 static int hlcd_ioctl(void *, void *, u_long, void *, int, struct lwp *);
90 static paddr_t hlcd_mmap(void *, void *, off_t, int);
91 static int hlcd_alloc_screen(void *, const struct wsscreen_descr *,
92 void **, int *, int *, long *);
93 static void hlcd_free_screen(void *, void *);
94 static int hlcd_show_screen(void *, void *, int,
95 void (*) (void *, int, int), void *);
96
97 const struct wsdisplay_accessops hlcd_accessops = {
98 hlcd_ioctl,
99 hlcd_mmap,
100 hlcd_alloc_screen,
101 hlcd_free_screen,
102 hlcd_show_screen,
103 0 /* load_font */
104 };
105
106 static void
hlcd_cursor(void * id,int on,int row,int col)107 hlcd_cursor(void *id, int on, int row, int col)
108 {
109 struct hlcd_screen *hdscr = id;
110
111 hdscr->hlcd_curon = on;
112 hdscr->hlcd_curx = col;
113 hdscr->hlcd_cury = row;
114 }
115
116 static int
hlcd_mapchar(void * id,int uni,unsigned int * index)117 hlcd_mapchar(void *id, int uni, unsigned int *index)
118 {
119
120 if (uni < 256) {
121 *index = uni;
122 return 5;
123 }
124 *index = ' ';
125 return 0;
126 }
127
128 static void
hlcd_putchar(void * id,int row,int col,u_int c,long attr)129 hlcd_putchar(void *id, int row, int col, u_int c, long attr)
130 {
131 struct hlcd_screen *hdscr = id;
132
133 c &= 0xff;
134 if (row > 0 && (hdscr->hlcd_sc->sc_flags & (HD_MULTILINE|HD_MULTICHIP)))
135 hdscr->image[hdscr->hlcd_sc->sc_cols * row + col] = c;
136 else
137 hdscr->image[col] = c;
138 }
139
140 /*
141 * copies columns inside a row.
142 */
143 static void
hlcd_copycols(void * id,int row,int srccol,int dstcol,int ncols)144 hlcd_copycols(void *id, int row, int srccol, int dstcol, int ncols)
145 {
146 struct hlcd_screen *hdscr = id;
147
148 if ((dstcol + ncols - 1) > hdscr->hlcd_sc->sc_cols)
149 ncols = hdscr->hlcd_sc->sc_cols - srccol;
150
151 if (row > 0 && (hdscr->hlcd_sc->sc_flags & (HD_MULTILINE|HD_MULTICHIP)))
152 memmove(&hdscr->image[hdscr->hlcd_sc->sc_cols * row + dstcol],
153 &hdscr->image[hdscr->hlcd_sc->sc_cols * row + srccol],
154 ncols);
155 else
156 memmove(&hdscr->image[dstcol], &hdscr->image[srccol], ncols);
157 }
158
159
160 /*
161 * Erases a bunch of chars inside one row.
162 */
163 static void
hlcd_erasecols(void * id,int row,int startcol,int ncols,long fillattr)164 hlcd_erasecols(void *id, int row, int startcol, int ncols, long fillattr)
165 {
166 struct hlcd_screen *hdscr = id;
167
168 if ((startcol + ncols) > hdscr->hlcd_sc->sc_cols)
169 ncols = hdscr->hlcd_sc->sc_cols - startcol;
170
171 if (row > 0 && (hdscr->hlcd_sc->sc_flags & (HD_MULTILINE|HD_MULTICHIP)))
172 memset(&hdscr->image[hdscr->hlcd_sc->sc_cols * row + startcol],
173 ' ', ncols);
174 else
175 memset(&hdscr->image[startcol], ' ', ncols);
176 }
177
178
179 static void
hlcd_copyrows(void * id,int srcrow,int dstrow,int nrows)180 hlcd_copyrows(void *id, int srcrow, int dstrow, int nrows)
181 {
182 struct hlcd_screen *hdscr = id;
183 int ncols = hdscr->hlcd_sc->sc_cols;
184
185 if (!(hdscr->hlcd_sc->sc_flags & (HD_MULTILINE|HD_MULTICHIP)))
186 return;
187 memmove(&hdscr->image[dstrow * ncols], &hdscr->image[srcrow * ncols],
188 nrows * ncols);
189 }
190
191 static void
hlcd_eraserows(void * id,int startrow,int nrows,long fillattr)192 hlcd_eraserows(void *id, int startrow, int nrows, long fillattr)
193 {
194 struct hlcd_screen *hdscr = id;
195 int ncols = hdscr->hlcd_sc->sc_cols;
196
197 memset(&hdscr->image[startrow * ncols], ' ', ncols * nrows);
198 }
199
200
201 static int
hlcd_allocattr(void * id,int fg,int bg,int flags,long * attrp)202 hlcd_allocattr(void *id, int fg, int bg, int flags, long *attrp)
203 {
204
205 *attrp = flags;
206 return 0;
207 }
208
209 static int
hlcd_ioctl(void * v,void * vs,u_long cmd,void * data,int flag,struct lwp * l)210 hlcd_ioctl(void *v, void *vs, u_long cmd, void *data, int flag, struct lwp *l)
211 {
212
213 switch (cmd) {
214 case WSDISPLAYIO_GTYPE:
215 *(u_int *)data = WSDISPLAY_TYPE_HDLCD;
216 break;
217
218 case WSDISPLAYIO_SVIDEO:
219 break;
220
221 case WSDISPLAYIO_GVIDEO:
222 *(u_int *)data = WSDISPLAYIO_VIDEO_ON;
223 break;
224
225 default:
226 return EPASSTHROUGH;
227 }
228 return 0;
229 }
230
231 static paddr_t
hlcd_mmap(void * v,void * vs,off_t offset,int prot)232 hlcd_mmap(void *v, void *vs, off_t offset, int prot)
233 {
234
235 return -1;
236 }
237
238 static int
hlcd_alloc_screen(void * v,const struct wsscreen_descr * type,void ** cookiep,int * curxp,int * curyp,long * defattrp)239 hlcd_alloc_screen(void *v, const struct wsscreen_descr *type, void **cookiep,
240 int *curxp, int *curyp, long *defattrp)
241 {
242 struct hlcd_screen *hdscr = v, *new;
243
244 new = *cookiep = malloc(sizeof(struct hlcd_screen),
245 M_DEVBUF, M_WAITOK|M_ZERO);
246 new->hlcd_sc = hdscr->hlcd_sc;
247 new->image = malloc(PAGE_SIZE, M_DEVBUF, M_WAITOK);
248 memset(new->image, ' ', PAGE_SIZE);
249 *curxp = *curyp = *defattrp = 0;
250 return 0;
251 }
252
253 static void
hlcd_free_screen(void * v,void * cookie)254 hlcd_free_screen(void *v, void *cookie)
255 {
256 }
257
258 static int
hlcd_show_screen(void * v,void * cookie,int waitok,void (* cb)(void *,int,int),void * cbarg)259 hlcd_show_screen(void *v, void *cookie, int waitok,
260 void (*cb)(void *, int, int), void *cbarg)
261 {
262 struct hlcd_screen *hdscr = v;
263
264 hdscr->hlcd_sc->sc_curscr = cookie;
265 callout_schedule(&hdscr->hlcd_sc->redraw, 1);
266 return 0;
267 }
268
269 static void
hlcd_updatechar(struct hd44780_chip * sc,int daddr,int c)270 hlcd_updatechar(struct hd44780_chip *sc, int daddr, int c)
271 {
272 int curdaddr, en, chipdaddr;
273
274 curdaddr = COORD_TO_DADDR(sc->sc_screen.hlcd_curx,
275 sc->sc_screen.hlcd_cury);
276 en = DADDR_TO_CHIPNO(daddr);
277 chipdaddr = DADDR_TO_CHIPDADDR(daddr);
278 if (daddr != curdaddr)
279 hd44780_ir_write(sc, en, cmd_ddramset(chipdaddr));
280
281 hd44780_dr_write(sc, en, c);
282
283 daddr++;
284 sc->sc_screen.hlcd_curx = DADDR_TO_COL(daddr);
285 sc->sc_screen.hlcd_cury = DADDR_TO_ROW(daddr);
286 }
287
288 static void
hlcd_redraw(void * arg)289 hlcd_redraw(void *arg)
290 {
291 struct hd44780_chip *sc = arg;
292 int len, crsridx, startidx, x, y;
293 int old_en, new_en;
294 uint8_t *img, *curimg;
295
296 if (sc->sc_curscr == NULL)
297 return;
298
299 if (sc->sc_flags & HD_MULTILINE)
300 len = 2 * sc->sc_cols;
301 else
302 len = sc->sc_cols;
303
304 if (sc->sc_flags & HD_MULTICHIP)
305 len = len * 2;
306
307 x = sc->sc_screen.hlcd_curx;
308 y = sc->sc_screen.hlcd_cury;
309 old_en = DADDR_TO_CHIPNO(COORD_TO_DADDR(x, y));
310
311 img = sc->sc_screen.image;
312 curimg = sc->sc_curscr->image;
313 startidx = crsridx =
314 COORD_TO_IDX(sc->sc_screen.hlcd_curx, sc->sc_screen.hlcd_cury);
315 do {
316 if (img[crsridx] != curimg[crsridx]) {
317 hlcd_updatechar(sc, IDX_TO_DADDR(crsridx),
318 curimg[crsridx]);
319 img[crsridx] = curimg[crsridx];
320 }
321 crsridx++;
322 if (crsridx == len)
323 crsridx = 0;
324 } while (crsridx != startidx);
325
326 x = sc->sc_curscr->hlcd_curx;
327 y = sc->sc_curscr->hlcd_cury;
328 new_en = DADDR_TO_CHIPNO(COORD_TO_DADDR(x, y));
329
330 if (sc->sc_screen.hlcd_curx != sc->sc_curscr->hlcd_curx ||
331 sc->sc_screen.hlcd_cury != sc->sc_curscr->hlcd_cury) {
332
333 x = sc->sc_screen.hlcd_curx = sc->sc_curscr->hlcd_curx;
334 y = sc->sc_screen.hlcd_cury = sc->sc_curscr->hlcd_cury;
335
336 hd44780_ir_write(sc, new_en, cmd_ddramset(
337 DADDR_TO_CHIPDADDR(COORD_TO_DADDR(x, y))));
338
339 }
340
341 /* visible cursor switched to other chip */
342 if (old_en != new_en && sc->sc_screen.hlcd_curon) {
343 hd44780_ir_write(sc, old_en, cmd_dispctl(1, 0, 0));
344 hd44780_ir_write(sc, new_en, cmd_dispctl(1, 1, 1));
345 }
346
347 if (sc->sc_screen.hlcd_curon != sc->sc_curscr->hlcd_curon) {
348 sc->sc_screen.hlcd_curon = sc->sc_curscr->hlcd_curon;
349 if (sc->sc_screen.hlcd_curon)
350 hd44780_ir_write(sc, new_en, cmd_dispctl(1, 1, 1));
351 else
352 hd44780_ir_write(sc, new_en, cmd_dispctl(1, 0, 0));
353 }
354
355 callout_schedule(&sc->redraw, 1);
356 }
357
358
359 /*
360 * Finish device attach. sc_writereg, sc_readreg and sc_flags must be properly
361 * initialized prior to this call.
362 */
363 void
hd44780_attach_subr(struct hd44780_chip * sc)364 hd44780_attach_subr(struct hd44780_chip *sc)
365 {
366 int err = 0;
367
368 /* Putc/getc are supposed to be set by platform-dependent code. */
369 if ((sc->sc_writereg == NULL) || (sc->sc_readreg == NULL))
370 sc->sc_dev_ok = 0;
371
372 /* Make sure that HD_MAX_CHARS is enough. */
373 if ((sc->sc_flags & HD_MULTILINE) && (2 * sc->sc_cols > HD_MAX_CHARS))
374 sc->sc_dev_ok = 0;
375 else if (sc->sc_cols > HD_MAX_CHARS)
376 sc->sc_dev_ok = 0;
377
378 if (sc->sc_dev_ok) {
379 if ((sc->sc_flags & HD_UP) == 0)
380 err = hd44780_init(sc);
381 if (err != 0)
382 aprint_error_dev(sc->sc_dev,
383 "LCD not responding or unconnected\n");
384 }
385
386 sc->sc_screen.hlcd_sc = sc;
387
388 sc->sc_screen.image = malloc(PAGE_SIZE, M_DEVBUF, M_WAITOK);
389 memset(sc->sc_screen.image, ' ', PAGE_SIZE);
390 sc->sc_curscr = NULL;
391 sc->sc_curchip = 0;
392 callout_init(&sc->redraw, 0);
393 callout_setfunc(&sc->redraw, hlcd_redraw, sc);
394 }
395
hd44780_detach(struct hd44780_chip * sc)396 void hd44780_detach(struct hd44780_chip *sc)
397 {
398 callout_stop(&sc->redraw);
399 callout_destroy(&sc->redraw);
400
401 if (sc->sc_screen.image)
402 free(sc->sc_screen.image, M_DEVBUF);
403 }
404
hd44780_init(struct hd44780_chip * sc)405 int hd44780_init(struct hd44780_chip *sc)
406 {
407 int ret;
408
409 ret = hd44780_chipinit(sc, 0);
410 if (ret != 0 || !(sc->sc_flags & HD_MULTICHIP))
411 return ret;
412 else
413 return hd44780_chipinit(sc, 1);
414 }
415
416 /*
417 * Initialize 4-bit or 8-bit connected device.
418 */
419 int
hd44780_chipinit(struct hd44780_chip * sc,uint32_t en)420 hd44780_chipinit(struct hd44780_chip *sc, uint32_t en)
421 {
422 uint8_t cmd, dat;
423
424 sc->sc_flags &= ~(HD_TIMEDOUT|HD_UP);
425 sc->sc_dev_ok = 1;
426
427 cmd = cmd_init(sc->sc_flags & HD_8BIT);
428 hd44780_ir_write(sc, en, cmd);
429 delay(HD_TIMEOUT_LONG);
430 hd44780_ir_write(sc, en, cmd);
431 hd44780_ir_write(sc, en, cmd);
432
433 cmd = cmd_funcset(
434 sc->sc_flags & HD_8BIT,
435 sc->sc_flags & HD_MULTILINE,
436 sc->sc_flags & HD_BIGFONT);
437
438 if ((sc->sc_flags & HD_8BIT) == 0)
439 hd44780_ir_write(sc, en, cmd);
440
441 sc->sc_flags |= HD_UP;
442
443 hd44780_ir_write(sc, en, cmd);
444 hd44780_ir_write(sc, en, cmd_dispctl(0, 0, 0));
445 hd44780_ir_write(sc, en, cmd_clear());
446 hd44780_ir_write(sc, en, cmd_modset(1, 0));
447
448 if (sc->sc_flags & HD_TIMEDOUT) {
449 sc->sc_flags &= ~HD_UP;
450 return EIO;
451 }
452
453 /* Turn display on and clear it. */
454 hd44780_ir_write(sc, en, cmd_clear());
455 hd44780_ir_write(sc, en, cmd_dispctl(1, 0, 0));
456
457 /* Attempt a simple probe for presence */
458 hd44780_ir_write(sc, en, cmd_ddramset(0x5));
459 hd44780_ir_write(sc, en, cmd_shift(0, 1));
460 hd44780_busy_wait(sc, en);
461 if (!(sc->sc_flags & HD_WRITEONLY) &&
462 (dat = hd44780_ir_read(sc, en) & 0x7f) != 0x6) {
463 sc->sc_dev_ok = 0;
464 sc->sc_flags &= ~HD_UP;
465 return EIO;
466 }
467 hd44780_ir_write(sc, en, cmd_ddramset(0));
468
469 return 0;
470 }
471
472 /*
473 * Standard hd44780 ioctl() functions.
474 */
475 int
hd44780_ioctl_subr(struct hd44780_chip * sc,u_long cmd,void * data)476 hd44780_ioctl_subr(struct hd44780_chip *sc, u_long cmd, void *data)
477 {
478 uint8_t tmp;
479 int error = 0;
480 uint32_t en = sc->sc_curchip;
481
482 #define hd44780_io() ((struct hd44780_io *)data)
483 #define hd44780_info() ((struct hd44780_info *)data)
484 #define hd44780_ctrl() ((struct hd44780_dispctl *)data)
485
486 switch (cmd) {
487 case HLCD_CLEAR:
488 /* Clear the LCD. */
489 hd44780_ir_write(sc, en, cmd_clear());
490 break;
491
492 case HLCD_CURSOR_LEFT:
493 /* Move the cursor one position to the left. */
494 hd44780_ir_write(sc, en, cmd_shift(0, 0));
495 break;
496
497 case HLCD_CURSOR_RIGHT:
498 /* Move the cursor one position to the right. */
499 hd44780_ir_write(sc, en, cmd_shift(0, 1));
500 break;
501
502 case HLCD_DISPCTL:
503 /* Control the LCD. */
504 hd44780_ir_write(sc, en, cmd_dispctl(
505 hd44780_ctrl()->display_on,
506 hd44780_ctrl()->cursor_on,
507 hd44780_ctrl()->blink_on));
508 break;
509
510 case HLCD_GET_INFO:
511 /* Get LCD configuration. */
512 hd44780_info()->lines
513 = (sc->sc_flags & HD_MULTILINE) ? 2 : 1;
514 if (sc->sc_flags & HD_MULTICHIP)
515 hd44780_info()->lines *= 2;
516 hd44780_info()->phys_rows = sc->sc_cols;
517 hd44780_info()->virt_rows = sc->sc_vcols;
518 hd44780_info()->is_wide = sc->sc_flags & HD_8BIT;
519 hd44780_info()->is_bigfont = sc->sc_flags & HD_BIGFONT;
520 hd44780_info()->kp_present = sc->sc_flags & HD_KEYPAD;
521 break;
522
523
524 case HLCD_RESET:
525 /* Reset the LCD. */
526 error = hd44780_init(sc);
527 break;
528
529 case HLCD_GET_CURSOR_POS:
530 /* Get the current cursor position. */
531 hd44780_io()->dat = (hd44780_ir_read(sc, en) & 0x7f);
532 break;
533
534 case HLCD_SET_CURSOR_POS:
535 /* Set the cursor position. */
536 hd44780_ir_write(sc, en, cmd_ddramset(hd44780_io()->dat));
537 break;
538
539 case HLCD_GETC:
540 /* Get the value at the current cursor position. */
541 tmp = (hd44780_ir_read(sc, en) & 0x7f);
542 hd44780_ir_write(sc, en, cmd_ddramset(tmp));
543 hd44780_io()->dat = hd44780_dr_read(sc, en);
544 break;
545
546 case HLCD_PUTC:
547 /* Set the character at the cursor position + advance cursor. */
548 hd44780_dr_write(sc, en, hd44780_io()->dat);
549 break;
550
551 case HLCD_SHIFT_LEFT:
552 /* Shift display left. */
553 hd44780_ir_write(sc, en, cmd_shift(1, 0));
554 break;
555
556 case HLCD_SHIFT_RIGHT:
557 /* Shift display right. */
558 hd44780_ir_write(sc, en, cmd_shift(1, 1));
559 break;
560
561 case HLCD_HOME:
562 /* Return home. */
563 hd44780_ir_write(sc, en, cmd_rethome());
564 break;
565
566 case HLCD_WRITE:
567 /* Write a string to the LCD virtual area. */
568 error = hd44780_ddram_io(sc, en, hd44780_io(), HD_DDRAM_WRITE);
569 break;
570
571 case HLCD_READ:
572 /* Read LCD virtual area. */
573 error = hd44780_ddram_io(sc, en, hd44780_io(), HD_DDRAM_READ);
574 break;
575
576 case HLCD_REDRAW:
577 /* Write to the LCD visible area. */
578 hd44780_ddram_redraw(sc, en, hd44780_io());
579 break;
580
581 case HLCD_WRITE_INST:
582 /* Write raw instruction. */
583 hd44780_ir_write(sc, en, hd44780_io()->dat);
584 break;
585
586 case HLCD_WRITE_DATA:
587 /* Write raw data. */
588 hd44780_dr_write(sc, en, hd44780_io()->dat);
589 break;
590
591 case HLCD_GET_CHIPNO:
592 /* Get current chip 0 or 1 (top or bottom) */
593 *(uint8_t *)data = sc->sc_curchip;
594 break;
595
596 case HLCD_SET_CHIPNO:
597 /* Set current chip 0 or 1 (top or bottom) */
598 sc->sc_curchip = *(uint8_t *)data;
599 break;
600
601 default:
602 error = EINVAL;
603 }
604
605 if (sc->sc_flags & HD_TIMEDOUT)
606 error = EIO;
607
608 return error;
609 }
610
611 /*
612 * Read/write particular area of the LCD screen.
613 */
614 int
hd44780_ddram_io(struct hd44780_chip * sc,uint32_t en,struct hd44780_io * io,uint8_t dir)615 hd44780_ddram_io(struct hd44780_chip *sc, uint32_t en, struct hd44780_io *io,
616 uint8_t dir)
617 {
618 uint8_t hi;
619 uint8_t addr;
620 int error = 0;
621 uint8_t i = 0;
622
623 if (io->dat < sc->sc_vcols) {
624 hi = HD_ROW1_ADDR + sc->sc_vcols;
625 addr = HD_ROW1_ADDR + io->dat;
626 for (; (addr < hi) && (i < io->len); addr++, i++) {
627 hd44780_ir_write(sc, en, cmd_ddramset(addr));
628 if (dir == HD_DDRAM_READ)
629 io->buf[i] = hd44780_dr_read(sc, en);
630 else
631 hd44780_dr_write(sc, en, io->buf[i]);
632 }
633 }
634 if (io->dat < 2 * sc->sc_vcols) {
635 hi = HD_ROW2_ADDR + sc->sc_vcols;
636 if (io->dat >= sc->sc_vcols)
637 addr = HD_ROW2_ADDR + io->dat - sc->sc_vcols;
638 else
639 addr = HD_ROW2_ADDR;
640 for (; (addr < hi) && (i < io->len); addr++, i++) {
641 hd44780_ir_write(sc, en, cmd_ddramset(addr));
642 if (dir == HD_DDRAM_READ)
643 io->buf[i] = hd44780_dr_read(sc, en);
644 else
645 hd44780_dr_write(sc, en, io->buf[i]);
646 }
647 if (i < io->len)
648 io->len = i;
649 } else {
650 error = EINVAL;
651 }
652 return error;
653 }
654
655 /*
656 * Write to the visible area of the display.
657 */
658 void
hd44780_ddram_redraw(struct hd44780_chip * sc,uint32_t en,struct hd44780_io * io)659 hd44780_ddram_redraw(struct hd44780_chip *sc, uint32_t en,
660 struct hd44780_io *io)
661 {
662 uint8_t i;
663
664 hd44780_ir_write(sc, en, cmd_clear());
665 hd44780_ir_write(sc, en, cmd_rethome());
666 hd44780_ir_write(sc, en, cmd_ddramset(HD_ROW1_ADDR));
667 for (i = 0; (i < io->len) && (i < sc->sc_cols); i++) {
668 hd44780_dr_write(sc, en, io->buf[i]);
669 }
670 hd44780_ir_write(sc, en, cmd_ddramset(HD_ROW2_ADDR));
671 for (; (i < io->len); i++)
672 hd44780_dr_write(sc, en, io->buf[i]);
673 }
674
675 void
hd44780_busy_wait(struct hd44780_chip * sc,uint32_t en)676 hd44780_busy_wait(struct hd44780_chip *sc, uint32_t en)
677 {
678 int nloops = 100;
679
680 if (sc->sc_flags & HD_TIMEDOUT)
681 return;
682
683 while (nloops-- && (hd44780_ir_read(sc, en) & BUSY_FLAG) == BUSY_FLAG)
684 continue;
685
686 if (nloops == 0) {
687 sc->sc_flags |= HD_TIMEDOUT;
688 sc->sc_dev_ok = 0;
689 }
690 }
691
692 #if defined(HD44780_STD_WIDE)
693 /*
694 * Standard 8-bit version of 'sc_writereg' (8-bit port, 8-bit access)
695 */
696 void
hd44780_writereg(struct hd44780_chip * sc,uint32_t en,uint32_t reg,uint8_t cmd)697 hd44780_writereg(struct hd44780_chip *sc, uint32_t en, uint32_t reg,
698 uint8_t cmd)
699 {
700 bus_space_tag_t iot = sc->sc_iot;
701 bus_space_handle_t ioh;
702
703 if (sc->sc_dev_ok == 0)
704 return;
705
706 if (reg == 0)
707 ioh = sc->sc_ioir;
708 else
709 ioh = sc->sc_iodr;
710
711 bus_space_write_1(iot, ioh, 0x00, cmd);
712 delay(HD_TIMEOUT_NORMAL);
713 }
714
715 /*
716 * Standard 8-bit version of 'sc_readreg' (8-bit port, 8-bit access)
717 */
718 uint8_t
hd44780_readreg(struct hd44780_chip * sc,uint32_t en,uint32_t reg)719 hd44780_readreg(struct hd44780_chip *sc, uint32_t en, uint32_t reg)
720 {
721 bus_space_tag_t iot = sc->sc_iot;
722 bus_space_handle_t ioh;
723
724 if (sc->sc_dev_ok == 0)
725 return;
726
727 if (reg == 0)
728 ioh = sc->sc_ioir;
729 else
730 ioh = sc->sc_iodr;
731
732 delay(HD_TIMEOUT_NORMAL);
733 return bus_space_read_1(iot, ioh, 0x00);
734 }
735 #elif defined(HD44780_STD_SHORT)
736 /*
737 * Standard 4-bit version of 'sc_writereg' (4-bit port, 8-bit access)
738 */
739 void
hd44780_writereg(struct hd44780_chip * sc,uint32_t en,uint32_t reg,uint8_t cmd)740 hd44780_writereg(struct hd44780_chip *sc, uint32_t en, uint32_t reg,
741 uint8_t cmd)
742 {
743 bus_space_tag_t iot = sc->sc_iot;
744 bus_space_handle_t ioh;
745
746 if (sc->sc_dev_ok == 0)
747 return;
748
749 if (reg == 0)
750 ioh = sc->sc_ioir;
751 else
752 ioh = sc->sc_iodr;
753
754 bus_space_write_1(iot, ioh, 0x00, hi_bits(cmd));
755 if (sc->sc_flags & HD_UP)
756 bus_space_write_1(iot, ioh, 0x00, lo_bits(cmd));
757 delay(HD_TIMEOUT_NORMAL);
758 }
759
760 /*
761 * Standard 4-bit version of 'sc_readreg' (4-bit port, 8-bit access)
762 */
763 uint8_t
hd44780_readreg(struct hd44780_chip * sc,uint32_t en,uint32_t reg)764 hd44780_readreg(struct hd44780_chip *sc, uint32_t en, uint32_t reg)
765 {
766 bus_space_tag_t iot = sc->sc_iot;
767 bus_space_handle_t ioh;
768 uint8_t rd, dat;
769
770 if (sc->sc_dev_ok == 0)
771 return;
772
773 if (reg == 0)
774 ioh = sc->sc_ioir;
775 else
776 ioh = sc->sc_iodr;
777
778 rd = bus_space_read_1(iot, ioh, 0x00);
779 dat = (rd & 0x0f) << 4;
780 rd = bus_space_read_1(iot, ioh, 0x00);
781 return (dat | (rd & 0x0f));
782 }
783 #endif
784