From d0e03ced81ad659881f673d0e9c95c31e7aaae0d Mon Sep 17 00:00:00 2001 From: Michael Shalayeff Date: Thu, 31 Dec 1998 03:20:45 +0000 Subject: STI graphics --- sys/arch/hppa/dev/sti.c | 578 +++++++++++++++++++++++++++++++++++++++++++++ sys/arch/hppa/dev/stireg.h | 430 +++++++++++++++++++++++++++++++++ 2 files changed, 1008 insertions(+) create mode 100644 sys/arch/hppa/dev/sti.c create mode 100644 sys/arch/hppa/dev/stireg.h (limited to 'sys/arch') diff --git a/sys/arch/hppa/dev/sti.c b/sys/arch/hppa/dev/sti.c new file mode 100644 index 00000000000..90b04af7230 --- /dev/null +++ b/sys/arch/hppa/dev/sti.c @@ -0,0 +1,578 @@ +/* $OpenBSD: sti.c,v 1.1 1998/12/31 03:20:44 mickey Exp $ */ + +/* + * Copyright (c) 1998 Michael Shalayeff + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by Michael Shalayeff. + * 4. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#define STIDEBUG + +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +#include + +#include + +struct sti_softc { + struct device sc_dev; + + u_int sc_flags; + u_int sc_devtype; + u_int sc_regs; + u_int sc_rom; + + int sc_attr; + struct sti_config sti_config; + struct sti_fontcfg sti_fontcfg; + vm_offset_t sc_code; /* code region allocated */ + void (*sti_init) __P((struct sti_initflags *, + struct sti_initin *, + struct sti_initout *, + struct sti_config *)); + void (*sti_state) __P((void)); + void (*sti_font) __P((struct sti_fontflags *, + struct sti_fontin *, + struct sti_fontout *, + struct sti_config *)); + void (*sti_bmove) __P((struct sti_moveflags *, + struct sti_movein *, + struct sti_moveout *, + struct sti_config *)); + void (*sti_test) __P((void)); + void (*sti_fault) __P((void)); + void (*sti_inqcfg) __P((struct sti_inquireflags *, + struct sti_inquirein *, + struct sti_inquireout *, + struct sti_config *)); +}; + +/* sti_init() flags */ +#define STI_TEXTMODE 0x01 +#define STI_CLEARSCR 0x02 + +enum sti_bmove_funcs { + bmf_clear, bmf_copy, bmf_invert +}; + +int stiprobe __P((struct device *, void *, void *)); +void stiattach __P((struct device *, struct device *, void *)); + +struct cfattach sti_ca = { + sizeof(struct sti_softc), stiprobe, stiattach +}; + +struct cfdriver sti_cd = { + NULL, "sti", DV_DULL +}; + +void sti_cursor __P((void *, int, int, int)); +void sti_putstr __P((void *, int, int, char *, int)); +void sti_copycols __P((void *, int, int, int, int)); +void sti_erasecols __P((void *, int, int, int)); +void sti_copyrows __P((void *, int, int, int)); +void sti_eraserows __P((void *, int, int)); +void sti_set_attr __P((void *, int)); + +struct wscons_emulfuncs sti_emulfuncs = { + sti_cursor, + sti_putstr, + sti_copycols, + sti_erasecols, + sti_copyrows, + sti_eraserows, + sti_set_attr +}; + +u_int stiload __P((vm_offset_t dst, vm_offset_t scode, + vm_offset_t ecode, int t)); +int sti_init __P((struct sti_softc *sc, int mode)); +int sti_inqcfg __P((struct sti_softc *sc, struct sti_inquireout *out)); +void sti_bmove __P((struct sti_softc *sc, int, int, int, int, int, int, + enum sti_bmove_funcs)); +int sti_print __P((void *aux, const char *pnp)); +int stiioctl __P((void *v, u_long cmd, caddr_t data, int flag, struct proc *)); +int stimmap __P((void *v, off_t offset, int prot)); + +int +stiprobe(parent, match, aux) + struct device *parent; + void *match, *aux; +{ + register struct confargs *ca = aux; + u_int rom; + u_char devtype; + int rv = 0; + + if (ca->ca_type.iodc_type != HPPA_TYPE_FIO || + (ca->ca_type.iodc_sv_model != HPPA_FIO_GSGC && + ca->ca_type.iodc_sv_model != HPPA_FIO_SGC)) + return 0; + + /* + * Locate STI ROM. + * On some machines it may not be part of the HPA space. + */ + if (!PAGE0->pd_resv2[1]) + rom = ca->ca_hpa; + else + rom = PAGE0->pd_resv2[1]; + + devtype = STI_DEVTYP(STI_TYPE_BWGRF, rom); + if ((ca->ca_type.iodc_sv_model == HPPA_FIO_SGC && + STI_ID_HI(STI_TYPE_BWGRF, ca->ca_hpa) == STI_ID_FDDI) || + (devtype != STI_TYPE_BWGRF && devtype != STI_TYPE_WWGRF)) { +#ifdef DEBUG + printf("sti: not a graphics device (:%x)\n", devtype); +#endif + } else + rv = 1; + + return rv; +} + +int +sti_init(sc, mode) + struct sti_softc *sc; + int mode; +{ + struct sti_initflags flags; + struct sti_initin input; + struct sti_initout output; + + bzero(&flags, sizeof(flags)); + bzero(&input, sizeof(input)); + bzero(&output, sizeof(output)); + + flags.wait = 1; + flags.hardreset = 0; + flags.clear = 0; + flags.cmap_black = 1; + flags.bus_error_timer = 1; + if (mode & STI_TEXTMODE) { + flags.texton = 1; + flags.no_change_bet = 1; + flags.no_change_bei = 1; + flags.init_text_cmap = 1; + } + input.text_planes = 1; + sc->sti_init(&flags, &input, &output, &sc->sti_config); + return (output.text_planes != input.text_planes || output.errno); +} + +int +sti_inqcfg(sc, out) + struct sti_softc *sc; + struct sti_inquireout *out; +{ + struct sti_inquireflags flags; + struct sti_inquirein input; + + bzero(&flags, sizeof(flags)); + bzero(&input, sizeof(input)); + bzero(out, sizeof(*out)); + + flags.wait = 1; + sc->sti_inqcfg(&flags, &input, out, &sc->sti_config); + + return out->errno; +} + +void +sti_bmove(sc, x1, y1, x2, y2, h, w, f) + struct sti_softc *sc; + int x1, y1, x2, y2, h, w; + enum sti_bmove_funcs f; +{ + struct sti_moveflags flags; + struct sti_movein input; + struct sti_moveout output; + + bzero(&flags, sizeof(flags)); + bzero(&input, sizeof(input)); + bzero(&output, sizeof(output)); + + flags.wait = 1; + switch (f) { + case bmf_clear: + flags.clear = 1; + input.bg_color = 0; + break; + case bmf_copy: + input.fg_color = 1; + input.bg_color = 0; + break; + case bmf_invert: + input.fg_color = 0; + input.bg_color = 1; + break; + } + input.src_x = x1; + input.src_y = y1; + input.dest_x = x2; + input.dest_y = y2; + input.wheight = h; + input.wwidth = w; + + sc->sti_bmove(&flags, &input, &output, &sc->sti_config); +#ifdef STIDEBUG + if (output.errno) + printf ("%s: sti_bmove returned %d\n", + sc->sc_dev.dv_xname, output.errno); +#endif +} + +void +stiattach(parent, self, aux) + struct device *parent, *self; + void *aux; +{ + struct wscons_attach_args waa; + struct sti_inquireout cfg; + register struct sti_softc *sc = (void *)self; + register struct confargs *ca = aux; + register struct wscons_odev_spec *wo; + register u_int dt, addr; + int error; + + sc->sc_regs = ca->ca_hpa; + if (!PAGE0->pd_resv2[1]) + sc->sc_rom = ca->ca_hpa; + else + sc->sc_rom = PAGE0->pd_resv2[1]; + + dt = sc->sc_devtype = STI_DEVTYP(STI_TYPE_BWGRF, sc->sc_rom); +#if 0 + sc->sti_init = (void *)STI_IGADDR(dt, sc->sc_rom); + sc->sti_state = (void *)STI_SMADDR(dt, sc->sc_rom); + sc->sti_font = (void *)STI_FUADDR(dt, sc->sc_rom); + sc->sti_bmove = (void *)STI_BMADDR(dt, sc->sc_rom); + sc->sti_test = (void *)STI_STADDR(dt, sc->sc_rom); + sc->sti_fault = (void *)STI_EHADDR(dt, sc->sc_rom); + sc->sti_inqcfg = (void *)STI_ICADDR(dt, sc->sc_rom); +#else + { + u_int t; + t = STI_EADDR(dt, sc->sc_rom) - STI_IGADDR(dt, sc->sc_rom); + t = hppa_round_page(t); + if (!(sc->sc_code = kmem_malloc(kmem_map, t, 0))) { + printf(": cannot allocate %d bytes for code\n", t); + return; + } else + pmap_protect(kmem_map->pmap, sc->sc_code, + sc->sc_code + t, VM_PROT_ALL); + + t = 0; + sc->sti_init = (void *)sc->sc_code; + t += stiload(sc->sc_code + t, STI_IGADDR(dt, sc->sc_rom), + STI_SMADDR(dt, sc->sc_rom), dt); + sc->sti_state = (void *)(sc->sc_code + t); + t += stiload(sc->sc_code + t, STI_SMADDR(dt, sc->sc_rom), + STI_FUADDR(dt, sc->sc_rom), dt); + sc->sti_font = (void *)(sc->sc_code + t); + t += stiload(sc->sc_code + t, STI_FUADDR(dt, sc->sc_rom), + STI_BMADDR(dt, sc->sc_rom), dt); + sc->sti_bmove = (void *)(sc->sc_code + t); + t += stiload(sc->sc_code + t, STI_BMADDR(dt, sc->sc_rom), + STI_STADDR(dt, sc->sc_rom), dt); + sc->sti_test = (void *)(sc->sc_code + t); + t += stiload(sc->sc_code + t, STI_STADDR(dt, sc->sc_rom), + STI_EHADDR(dt, sc->sc_rom), dt); + sc->sti_fault = (void *)(sc->sc_code + t); + t += stiload(sc->sc_code + t, STI_EHADDR(dt, sc->sc_rom), + STI_ICADDR(dt, sc->sc_rom), dt); + sc->sti_inqcfg = (void *)(sc->sc_code + t); + t += stiload(sc->sc_code + t, STI_ICADDR(dt, sc->sc_rom), + STI_EADDR(dt, sc->sc_rom), dt); + fcacheall(); + } +#endif + + /* fill out sti_config */ + bzero(&sc->sti_config, sizeof(sc->sti_config)); + { + register u_int *p; + register u_int *q = (u_int *)STI_MMAP(dt, sc->sc_rom); + + for (p = sc->sti_config.regions; + p < &sc->sti_config.regions[STI_REGIONS]; p++) { + struct sti_region r; + if (dt == STI_TYPE_BWGRF) { + /* we know that sti_region is 4 bytes */ + *((u_char *)&r + 0) = *q++; + *((u_char *)&r + 1) = *q++; + *((u_char *)&r + 2) = *q++; + *((u_char *)&r + 3) = *q++; + } else + *(u_int *)&r = *q++; + + *p = ((p == sc->sti_config.regions)? sc->sc_rom : + sc->sc_regs) + (r.offset << PGSHIFT); + + if (r.last) + break; +#ifdef STIDEBUG + printf("@0x%05x, sys %d, cache %d, btlb %d, len %d\n", + r.offset, r.sysonly, r.cache, r.btlb, r.length); +#endif + } + } + + + if ((error = sti_init(sc, 0))) { + printf (": can not initialize (%d)\n", error); + return; + } + + if ((error = sti_inqcfg(sc, &cfg))) { + printf (": error %d inquiring config\n", error); + return; + } + + if ((error = sti_init(sc, STI_TEXTMODE))) { + printf (": can not initialize (%d)\n", error); + return; + } + + /* fill out sti_fontcfg */ + addr = STI_FONTAD(dt, sc->sc_rom) & ~3; + sc->sti_fontcfg.firstc = STIF_FIRSTC (dt, addr); + sc->sti_fontcfg.lastc = STIF_LASTC (dt, addr); + sc->sti_fontcfg.ftheight = STIF_FHEIGHT(dt, addr); + sc->sti_fontcfg.ftwidth = STIF_FWIDTH (dt, addr); + sc->sti_fontcfg.ftype = STIF_FTYPE (dt, addr); + sc->sti_fontcfg.bpc = STIF_BPC (dt, addr); + sc->sti_fontcfg.uheight = STIF_UHEIGHT(dt, addr); + sc->sti_fontcfg.uoffset - STIF_UOFFSET(dt, addr); + + printf (": %s rev %d.%d\n" + "%s: %dx%d frame buffer, %dx%dx%d display, offset %dx%d\n" + "%s: %dx%d font type %d, %d bpc, charset %d-%d\n", + cfg.devname, STI_GLOREV(dt, sc->sc_rom) >> 4, + STI_GLOREV(dt, sc->sc_rom) & 0xf, + sc->sc_dev.dv_xname, cfg.fbwidth, cfg.fbheight, + cfg.dwidth, cfg.dheight, cfg.bpp, cfg.owidth, cfg.oheight, + sc->sc_dev.dv_xname, + sc->sti_fontcfg.ftwidth, sc->sti_fontcfg.ftheight, + sc->sti_fontcfg.ftype, sc->sti_fontcfg.bpc, + sc->sti_fontcfg.firstc, sc->sti_fontcfg.lastc); + + /* attach WSCONS */ + wo = &waa.waa_odev_spec; + + wo->wo_emulfuncs = &sti_emulfuncs; + wo->wo_emulfuncs_cookie = sc; + + wo->wo_ioctl = stiioctl; + wo->wo_mmap = stimmap; + wo->wo_miscfuncs_cookie = sc; + + wo->wo_nrows = 64; + wo->wo_ncols = 80; + wo->wo_crow = 64; + wo->wo_ccol = 0; + + config_found(parent, &waa, sti_print); + + return; +} + +u_int +stiload(dst, scode, ecode, t) + vm_offset_t dst, scode, ecode; + int t; +{ + vm_offset_t sdst = dst; + +#ifdef STIDEBUG + printf("stiload(%x, %x, %x, %d)\n", dst, scode, ecode, t); +#endif + while (scode < ecode) { + if (t == STI_TYPE_BWGRF) + *((u_char *)dst)++ = *(u_char *)scode; + else + *((u_int *)dst)++ = *(u_int *)scode; + scode += sizeof(u_int); + } + + return dst - sdst; +} + +int +sti_print(aux, pnp) + void *aux; + const char *pnp; +{ + if (pnp) + printf("wscons at %s", pnp); + return UNCONF; +} + +int +stiioctl(v, cmd, data, flag, p) + void *v; + u_long cmd; + caddr_t data; + int flag; + struct proc *p; +{ + /* register struct sti_softc *sc; */ + + return -1; +} + +int +stimmap(v, offset, prot) + void *v; + off_t offset; + int prot; +{ + /* XXX not finished */ + return offset; +} + +void +sti_cursor(v, on, row, col) + void *v; + int on, row, col; +{ + register struct sti_softc *sc = v; + + sti_bmove(sc, row * sc->sti_fontcfg.ftheight, col * sc->sti_fontcfg.ftwidth, + row * sc->sti_fontcfg.ftheight, col * sc->sti_fontcfg.ftwidth, + sc->sti_fontcfg.ftwidth, sc->sti_fontcfg.ftheight, bmf_invert); +} + +void +sti_putstr(v, row, col, cp, len) + void *v; + int row, col; + char *cp; + int len; +{ + register struct sti_softc *sc = v; + struct sti_fontflags flags; + struct sti_fontin input; + struct sti_fontout output; + + bzero(&flags, sizeof(flags)); + bzero(&input, sizeof(input)); + bzero(&output, sizeof(output)); + + flags.wait = 1; + /* XXX does not handle text attributes */ + input.fg_color = 1; + input.bg_color = 0; + input.dest_x = col * sc->sti_fontcfg.ftwidth; + input.dest_y = row * sc->sti_fontcfg.ftheight; + input.startaddr = STI_FONTAD(sc->sc_devtype, sc->sc_rom); + for (; *cp; cp++, input.dest_x += sc->sti_fontcfg.ftwidth) { + input.index = *cp; + sc->sti_font(&flags, &input, &output, &sc->sti_config); + } +} + +void +sti_copycols(v, row, srccol, dstcol, ncols) + void *v; + int row, srccol, dstcol, ncols; +{ + register struct sti_softc *sc = v; + + sti_bmove(sc, + row * sc->sti_fontcfg.ftheight, srccol * sc->sti_fontcfg.ftwidth, + row * sc->sti_fontcfg.ftheight, dstcol * sc->sti_fontcfg.ftwidth, + ncols * sc->sti_fontcfg.ftwidth, sc->sti_fontcfg.ftheight, + bmf_copy); +} + +void +sti_erasecols(v, row, startcol, ncols) + void *v; + int row, startcol, ncols; +{ + register struct sti_softc *sc = v; + + sti_bmove(sc, + row * sc->sti_fontcfg.ftheight, startcol * sc->sti_fontcfg.ftwidth, + row * sc->sti_fontcfg.ftheight, startcol * sc->sti_fontcfg.ftwidth, + ncols * sc->sti_fontcfg.ftwidth, sc->sti_fontcfg.ftheight, + bmf_clear); +} + +void +sti_copyrows(v, srcrow, dstrow, nrows) + void *v; + int srcrow, dstrow, nrows; +{ + register struct sti_softc *sc = v; + + sti_bmove(sc, + srcrow * sc->sti_fontcfg.ftheight, 0, + dstrow * sc->sti_fontcfg.ftheight, 0, + sc->sti_config.fbwidth, nrows + sc->sti_fontcfg.ftheight, + bmf_copy); +} + +void +sti_eraserows(v, srcrow, nrows) + void *v; + int srcrow, nrows; +{ + register struct sti_softc *sc = v; + + sti_bmove(sc, + srcrow * sc->sti_fontcfg.ftheight, 0, + srcrow * sc->sti_fontcfg.ftheight, 0, + sc->sti_config.fbwidth, nrows + sc->sti_fontcfg.ftheight, + bmf_clear); +} + +void +sti_set_attr(v, val) + void *v; + int val; +{ + register struct sti_softc *sc = v; + + sc->sc_attr = val; +} + diff --git a/sys/arch/hppa/dev/stireg.h b/sys/arch/hppa/dev/stireg.h new file mode 100644 index 00000000000..b0c353a3c12 --- /dev/null +++ b/sys/arch/hppa/dev/stireg.h @@ -0,0 +1,430 @@ +/* $OpenBSD: stireg.h,v 1.1 1998/12/31 03:20:44 mickey Exp $ */ + +/* + * Copyright 1996 1995 by Open Software Foundation, Inc. + * All Rights Reserved + * + * Permission to use, copy, modify, and distribute this software and + * its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notice appears in all copies and + * that both the copyright notice and this permission notice appear in + * supporting documentation. + * + * OSF DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE. + * + * IN NO EVENT SHALL OSF BE LIABLE FOR ANY SPECIAL, INDIRECT, OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM + * LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT, + * NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION + * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +/* + * Copyright (c) 1991,1992,1994, The University of Utah and + * the Computer Systems Laboratory at the University of Utah (CSL). + * All rights reserved. + * + * Permission to use, copy, modify and distribute this software is hereby + * granted provided that (1) source code retains these copyright, permission, + * and disclaimer notices, and (2) redistributions including binaries + * reproduce the notices in supporting documentation, and (3) all advertising + * materials mentioning features or use of this software display the following + * acknowledgement: ``This product includes software developed by the + * Computer Systems Laboratory at the University of Utah.'' + * + * THE UNIVERSITY OF UTAH AND CSL ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS + * IS" CONDITION. THE UNIVERSITY OF UTAH AND CSL DISCLAIM ANY LIABILITY OF + * ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. + * + * CSL requests users of this software to return to csl-dist@cs.utah.edu any + * improvements that they make and grant CSL redistribution rights. + * + * Utah $Hdr: grf_stireg.h 1.7 94/12/14$ + */ + +#ifndef _STIREG_H_ +#define _STIREG_H_ + +/* + * Standard Text Interface. + */ + +#define STI_CODECNT 7 +#define STI_REGIONS 8 +#define STI_NAMELEN 32 + +/* + * Structure templates for old byte-wide interface + */ +typedef struct { + char p[3]; + u_char b0; +} stibyte; + +typedef struct { + char p0[3]; + u_char b0; + char p1[3]; + u_char b1; +} stihalf; + +typedef struct { + char p0[3]; + u_char b0; + char p1[3]; + u_char b1; + char p2[3]; + u_char b2; + char p3[3]; + u_char b3; +} stiword; + +/* + * STI ROM layout, byte-wide and word-wide interfaces. + * Word-wide fields are aligned to word boundaries for access even + * though some are technically smaller (e.g. devtype is 8 bits). + */ +struct sti_bytewide { + stibyte sti_devtype; /* 0x03: device type (see below) */ + stihalf sti_revno; /* 0x07: global/local ROM revision */ + char sti_p0[0x4]; + stiword sti_gid_hi; /* 0x13: graphics ID (high word) */ + stiword sti_gid_lo; /* 0x23: graphics ID (low byte) */ + stiword sti_fontaddr; /* 0x33: font start address */ + stiword sti_mss; /* 0x43: max state storage */ + stiword sti_erom; /* 0x53: last address of ROM */ + stiword sti_mmap; /* 0x63: memory map information */ + stihalf sti_mstore; /* 0x73: max re-entrant storage */ + stihalf sti_mtimo; /* 0x7b: max 1/10 secs for routines */ +#ifdef hp300 + char sti_p1[0x180]; +#else + char sti_p1[0x80]; +#endif + stiword sti_routine[STI_CODECNT+1]; /* 0x103: routines */ +}; + +struct sti_wordwide { + u_int sti_devtype; /* 0x00: device type (see below) */ + u_int sti_revno; /* 0x04: global ROM revision */ + u_int sti_gid_hi; /* 0x08: graphics ID (high word) */ + u_int sti_gid_lo; /* 0x0c: graphics ID (low byte) */ + u_int sti_fontaddr; /* 0x10: font start address */ + u_int sti_mss; /* 0x14: max state storage */ + u_int sti_erom; /* 0x18: last address of ROM */ + u_int sti_mmap; /* 0x1c: memory map information */ + u_int sti_mstore; /* 0x20: max re-entrant storage */ + u_int sti_mtimo; /* 0x24: max 1/10 secs for routines */ +#ifdef hp300 + char sti_p0[0x58]; +#else + char sti_p0[0x18]; +#endif + u_int sti_routine[STI_CODECNT+1]; /* 0x40: routines */ +}; + +#define STI_GETBYTE(t,a,f) \ + (((t) == STI_TYPE_BWGRF) ? \ + ((struct sti_bytewide *)(a))->f.b0 : \ + (((struct sti_wordwide *)(a))->f & 0xff)) + +#define STI_GETHALF(t,a,f) \ + (((t) == STI_TYPE_BWGRF) ? \ + ((((struct sti_bytewide *)(a))->f.b0 << 8) | \ + (((struct sti_bytewide *)(a))->f.b1)) : \ + (((struct sti_wordwide *)(a))->f & 0xffff)) + +#define STI_GETWORD(t,a,f) \ + (((t) == STI_TYPE_BWGRF) ? \ + ((((struct sti_bytewide *)(a))->f.b0 << 24) | \ + (((struct sti_bytewide *)(a))->f.b1 << 16) | \ + (((struct sti_bytewide *)(a))->f.b2 << 8) | \ + (((struct sti_bytewide *)(a))->f.b3)) : \ + ((struct sti_wordwide *)(a))->f) + + +#define STI_DEVTYP(t,a) STI_GETBYTE(t,a,sti_devtype) +#define STI_GLOREV(t,a) (STI_GETHALF(t,a,sti_revno) >> 8) +#define STI_LOCREV(t,a) (STI_GETHALF(t,a,sti_revno) & 0xff) +#define STI_ID_HI(t,a) STI_GETWORD(t,a,sti_gid_hi) +#define STI_ID_LO(t,a) STI_GETWORD(t,a,sti_gid_lo) +#define STI_FONTAD(t,a) ((u_int)(a) + STI_GETWORD(t,a,sti_fontaddr)) +#define STI_MSS(t,a) ((u_int)(a) + STI_GETWORD(t,a,sti_mss)) +#define STI_EROM(t,a) ((u_int)(a) + STI_GETWORD(t,a,sti_erom)) +#define STI_MMAP(t,a) ((u_int)(a) + STI_GETWORD(t,a,sti_mmap)) +#define STI_MSTOR(t,a) STI_GETHALF(t,a,sti_mstore) +#define STI_MTOUT(t,a) STI_GETHALF(t,a,sti_mtimo) + + /* INIT_GRAPH address */ +#define STI_IGADDR(t,a) ((u_int)(a) + STI_GETWORD(t,a,sti_routine[0])) + /* STATE_MGMT address */ +#define STI_SMADDR(t,a) ((u_int)(a) + STI_GETWORD(t,a,sti_routine[1])) + /* FONT_UNP/MV address*/ +#define STI_FUADDR(t,a) ((u_int)(a) + STI_GETWORD(t,a,sti_routine[2])) + /* BLOCK_MOVE address */ +#define STI_BMADDR(t,a) ((u_int)(a) + STI_GETWORD(t,a,sti_routine[3])) + /* SELF_TEST address */ +#define STI_STADDR(t,a) ((u_int)(a) + STI_GETWORD(t,a,sti_routine[4])) + /* EXCEP_HDLR address */ +#define STI_EHADDR(t,a) ((u_int)(a) + STI_GETWORD(t,a,sti_routine[5])) + /* INQ_CONF address */ +#define STI_ICADDR(t,a) ((u_int)(a) + STI_GETWORD(t,a,sti_routine[6])) + /* End address */ +#define STI_EADDR(t,a) ((u_int)(a) + STI_GETWORD(t,a,sti_routine[7])) + +/* STI_ID_HI */ +#define STI_ID_FDDI 0x280B31AF /* Medusa STI ROM graphics ID */ + +/* STI_DEVTYP */ +#define STI_TYPE_BWGRF 1 /* graphics device (byte-wide if) */ +#define STI_TYPE_WWGRF 3 /* graphics device (word-wide if) */ + +/* + * STI font information. + * Note that fields of word-wide structure are not word aligned + * making access a little harder. + */ +struct stifont_bytewide { + stihalf sti_firstchar; /* 0x03: first character */ + stihalf sti_lastchar; /* 0x0b: last character */ + stibyte sti_fwidth; /* 0x13: font width */ + stibyte sti_fheight; /* 0x17: font height */ + stibyte sti_ftype; /* 0x1b: font type */ + stibyte sti_bpc; /* 0x1f: bytes per character */ + stiword sti_next; /* 0x23: offset of next font */ + stibyte sti_uheight; /* 0x33: underline height */ + stibyte sti_uoffset; /* 0x37: underline offset */ +}; + +struct stifont_wordwide { + u_short sti_firstchar; /* 0x00: first character */ + u_short sti_lastchar; /* 0x02: last character */ + u_char sti_fwidth; /* 0x04: font width */ + u_char sti_fheight; /* 0x05: font height */ + u_char sti_ftype; /* 0x06: font type */ + u_char sti_bpc; /* 0x07: bytes per character */ + u_int sti_next; /* 0x08: offset of next font */ + u_char sti_uheight; /* 0x0c: underline height */ + u_char sti_uoffset; /* 0x0d: underline offset */ + char sti_p0[2]; +}; + +#define STIF_FIRSTC(t,a) \ + (((t) == STI_TYPE_BWGRF) ? \ + ((((struct stifont_bytewide *)(a))->sti_firstchar.b0 << 8) | \ + (((struct stifont_bytewide *)(a))->sti_firstchar.b1)) : \ + (((volatile u_int *)(a))[0] >> 16)) +#define STIF_LASTC(t,a) \ + (((t) == STI_TYPE_BWGRF) ? \ + ((((struct stifont_bytewide *)(a))->sti_lastchar.b0 << 8) | \ + (((struct stifont_bytewide *)(a))->sti_lastchar.b1)) : \ + (((volatile u_int *)(a))[0] & 0xffff)) +#define STIF_FWIDTH(t,a) \ + (((t) == STI_TYPE_BWGRF) ? \ + ((struct stifont_bytewide *)(a))->sti_fwidth.b0 : \ + (((volatile u_int *)(a))[1] >> 24)) +#define STIF_FHEIGHT(t,a) \ + (((t) == STI_TYPE_BWGRF) ? \ + ((struct stifont_bytewide *)(a))->sti_fheight.b0 : \ + ((((volatile u_int *)(a))[1] >> 16) & 0xff)) +#define STIF_FTYPE(t,a) \ + (((t) == STI_TYPE_BWGRF) ? \ + ((struct stifont_bytewide *)(a))->sti_ftype.b0 : \ + ((((volatile u_int *)(a))[1] >> 8) & 0xff)) +#define STIF_BPC(t,a) \ + (((t) == STI_TYPE_BWGRF) ? \ + ((struct stifont_bytewide *)(a))->sti_bpc.b0 : \ + (((volatile u_int *)(a))[1] & 0xff)) +#define STIF_NEXT(t,a) \ + (((t) == STI_TYPE_BWGRF) ? \ + ((((struct stifont_bytewide *)(a))->sti_next.b0 << 24) | \ + (((struct stifont_bytewide *)(a))->sti_next.b1 << 16) | \ + (((struct stifont_bytewide *)(a))->sti_next.b2 << 8) | \ + (((struct stifont_bytewide *)(a))->sti_next.b3)) : \ + ((volatile u_int *)(a))[2]) +#define STIF_UHEIGHT(t,a) \ + (((t) == STI_TYPE_BWGRF) ? \ + ((struct stifont_bytewide *)(a))->sti_uheight.b0 : \ + (((volatile u_int *)(a))[3] >> 24)) +#define STIF_UOFFSET(t,a) \ + (((t) == STI_TYPE_BWGRF) ? \ + ((struct stifont_bytewide *)(a))->sti_uoffset.b0 : \ + ((((volatile u_int *)(a))[3] >> 16) & 0xff)) + + + +/* + * Device region information. + */ +struct sti_region { + u_int offset :14, + sysonly :1, + cache :1, + btlb :1, + last :1, + length :14; +}; + +/* + * Global configuration information. There is one per STI device. + */ +struct sti_config { + u_int text_planes; + u_short dwidth; + u_short dheight; + u_short owidth; + u_short oheight; + u_short fbwidth; + u_short fbheight; + u_int regions[STI_REGIONS]; + u_int reentry_level; + u_int save_address; + u_int *future; +}; + +/* + * Font config + */ +struct sti_fontcfg { + u_short firstc; /* first character */ + u_short lastc; /* last character */ + u_char ftwidth; /* font width */ + u_char ftheight; /* font height */ + u_char ftype; /* font type */ + u_char bpc; /* bytes per character */ + u_char uheight; /* underline height */ + u_char uoffset; /* underline offset */ +}; + +/* + * Device initialization structures. + */ +struct sti_initflags { /* Initialization flags */ + u_int wait :1, + hardreset :1, + texton :1, /* ignored if no_change_text == 1 */ + graphon :1, /* ignored if no_change_graph == 1 */ + clear :1, + cmap_black :1, /* ignored if hardreset == 0 */ + bus_error_timer:1, /* ignored if no_change_bet == 1 */ + bus_error_int :1, /* ignored if no_change_bei == 1 */ + no_change_text :1, + no_change_graph:1, + no_change_bet :1, + no_change_bei :1, + init_text_cmap :1, + pad :19; + int *future; +}; + +struct sti_initin { /* Initialization input args */ + int text_planes; + int *future; +}; + +struct sti_initout { /* Initialization output args */ + int errno; + int text_planes; + int *future; +}; + +/* + * Inquire Configuration. + */ +struct sti_inquireflags { + u_int wait :1; + u_int pad :31; + int *future; +}; + +struct sti_inquirein { + int *future; +}; + +struct sti_inquireout { + int errno; + short dwidth; + short dheight; + short owidth; + short oheight; + short fbwidth; + short fbheight; + int bpp; + int bits; + int planes; + char devname[STI_NAMELEN]; + u_int attributes; + int *future; +}; + +/* + * Font Unpack/Move. + */ +struct sti_fontflags { + u_int wait :1; + u_int pad :31; + int *future; +}; + +struct sti_fontin { + int startaddr; + short index; + char fg_color; + char bg_color; + short dest_x; + short dest_y; + int *future; +}; + +struct sti_fontout { + int errno; + int *future; +}; + +/* + * Block Move. + */ +struct sti_moveflags { + u_int wait :1; + u_int color :1; + u_int clear :1; + u_int pad :29; + int *future; +}; + +struct sti_movein { + char fg_color; + char bg_color; + short src_x; + short src_y; + short dest_x; + short dest_y; + short wwidth; + short wheight; + int *future; +}; + +struct sti_moveout { + int errno; + int *future; +}; + +/* + * Error codes returned by STI ROM routines. + */ +#define NO_ERROR 0 +#define BAD_REENTRY_LEVEL 1 +#define NO_REGIONS_DEFINED 2 +#define ILLEGAL_NUMBER_PLANES 3 +#define INVALID_FONT_INDEX 4 +#define INVALID_FONT_LOCATION 5 +#define INVALID_COLOR 6 +#define INVALID_BLKMOVE_SRC 7 +#define INVALID_BLKMOVE_DST 8 +#define INVALID_BLKMOVE_SIZE 9 +#define NO_BUS_ERROR_INT 10 +#define BUS_ERROR 11 +#define HARDWARE_FAILURE 12 + +#endif /* _STIREG_H_ */ -- cgit v1.2.3