From dfe8644d8caa7dbc4d7747853f394fb8fb34d385 Mon Sep 17 00:00:00 2001 From: Jason Wright Date: Tue, 4 Dec 2001 21:43:02 +0000 Subject: skeleton driver for cgthree (at the same point as cgsix) --- sys/dev/sbus/cgthree.c | 392 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 392 insertions(+) create mode 100644 sys/dev/sbus/cgthree.c (limited to 'sys/dev/sbus/cgthree.c') diff --git a/sys/dev/sbus/cgthree.c b/sys/dev/sbus/cgthree.c new file mode 100644 index 00000000000..5242ac06d85 --- /dev/null +++ b/sys/dev/sbus/cgthree.c @@ -0,0 +1,392 @@ +/* $OpenBSD: cgthree.c,v 1.1 2001/12/04 21:43:01 jason Exp $ */ + +/* + * Copyright (c) 2001 Jason L. Wright (jason@thought.net) + * 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 Jason L. Wright + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#define CGTHREE_CTRL_OFFSET 0x400000 +#define CGTHREE_CTRL_SIZE (sizeof(u_int32_t) * 8) +#define CGTHREE_VID_OFFSET 0x800000 +#define CGTHREE_VID_SIZE (1024 * 1024) + +struct cgthree_softc { + struct device sc_dev; + struct sbusdev sc_sd; + bus_space_tag_t sc_bustag; + bus_space_handle_t sc_ctrl_regs; + bus_space_handle_t sc_vid_regs; + int sc_nscreens; + int sc_width, sc_height, sc_depth, sc_linebytes; + struct rcons sc_rcons; + struct raster sc_raster; +}; + +struct wsdisplay_emulops cgthree_emulops = { + rcons_cursor, + rcons_mapchar, + rcons_putchar, + rcons_copycols, + rcons_erasecols, + rcons_copyrows, + rcons_eraserows, + rcons_alloc_attr +}; + +struct wsscreen_descr cgthree_stdscreen = { + "std", + 0, 0, /* will be filled in -- XXX shouldn't, it's global. */ + 0, + 0, 0, + WSSCREEN_REVERSE +}; + +const struct wsscreen_descr *cgthree_scrlist[] = { + &cgthree_stdscreen, + /* XXX other formats? */ +}; + +struct wsscreen_list cgthree_screenlist = { + sizeof(cgthree_scrlist) / sizeof(struct wsscreen_descr *), cgthree_scrlist +}; + +int cgthree_ioctl __P((void *, u_long, caddr_t, int, struct proc *)); +int cgthree_alloc_screen __P((void *, const struct wsscreen_descr *, void **, + int *, int *, long *)); +void cgthree_free_screen __P((void *, void *)); +int cgthree_show_screen __P((void *, void *, int, + void (*cb) __P((void *, int, int)), void *)); +paddr_t cgthree_mmap __P((void *, off_t, int)); +int cgthree_romcursoraddr __P((int **, int **)); +int cgthree_is_console __P((int)); + +static int a2int __P((char *, int)); + +struct wsdisplay_accessops cgthree_accessops = { + cgthree_ioctl, + cgthree_mmap, + cgthree_alloc_screen, + cgthree_free_screen, + cgthree_show_screen, + 0 /* load_font */ +}; + +int cgthreematch __P((struct device *, void *, void *)); +void cgthreeattach __P((struct device *, struct device *, void *)); + +struct cfattach cgthree_ca = { + sizeof (struct cgthree_softc), cgthreematch, cgthreeattach +}; + +struct cfdriver cgthree_cd = { + NULL, "cgthree", DV_DULL +}; + +int +cgthreematch(parent, vcf, aux) + struct device *parent; + void *vcf, *aux; +{ + struct cfdata *cf = vcf; + struct sbus_attach_args *sa = aux; + + return (strcmp(cf->cf_driver->cd_name, sa->sa_name) == 0); +} + +void +cgthreeattach(parent, self, aux) + struct device *parent, *self; + void *aux; +{ + struct cgthree_softc *sc = (struct cgthree_softc *)self; + struct sbus_attach_args *sa = aux; + struct wsemuldisplaydev_attach_args waa; + int console; + long defattr; + + sc->sc_bustag = sa->sa_bustag; + + if (sa->sa_nreg != 1) { + printf(": expected %d registers, got %d\n", 1, sa->sa_nreg); + goto fail; + } + + /* + * Map just BT, FHC, THC, and video RAM. + */ + if (sbus_bus_map(sa->sa_bustag, sa->sa_reg[0].sbr_slot, + sa->sa_reg[0].sbr_offset + CGTHREE_CTRL_OFFSET, + CGTHREE_CTRL_SIZE, BUS_SPACE_MAP_LINEAR, + 0, &sc->sc_ctrl_regs) != 0) { + printf(": cannot map bt registers\n", self->dv_xname); + goto fail_bt; + } + + if (sbus_bus_map(sa->sa_bustag, sa->sa_reg[0].sbr_slot, + sa->sa_reg[0].sbr_offset + CGTHREE_VID_OFFSET, + CGTHREE_VID_SIZE, BUS_SPACE_MAP_LINEAR, + 0, &sc->sc_vid_regs) != 0) { + printf(": cannot map vid registers\n", self->dv_xname); + goto fail_vid; + } + + console = cgthree_is_console(sa->sa_node); + + sc->sc_depth = getpropint(sa->sa_node, "depth", -1); + if (sc->sc_depth == -1) + sc->sc_depth = 8; + + sc->sc_linebytes = getpropint(sa->sa_node, "linebytes", -1); + if (sc->sc_linebytes == -1) + sc->sc_linebytes = 1152; + + sc->sc_height = getpropint(sa->sa_node, "height", -1); + if (sc->sc_height == -1) + sc->sc_height = 900; + + sc->sc_width = getpropint(sa->sa_node, "width", -1); + if (sc->sc_width == -1) + sc->sc_width = 1152; + + sbus_establish(&sc->sc_sd, &sc->sc_dev); + + sc->sc_rcons.rc_sp = &sc->sc_raster; + sc->sc_raster.width = sc->sc_width; + sc->sc_raster.height = sc->sc_height; + sc->sc_raster.depth = sc->sc_depth; + sc->sc_raster.linelongs = sc->sc_linebytes / 4; + sc->sc_raster.pixels = (void *)sc->sc_vid_regs; + + sc->sc_rcons.rc_crow = sc->sc_rcons.rc_ccol = -1; + if (cgthree_romcursoraddr(&sc->sc_rcons.rc_crowp, &sc->sc_rcons.rc_ccolp)) { + sc->sc_rcons.rc_crowp = &sc->sc_rcons.rc_crow; + sc->sc_rcons.rc_ccolp = &sc->sc_rcons.rc_ccol; + } + +#if 0 + sc->sc_rcons.rc_font = &console_font; + sc->sc_rcons.rc_maxcol = + sc->sc_raster.width / sc->sc_rcons.rc_font->width; + sc->sc_rcons.rc_maxrow = + sc->sc_raster.height / sc->sc_rcons.rc_font->height; + sc->sc_rcons.rc_maxcol = min(sc->sc_rcons.rc_maxcol, + a2int(getpropstring(optionsnode, "screen-#columns"), 80)); + sc->sc_rcons.rc_maxrow = min(sc->sc_rcons.rc_maxrow, + a2int(getpropstring(optionsnode, "screen-#rows"), 34)); +#else + sc->sc_rcons.rc_maxcol = + a2int(getpropstring(optionsnode, "screen-#columns"), 80); + sc->sc_rcons.rc_maxrow = + a2int(getpropstring(optionsnode, "screen-#rows"), 34); +#endif + + rcons_init(&sc->sc_rcons, 160, 160); + + cgthree_stdscreen.nrows = sc->sc_rcons.rc_maxrow; + cgthree_stdscreen.ncols = sc->sc_rcons.rc_maxcol; + cgthree_stdscreen.textops = &cgthree_emulops; + rcons_alloc_attr(&sc->sc_rcons, 0, 0, 0, &defattr); + + waa.console = console; + waa.scrdata = &cgthree_screenlist; + waa.accessops = &cgthree_accessops; + waa.accesscookie = sc; + + printf("\n"); + + wsdisplay_cnattach(&cgthree_stdscreen, &sc->sc_rcons, 0, 0, defattr); + + config_found(self, &waa, wsemuldisplaydevprint); + + return; + +fail_vid: + bus_space_unmap(sa->sa_bustag, sc->sc_ctrl_regs, CGTHREE_CTRL_SIZE); +fail_bt: +fail: +} + +int +cgthree_ioctl(v, cmd, data, flags, p) + void *v; + u_long cmd; + caddr_t data; + int flags; + struct proc *p; +{ + struct cgthree_softc *sc = v; + struct wsdisplay_fbinfo *wdf; + + switch (cmd) { + case WSDISPLAYIO_GTYPE: + *(u_int *)data = WSDISPLAY_TYPE_UNKNOWN; + break; + case WSDISPLAYIO_GINFO: + wdf = (void *)data; + wdf->height = sc->sc_height; + wdf->width = sc->sc_width; + wdf->depth = sc->sc_depth; + wdf->cmsize = 256; + break; + case WSDISPLAYIO_LINEBYTES: + *(u_int *)data = sc->sc_linebytes; + break; + +#if 0 + case WSDISPLAYIO_GETCMAP: + return vgafb_getcmap(vc, (struct wsdisplay_cmap *)data); + case WSDISPLAYIO_PUTCMAP: + return vgafb_putcmap(vc, (struct wsdisplay_cmap *)data); +#endif + + case WSDISPLAYIO_SVIDEO: + case WSDISPLAYIO_GVIDEO: + case WSDISPLAYIO_GCURPOS: + case WSDISPLAYIO_SCURPOS: + case WSDISPLAYIO_GCURMAX: + case WSDISPLAYIO_GCURSOR: + case WSDISPLAYIO_SCURSOR: + default: + return -1; /* not supported yet */ + } + + return (0); +} + +int +cgthree_alloc_screen(v, type, cookiep, curxp, curyp, attrp) + void *v; + const struct wsscreen_descr *type; + void **cookiep; + int *curxp, *curyp; + long *attrp; +{ + struct cgthree_softc *sc = v; + + if (sc->sc_nscreens > 0) + return (ENOMEM); + + *cookiep = &sc->sc_rcons; + *curxp = *curyp = 0; + rcons_alloc_attr(&sc->sc_rcons, 0, 0, 0, attrp); + sc->sc_nscreens++; + return (0); +} + +void +cgthree_free_screen(v, cookie) + void *v; + void *cookie; +{ + struct cgthree_softc *sc = v; + + sc->sc_nscreens--; +} + +int +cgthree_show_screen(v, cookie, waitok, cb, cbarg) + void *v; + void *cookie; + int waitok; + void (*cb) __P((void *, int, int)); + void *cbarg; +{ + return (0); +} + +paddr_t +cgthree_mmap(v, offset, prot) + void *v; + off_t offset; + int prot; +{ +#if 0 + struct cgthree_softc *sc = v; +#endif + + if (offset & PGOFSET) + return (-1); + return (-1); +} + +static int +a2int(char *cp, int deflt) +{ + int i; + + if (*cp == '\0') + return (deflt); + while (*cp != '\0') + i = i * 10 + *cp++ - '\0'; + return (i); +} + +int +cgthree_romcursoraddr(rowp, colp) + int **rowp, **colp; +{ + int rx, cx; + + return (1); + /* + * XXX these calls crash the machine... OF_interpret appears to + * be broken. + */ + OF_interpret("addr line#", 1, &rx); + OF_interpret("addr column#", 1, &cx); + return (0); +} + +int +cgthree_is_console(node) + int node; +{ + extern int fbnode; + + return (fbnode == node); +} -- cgit v1.2.3