/* $NetBSD: cgtwelve.c,v 1.6 2016/04/21 18:24:02 macallan Exp $ */ /*- * Copyright (c) 2010 Michael Lorenz * 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. * * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS * ``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 FOUNDATION OR CONTRIBUTORS * 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. */ /* a console driver for the Sun CG12 / Matrox SG3 graphics board */ #include __KERNEL_RCSID(0, "$NetBSD: cgtwelve.c,v 1.6 2016/04/21 18:24:02 macallan Exp $"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "opt_wsemul.h" #include "opt_cgtwelve.h" struct cgtwelve_softc { device_t sc_dev; bus_space_tag_t sc_tag; bus_space_handle_t sc_regh; bus_addr_t sc_paddr; void *sc_fbaddr; void *sc_shadow; uint8_t *sc_wids; void *sc_int; int sc_width; int sc_height; int sc_stride; int sc_fbsize; int sc_mode; struct vcons_data vd; }; static int cgtwelve_match(device_t, cfdata_t, void *); static void cgtwelve_attach(device_t, device_t, void *); static int cgtwelve_ioctl(void *, void *, u_long, void *, int, struct lwp*); static paddr_t cgtwelve_mmap(void *, void *, off_t, int); static void cgtwelve_init_screen(void *, struct vcons_screen *, int, long *); static void cgtwelve_write_wid(struct cgtwelve_softc *, int, uint8_t); static void cgtwelve_select_ovl(struct cgtwelve_softc *, int); #define CG12_SEL_OVL 0 #define CG12_SEL_ENABLE 1 #define CG12_SEL_8BIT 2 #define CG12_SEL_24BIT 3 #define CG12_SEL_WID 4 static void cgtwelve_write_dac(struct cgtwelve_softc *, int, int, int, int); static void cgtwelve_setup(struct cgtwelve_softc *, int); CFATTACH_DECL_NEW(cgtwelve, sizeof(struct cgtwelve_softc), cgtwelve_match, cgtwelve_attach, NULL, NULL); struct wsscreen_descr cgtwelve_defscreendesc = { "default", 0, 0, NULL, 8, 16, 0, }; static struct vcons_screen cgtwelve_console_screen; const struct wsscreen_descr *_cgtwelve_scrlist[] = { &cgtwelve_defscreendesc, /* XXX other formats, graphics screen? */ }; struct wsscreen_list cgtwelve_screenlist = { sizeof(_cgtwelve_scrlist) / sizeof(struct wsscreen_descr *), _cgtwelve_scrlist }; struct wsdisplay_accessops cgtwelve_accessops = { cgtwelve_ioctl, cgtwelve_mmap, NULL, /* vcons_alloc_screen */ NULL, /* vcons_free_screen */ NULL, /* vcons_show_screen */ NULL, /* load_font */ NULL, /* polls */ NULL, /* scroll */ }; extern const u_char rasops_cmap[768]; static int cgtwelve_match(device_t parent, cfdata_t cf, void *aux) { struct sbus_attach_args *sa = aux; if (strcmp("cgtwelve", sa->sa_name) == 0) return 100; return 0; } /* * Attach a display. We need to notice if it is the console, too. */ static void cgtwelve_attach(device_t parent, device_t self, void *args) { struct cgtwelve_softc *sc = device_private(self); struct sbus_attach_args *sa = args; struct wsemuldisplaydev_attach_args aa; struct rasops_info *ri; unsigned long defattr; bus_space_handle_t bh; int node = sa->sa_node; int isconsole; aprint_normal("\n"); sc->sc_dev = self; sc->sc_tag = sa->sa_bustag; sc->sc_paddr = sbus_bus_addr(sa->sa_bustag, sa->sa_slot, sa->sa_offset); /* read geometry information from the device tree */ sc->sc_width = prom_getpropint(sa->sa_node, "width", 1152); sc->sc_height = prom_getpropint(sa->sa_node, "height", 900); #ifdef CG12_COLOR sc->sc_stride = sc->sc_width; #else sc->sc_stride = (sc->sc_width + 7) >> 3; #endif sc->sc_fbsize = sc->sc_height * sc->sc_stride; sc->sc_fbaddr = (void *)prom_getpropint(sa->sa_node, "address", 0); if (sc->sc_fbaddr == NULL) { if (sbus_bus_map(sa->sa_bustag, sa->sa_slot, sa->sa_offset + CG12_FB_MONO, sc->sc_fbsize, BUS_SPACE_MAP_LINEAR, &bh) != 0) { aprint_error_dev(self, "cannot map framebuffer\n"); return; } sc->sc_fbaddr = bus_space_vaddr(sa->sa_bustag, bh); } aprint_normal_dev(self, "%d x %d\n", sc->sc_width, sc->sc_height); if (sbus_bus_map(sa->sa_bustag, sa->sa_slot, sa->sa_offset + CG12_OFF_REGISTERS, 0xc0000, 0, &sc->sc_regh) != 0) { aprint_error("%s: couldn't map registers\n", device_xname(sc->sc_dev)); return; } if (sbus_bus_map(sa->sa_bustag, sa->sa_slot, sa->sa_offset + CG12_OFF_WID, 0x100000, BUS_SPACE_MAP_LINEAR | BUS_SPACE_MAP_LARGE, &bh) != 0) { aprint_error("%s: couldn't map WID\n", device_xname(sc->sc_dev)); return; } sc->sc_wids = bus_space_vaddr(sa->sa_bustag, bh); if (sbus_bus_map(sa->sa_bustag, sa->sa_slot, sa->sa_offset + CG12_OFF_INTEN, 0x400000, BUS_SPACE_MAP_LINEAR | BUS_SPACE_MAP_LARGE, &bh) != 0) { aprint_error("%s: couldn't map colour fb\n", device_xname(sc->sc_dev)); return; } sc->sc_int = bus_space_vaddr(sa->sa_bustag, bh); #ifdef CG12_COLOR cgtwelve_setup(sc, 8); #else cgtwelve_setup(sc, 1); #endif #ifdef CG12_SHADOW sc->sc_shadow = kmem_alloc(sc->sc_fbsize, KM_SLEEP); #else sc->sc_shadow = NULL; #endif isconsole = fb_is_console(node); sc->sc_mode = WSDISPLAYIO_MODE_EMUL; wsfont_init(); vcons_init(&sc->vd, sc, &cgtwelve_defscreendesc, &cgtwelve_accessops); sc->vd.init_screen = cgtwelve_init_screen; vcons_init_screen(&sc->vd, &cgtwelve_console_screen, 1, &defattr); cgtwelve_console_screen.scr_flags |= VCONS_SCREEN_IS_STATIC; ri = &cgtwelve_console_screen.scr_ri; cgtwelve_defscreendesc.nrows = ri->ri_rows; cgtwelve_defscreendesc.ncols = ri->ri_cols; cgtwelve_defscreendesc.textops = &ri->ri_ops; cgtwelve_defscreendesc.capabilities = ri->ri_caps; if(isconsole) { wsdisplay_cnattach(&cgtwelve_defscreendesc, ri, 0, 0, defattr); vcons_replay_msgbuf(&cgtwelve_console_screen); } aa.console = isconsole; aa.scrdata = &cgtwelve_screenlist; aa.accessops = &cgtwelve_accessops; aa.accesscookie = &sc->vd; config_found(self, &aa, wsemuldisplaydevprint); #ifdef CG12_DEBUG { int i; for (i = 0; i < 0x10; i++) { bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12DAC_ADDR0, (i << 16) | (i << 8) | i); bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12DAC_ADDR1, 0x010101); printf("%02x: %08x\n", i, bus_space_read_4(sc->sc_tag, sc->sc_regh, CG12DAC_CTRL)); } } #endif } /* 0 - overlay plane, 1 - enable plane, 2 - 8bit fb, 3 - 24bit fb, 4 - WIDs */ static void cgtwelve_select_ovl(struct cgtwelve_softc *sc, int which) { switch(which) { case 0: bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12DPU_PLN_RDMSK_HOST, CG12_PLN_RD_OVERLAY); bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12DPU_PLN_WRMSK_HOST, CG12_PLN_WR_OVERLAY); bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12DPU_PLN_SL_HOST, CG12_PLN_SL_OVERLAY); bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12APU_HPAGE, CG12_HPAGE_OVERLAY); bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12APU_HACCESS, CG12_HACCESS_OVERLAY); break; case 1: bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12DPU_PLN_RDMSK_HOST, CG12_PLN_RD_ENABLE); bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12DPU_PLN_WRMSK_HOST, CG12_PLN_WR_ENABLE); bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12DPU_PLN_SL_HOST, CG12_PLN_SL_ENABLE); bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12APU_HPAGE, CG12_HPAGE_ENABLE); bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12APU_HACCESS, CG12_HACCESS_ENABLE); break; case 2: bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12DPU_PLN_RDMSK_HOST, CG12_PLN_RD_8BIT); bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12DPU_PLN_WRMSK_HOST, CG12_PLN_WR_8BIT); bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12DPU_PLN_SL_HOST, CG12_PLN_SL_8BIT); bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12APU_HPAGE, CG12_HPAGE_8BIT); bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12APU_HACCESS, CG12_HACCESS_8BIT); break; case 3: bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12DPU_PLN_RDMSK_HOST, CG12_PLN_RD_24BIT); bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12DPU_PLN_WRMSK_HOST, CG12_PLN_WR_24BIT); bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12DPU_PLN_SL_HOST, CG12_PLN_SL_24BIT); bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12APU_HPAGE, CG12_HPAGE_24BIT); bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12APU_HACCESS, CG12_HACCESS_24BIT); break; case 4: bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12DPU_PLN_RDMSK_HOST, CG12_PLN_RD_WID); bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12DPU_PLN_WRMSK_HOST, CG12_PLN_WR_WID); bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12DPU_PLN_SL_HOST, CG12_PLN_SL_WID); bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12APU_HPAGE, CG12_HPAGE_WID); bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12APU_HACCESS, CG12_HACCESS_WID); break; } } static void cgtwelve_write_wid(struct cgtwelve_softc *sc, int idx, uint8_t wid) { bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12_WSC_ADDR, idx << 16); bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12_WSC_DATA, ((uint32_t)wid) << 16); } static void cgtwelve_write_dac(struct cgtwelve_softc *sc, int idx, int r, int g, int b) { uint32_t lo = (idx & 0xff); uint32_t hi = (idx >> 8) & 0xff; lo |= lo << 8 | lo << 16; hi |= hi << 8 | hi << 16; bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12DAC_ADDR0, lo); bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12DAC_ADDR1, hi); bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12DAC_DATA, b << 16 | g << 8 | r); } static void cgtwelve_setup(struct cgtwelve_softc *sc, int depth) { int i, j; /* first let's put some stuff into the WID table */ cgtwelve_write_wid(sc, 0, CG12_WID_8_BIT); cgtwelve_write_wid(sc, 1, CG12_WID_24_BIT); /* a linear ramp for the gamma table */ for (i = 0; i < 256; i++) cgtwelve_write_dac(sc, i + 0x100, i, i, i); j = 0; /* rasops' ANSI colour map */ for (i = 0; i < 256; i++) { cgtwelve_write_dac(sc, i, rasops_cmap[j], rasops_cmap[j + 1], rasops_cmap[j + 2]); j += 3; } switch(depth) { case 1: /* setup the console */ /* first, make the overlay all opaque */ cgtwelve_select_ovl(sc, CG12_SEL_ENABLE); memset(sc->sc_fbaddr, 0xff, 0x20000); /* now write the right thing into the WID plane */ cgtwelve_select_ovl(sc, CG12_SEL_WID); memset(sc->sc_wids, 0, 0x100000); /* now clean the plane */ cgtwelve_select_ovl(sc, CG12_SEL_OVL); memset(sc->sc_fbaddr, 0, 0x20000); break; case 8: /* setup the 8bit fb */ /* * first clean the 8bit fb - for aesthetic reasons do it while * it's still not visible ( we hope... ) */ cgtwelve_select_ovl(sc, CG12_SEL_8BIT); memset(sc->sc_int, 0x00, 0x100000); /* now write the right thing into the WID plane */ cgtwelve_select_ovl(sc, CG12_SEL_WID); memset(sc->sc_wids, 0, 0x100000); /* hide the overlay */ cgtwelve_select_ovl(sc, CG12_SEL_ENABLE); memset(sc->sc_fbaddr, 0, 0x20000); /* now clean the plane */ cgtwelve_select_ovl(sc, CG12_SEL_OVL); memset(sc->sc_fbaddr, 0, 0x20000); /* and make sure we can write the 8bit fb */ cgtwelve_select_ovl(sc, CG12_SEL_8BIT); break; case 24: case 32: /* setup the 24bit fb for X */ /* * first clean the 24bit fb - for aesthetic reasons do it while * it's still not visible ( we hope... ) */ cgtwelve_select_ovl(sc, CG12_SEL_24BIT); memset(sc->sc_int, 0x80, 0x400000); /* now write the right thing into the WID plane */ cgtwelve_select_ovl(sc, CG12_SEL_WID); memset(sc->sc_wids, 1, 0x100000); /* hide the overlay */ cgtwelve_select_ovl(sc, CG12_SEL_ENABLE); memset(sc->sc_fbaddr, 0, 0x20000); /* now clean the plane */ cgtwelve_select_ovl(sc, CG12_SEL_OVL); memset(sc->sc_fbaddr, 0, 0x20000); /* and make sure we can write the 24bit fb */ cgtwelve_select_ovl(sc, CG12_SEL_24BIT); break; } } static void cgtwelve_init_screen(void *cookie, struct vcons_screen *scr, int existing, long *defattr) { struct cgtwelve_softc *sc = cookie; struct rasops_info *ri = &scr->scr_ri; #ifdef CG12_COLOR ri->ri_depth = 8; #else ri->ri_depth = 1; #endif ri->ri_width = sc->sc_width; ri->ri_height = sc->sc_height; ri->ri_stride = sc->sc_stride; ri->ri_flg = RI_CENTER; if (sc->sc_shadow == NULL) { #ifdef CG12_COLOR ri->ri_bits = sc->sc_int; #else ri->ri_bits = sc->sc_fbaddr; #endif scr->scr_flags |= VCONS_DONT_READ; } else { #ifdef CG12_COLOR ri->ri_hwbits = sc->sc_int; #else ri->ri_hwbits = sc->sc_fbaddr; #endif ri->ri_bits = sc->sc_shadow; } rasops_init(ri, 0, 0); #ifdef CG12_COLOR ri->ri_caps = WSSCREEN_REVERSE | WSSCREEN_WSCOLORS; #else ri->ri_caps = WSSCREEN_REVERSE; #endif rasops_reconfig(ri, ri->ri_height / ri->ri_font->fontheight, ri->ri_width / ri->ri_font->fontwidth); } static int cgtwelve_ioctl(void *v, void *vs, u_long cmd, void *data, int flag, struct lwp *l) { struct vcons_data *vd = v; struct cgtwelve_softc *sc = vd->cookie; struct wsdisplay_fbinfo *wdf; struct vcons_screen *ms = vd->active; switch (cmd) { case WSDISPLAYIO_GTYPE: *(u_int *)data = WSDISPLAY_TYPE_SUNCG12; return 0; case WSDISPLAYIO_GINFO: wdf = (void *)data; wdf->height = sc->sc_height; wdf->width = sc->sc_width; wdf->depth = 32; wdf->cmsize = 256; return 0; case FBIOGVIDEO: case WSDISPLAYIO_GVIDEO: *(int *)data = 1; return 0; case WSDISPLAYIO_SVIDEO: case FBIOSVIDEO: /* when we figure out how to do this... */ /*cgtwelve_set_video(sc, *(int *)data);*/ return 0; case WSDISPLAYIO_LINEBYTES: { int *ret = (int *)data; *ret = sc->sc_width << 2; } return 0; case WSDISPLAYIO_SMODE: { int new_mode = *(int*)data; if (new_mode != sc->sc_mode) { sc->sc_mode = new_mode; if (new_mode == WSDISPLAYIO_MODE_EMUL) { #ifdef CG12_COLOR cgtwelve_setup(sc, 8); #else cgtwelve_setup(sc, 1); #endif vcons_redraw_screen(ms); } else { cgtwelve_setup(sc, 32); } } } } return EPASSTHROUGH; } static paddr_t cgtwelve_mmap(void *v, void *vs, off_t offset, int prot) { struct vcons_data *vd = v; struct cgtwelve_softc *sc = vd->cookie; /* regular fb mapping at 0 */ if ((offset >= 0) && (offset < 0x400000)) { return bus_space_mmap(sc->sc_tag, sc->sc_paddr + CG12_OFF_INTEN, offset, prot, BUS_SPACE_MAP_LINEAR); } return -1; }