Return to lcd.c CVS log

Up to [local] / sys / arch / hppa / dev

Annotation of sys/arch/hppa/dev/lcd.c, Revision 1.1.1.1

1.1       nbrk        1: /*     $OpenBSD: lcd.c,v 1.2 2007/07/20 22:13:45 kettenis Exp $        */
                      2:
                      3: /*
                      4:  * Copyright (c) 2007 Mark Kettenis
                      5:  *
                      6:  * Permission to use, copy, modify, and distribute this software for any
                      7:  * purpose with or without fee is hereby granted, provided that the above
                      8:  * copyright notice and this permission notice appear in all copies.
                      9:  *
                     10:  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
                     11:  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
                     12:  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
                     13:  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
                     14:  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
                     15:  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
                     16:  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
                     17:  */
                     18:
                     19: #include <sys/param.h>
                     20: #include <sys/device.h>
                     21: #include <sys/kernel.h>
                     22: #include <sys/systm.h>
                     23: #include <sys/timeout.h>
                     24:
                     25: #include <machine/autoconf.h>
                     26: #include <machine/bus.h>
                     27: #include <machine/cpu.h>
                     28: #include <machine/pdc.h>
                     29:
                     30: #define LCD_CLS                0x01
                     31: #define LCD_HOME       0x02
                     32: #define LCD_LOCATE(X, Y)       (((Y) & 1 ? 0xc0 : 0x80) | ((X) & 0x0f))
                     33:
                     34: struct lcd_softc {
                     35:        struct device           sc_dv;
                     36:
                     37:        bus_space_tag_t         sc_iot;
                     38:        bus_space_handle_t      sc_cmdh, sc_datah;
                     39:
                     40:        u_int                   sc_delay;
                     41:        u_int8_t                sc_heartbeat[3];
                     42:
                     43:        struct timeout          sc_to;
                     44:        int                     sc_on;
                     45:        struct blink_led        sc_blink;
                     46: };
                     47:
                     48: int    lcd_match(struct device *, void *, void *);
                     49: void   lcd_attach(struct device *, struct device *, void *);
                     50:
                     51: struct cfattach lcd_ca = {
                     52:        sizeof(struct lcd_softc), lcd_match, lcd_attach
                     53: };
                     54:
                     55: struct cfdriver lcd_cd = {
                     56:        NULL, "lcd", DV_DULL
                     57: };
                     58:
                     59: void   lcd_write(struct lcd_softc *, const char *);
                     60: void   lcd_blink(void *, int);
                     61: void   lcd_blink_finish(void *);
                     62:
                     63: int
                     64: lcd_match(struct device *parent, void *match, void *aux)
                     65: {
                     66:        struct confargs *ca = aux;
                     67:
                     68:        if (strcmp(ca->ca_name, "lcd") == 0)
                     69:                return (1);
                     70:
                     71:        return (0);
                     72: }
                     73:
                     74: void
                     75: lcd_attach(struct device *parent, struct device *self, void *aux)
                     76: {
                     77:        struct lcd_softc *sc = (struct lcd_softc *)self;
                     78:        struct confargs *ca = aux;
                     79:        struct pdc_chassis_lcd *pdc_lcd = (void *)ca->ca_pdc_iodc_read;
                     80:        int i;
                     81:
                     82:        sc->sc_iot = ca->ca_iot;
                     83:        if (bus_space_map(sc->sc_iot, pdc_lcd->cmd_addr,
                     84:                1, 0, &sc->sc_cmdh)) {
                     85:                printf(": cannot map cmd register\n");
                     86:                return;
                     87:        }
                     88:
                     89:        if (bus_space_map(sc->sc_iot, pdc_lcd->data_addr,
                     90:                1, 0, &sc->sc_datah)) {
                     91:                printf(": cannot map data register\n");
                     92:                bus_space_unmap(sc->sc_iot, sc->sc_cmdh, 1);
                     93:                return;
                     94:        }
                     95:
                     96:        printf(": model %d\n", pdc_lcd->model);
                     97:
                     98:        sc->sc_delay = pdc_lcd->delay;
                     99:        for (i = 0; i < 3; i++)
                    100:                sc->sc_heartbeat[i] = pdc_lcd->heartbeat[i];
                    101:
                    102:        bus_space_write_1(sc->sc_iot, sc->sc_cmdh, 0, LCD_CLS);
                    103:        delay(100 * sc->sc_delay);
                    104:
                    105:        bus_space_write_1(sc->sc_iot, sc->sc_cmdh, 0, LCD_LOCATE(0, 0));
                    106:        delay(sc->sc_delay);
                    107:        lcd_write(sc, "OpenBSD/" MACHINE);
                    108:
                    109:        timeout_set(&sc->sc_to, lcd_blink_finish, sc);
                    110:
                    111:        sc->sc_blink.bl_func = lcd_blink;
                    112:        sc->sc_blink.bl_arg = sc;
                    113:        blink_led_register(&sc->sc_blink);
                    114: }
                    115:
                    116: void
                    117: lcd_write(struct lcd_softc *sc, const char *str)
                    118: {
                    119:        while (*str) {
                    120:                bus_space_write_1(sc->sc_iot, sc->sc_datah, 0, *str++);
                    121:                delay(sc->sc_delay);
                    122:        }
                    123: }
                    124:
                    125: void
                    126: lcd_blink(void *v, int on)
                    127: {
                    128:        struct lcd_softc *sc = v;
                    129:
                    130:        sc->sc_on = on;
                    131:        bus_space_write_1(sc->sc_iot, sc->sc_cmdh, 0, sc->sc_heartbeat[0]);
                    132:        timeout_add(&sc->sc_to, max(1, (sc->sc_delay * hz) / 1000000));
                    133: }
                    134:
                    135: void
                    136: lcd_blink_finish(void *v)
                    137: {
                    138:        struct lcd_softc *sc = v;
                    139:        u_int8_t data;
                    140:
                    141:        if (sc->sc_on)
                    142:                data = sc->sc_heartbeat[1];
                    143:        else
                    144:                data = sc->sc_heartbeat[2];
                    145:
                    146:        bus_space_write_1(sc->sc_iot, sc->sc_datah, 0, data);
                    147: }