Annotation of sys/dev/sbus/zx.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: zx.c,v 1.13 2007/03/13 19:40:49 miod Exp $ */
! 2: /* $NetBSD: zx.c,v 1.5 2002/10/02 16:52:46 thorpej Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 2003, Miodrag Vallat.
! 6: * All rights reserved.
! 7: *
! 8: * Redistribution and use in source and binary forms, with or without
! 9: * modification, are permitted provided that the following conditions
! 10: * are met:
! 11: * 1. Redistributions of source code must retain the above copyright
! 12: * notice, this list of conditions and the following disclaimer.
! 13: * 2. Redistributions in binary form must reproduce the above copyright
! 14: * notice, this list of conditions and the following disclaimer in the
! 15: * documentation and/or other materials provided with the distribution.
! 16: *
! 17: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 18: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
! 19: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
! 20: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
! 21: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
! 22: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
! 23: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 24: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
! 25: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
! 26: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 27: * POSSIBILITY OF SUCH DAMAGE.
! 28: *
! 29: * Derived from NetBSD syssrc/sys/dev/sbus/zx.c under the following licence
! 30: * terms:
! 31: *
! 32: * Copyright (c) 2002 The NetBSD Foundation, Inc.
! 33: * All rights reserved.
! 34: *
! 35: * This code is derived from software contributed to The NetBSD Foundation
! 36: * by Andrew Doran.
! 37: *
! 38: * Redistribution and use in source and binary forms, with or without
! 39: * modification, are permitted provided that the following conditions
! 40: * are met:
! 41: * 1. Redistributions of source code must retain the above copyright
! 42: * notice, this list of conditions and the following disclaimer.
! 43: * 2. Redistributions in binary form must reproduce the above copyright
! 44: * notice, this list of conditions and the following disclaimer in the
! 45: * documentation and/or other materials provided with the distribution.
! 46: * 3. All advertising materials mentioning features or use of this software
! 47: * must display the following acknowledgement:
! 48: * This product includes software developed by the NetBSD
! 49: * Foundation, Inc. and its contributors.
! 50: * 4. Neither the name of The NetBSD Foundation nor the names of its
! 51: * contributors may be used to endorse or promote products derived
! 52: * from this software without specific prior written permission.
! 53: *
! 54: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
! 55: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
! 56: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
! 57: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
! 58: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
! 59: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
! 60: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
! 61: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
! 62: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
! 63: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 64: * POSSIBILITY OF SUCH DAMAGE.
! 65: */
! 66:
! 67: /*
! 68: * Driver for the Sun ZX display adapter. This would be called 'leo', but
! 69: * NetBSD/amiga already has a driver by that name. The XFree86 and Linux
! 70: * drivers were used as "living documentation" when writing this; thanks
! 71: * to the authors.
! 72: */
! 73:
! 74: #include <sys/param.h>
! 75: #include <sys/systm.h>
! 76: #include <sys/device.h>
! 77: #include <sys/ioctl.h>
! 78: #include <sys/malloc.h>
! 79: #include <sys/mman.h>
! 80: #include <sys/tty.h>
! 81: #include <sys/conf.h>
! 82:
! 83: #include <uvm/uvm_extern.h>
! 84:
! 85: #include <machine/autoconf.h>
! 86: #include <machine/bus.h>
! 87: #include <machine/cpu.h>
! 88: #include <machine/conf.h>
! 89:
! 90: #include <dev/wscons/wsconsio.h>
! 91: #include <dev/wscons/wsdisplayvar.h>
! 92: #include <dev/rasops/rasops.h>
! 93: #include <machine/fbvar.h>
! 94:
! 95: #include <dev/sbus/zxreg.h>
! 96: #include <dev/sbus/sbusvar.h>
! 97:
! 98: #define ZX_WID_SHARED_8 0
! 99: #define ZX_WID_SHARED_24 1
! 100: #define ZX_WID_DBL_8 2
! 101: #define ZX_WID_DBL_24 3
! 102:
! 103: /*
! 104: * Per-instance data.
! 105: */
! 106:
! 107: struct zx_cmap {
! 108: u_int8_t cm_red[256];
! 109: u_int8_t cm_green[256];
! 110: u_int8_t cm_blue[256];
! 111: };
! 112:
! 113: struct zx_softc {
! 114: struct sunfb sc_sunfb;
! 115:
! 116: bus_space_tag_t sc_bustag;
! 117: bus_addr_t sc_paddr;
! 118:
! 119: struct zx_cmap sc_cmap; /* shadow color map for overlay plane */
! 120:
! 121: volatile struct zx_command *sc_zc;
! 122: volatile struct zx_cross *sc_zx;
! 123: volatile struct zx_draw *sc_zd_ss0;
! 124: volatile struct zx_draw_ss1 *sc_zd_ss1;
! 125: volatile struct zx_cursor *sc_zcu;
! 126:
! 127: int sc_nscreens;
! 128: };
! 129:
! 130: int zx_ioctl(void *, u_long, caddr_t, int, struct proc *);
! 131: int zx_alloc_screen(void *, const struct wsscreen_descr *, void **,
! 132: int *, int *, long *);
! 133: void zx_free_screen(void *, void *);
! 134: int zx_show_screen(void *, void *, int, void (*)(void *, int, int), void *);
! 135: paddr_t zx_mmap(void *, off_t, int);
! 136: void zx_setcolor(void *, u_int, u_int8_t, u_int8_t, u_int8_t);
! 137: void zx_reset(struct zx_softc *, u_int);
! 138: void zx_burner(void *, u_int, u_int);
! 139:
! 140: struct wsdisplay_accessops zx_accessops = {
! 141: zx_ioctl,
! 142: zx_mmap,
! 143: zx_alloc_screen,
! 144: zx_free_screen,
! 145: zx_show_screen,
! 146: NULL, /* load_font */
! 147: NULL, /* scrollback */
! 148: NULL, /* getchar */
! 149: zx_burner
! 150: };
! 151:
! 152: /* Force 32-bit writes. */
! 153: #define SETREG(r, v) (*((volatile u_int32_t *)&r) = (v))
! 154:
! 155: #define ZX_STD_ROP (ZX_ROP_NEW | ZX_ATTR_WE_ENABLE | \
! 156: ZX_ATTR_OE_ENABLE | ZX_ATTR_FORCE_WID)
! 157:
! 158: #define ZX_BWIDTH 13
! 159: #define ZX_WWIDTH 11 /* word width */
! 160:
! 161: #define ZX_COORDS(x, y) ((x) | ((y) << ZX_WWIDTH))
! 162:
! 163: void zx_attach(struct device *, struct device *, void *);
! 164: int zx_match(struct device *, void *, void *);
! 165:
! 166: int zx_putcmap(struct zx_softc *);
! 167: void zx_copyrect(struct rasops_info *, int, int, int, int, int, int);
! 168: int zx_cross_loadwid(struct zx_softc *, u_int, u_int, u_int);
! 169: int zx_cross_wait(struct zx_softc *);
! 170: void zx_fillrect(struct rasops_info *, int, int, int, int, long, int);
! 171: int zx_intr(void *);
! 172: void zx_prom(void *);
! 173:
! 174: void zx_putchar(void *, int, int, u_int, long);
! 175: void zx_copycols(void *, int, int, int, int);
! 176: void zx_erasecols(void *, int, int, int, long);
! 177: void zx_copyrows(void *, int, int, int);
! 178: void zx_eraserows(void *, int, int, long);
! 179: void zx_do_cursor(struct rasops_info *);
! 180:
! 181: struct cfattach zx_ca = {
! 182: sizeof(struct zx_softc), zx_match, zx_attach
! 183: };
! 184:
! 185: struct cfdriver zx_cd = {
! 186: NULL, "zx", DV_DULL
! 187: };
! 188:
! 189: int
! 190: zx_match(struct device *parent, void *vcf, void *aux)
! 191: {
! 192: struct sbus_attach_args *sa = aux;
! 193:
! 194: if (strcmp(sa->sa_name, "SUNW,leo") == 0)
! 195: return (1);
! 196:
! 197: return (0);
! 198: }
! 199:
! 200: void
! 201: zx_attach(struct device *parent, struct device *self, void *args)
! 202: {
! 203: struct zx_softc *sc = (struct zx_softc *)self;
! 204: struct sbus_attach_args *sa = args;
! 205: struct rasops_info *ri;
! 206: bus_space_tag_t bt;
! 207: bus_space_handle_t bh;
! 208: int node, isconsole = 0;
! 209: const char *nam;
! 210:
! 211: bt = sa->sa_bustag;
! 212: ri = &sc->sc_sunfb.sf_ro;
! 213: node = sa->sa_node;
! 214:
! 215: /*
! 216: * Map the various parts of the card.
! 217: */
! 218: sc->sc_bustag = bt;
! 219: sc->sc_paddr = sbus_bus_addr(bt, sa->sa_slot, sa->sa_offset);
! 220:
! 221: if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + ZX_OFF_LC_SS0_USR,
! 222: sizeof(struct zx_command), BUS_SPACE_MAP_LINEAR, 0, &bh) != 0) {
! 223: printf(": couldn't map command registers\n");
! 224: return;
! 225: }
! 226: sc->sc_zc = (struct zx_command *)bus_space_vaddr(bt, bh);
! 227:
! 228: if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + ZX_OFF_LD_SS0,
! 229: sizeof(struct zx_draw), BUS_SPACE_MAP_LINEAR, 0, &bh) != 0) {
! 230: printf(": couldn't map ss0 drawing registers\n");
! 231: return;
! 232: }
! 233: sc->sc_zd_ss0 = (struct zx_draw *)bus_space_vaddr(bt, bh);
! 234:
! 235: if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + ZX_OFF_LD_SS1,
! 236: sizeof(struct zx_draw_ss1), BUS_SPACE_MAP_LINEAR, 0, &bh) != 0) {
! 237: printf(": couldn't map ss1 drawing registers\n");
! 238: return;
! 239: }
! 240: sc->sc_zd_ss1 = (struct zx_draw_ss1 *)bus_space_vaddr(bt, bh);
! 241:
! 242: if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + ZX_OFF_LX_CROSS,
! 243: sizeof(struct zx_cross), BUS_SPACE_MAP_LINEAR, 0, &bh) != 0) {
! 244: printf(": couldn't map cross registers\n");
! 245: return;
! 246: }
! 247: sc->sc_zx = (struct zx_cross *)bus_space_vaddr(bt, bh);
! 248:
! 249: if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + ZX_OFF_LX_CURSOR,
! 250: sizeof(struct zx_cursor), BUS_SPACE_MAP_LINEAR, 0, &bh) != 0) {
! 251: printf(": couldn't map cursor registers\n");
! 252: return;
! 253: }
! 254: sc->sc_zcu = (struct zx_cursor *)bus_space_vaddr(bt, bh);
! 255:
! 256: nam = getpropstring(node, "model");
! 257: if (*nam == '\0')
! 258: nam = sa->sa_name;
! 259: printf(": %s", nam);
! 260:
! 261: isconsole = node == fbnode;
! 262:
! 263: /*
! 264: * The console is using the 8-bit overlay plane, while the prom
! 265: * will correctly report 32 bit depth.
! 266: * The following is an equivalent for
! 267: * fb_setsize(&sc->sc_sunfb, 8, 1152, 900, node, ca->ca_bustype);
! 268: * forcing the depth value not to be overwritten.
! 269: * Furthermore, the linebytes value is in fact 8192 bytes.
! 270: */
! 271: sc->sc_sunfb.sf_depth = 8;
! 272: sc->sc_sunfb.sf_width = getpropint(node, "width", 1152);
! 273: sc->sc_sunfb.sf_height = getpropint(node, "height", 900);
! 274: sc->sc_sunfb.sf_linebytes = 1 << ZX_BWIDTH;
! 275: sc->sc_sunfb.sf_fbsize = sc->sc_sunfb.sf_height << ZX_BWIDTH;
! 276:
! 277: printf(", %dx%d\n", sc->sc_sunfb.sf_width, sc->sc_sunfb.sf_height);
! 278:
! 279: if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + ZX_OFF_SS0,
! 280: round_page(sc->sc_sunfb.sf_fbsize), BUS_SPACE_MAP_LINEAR,
! 281: 0, &bh) != 0) {
! 282: printf("%s: couldn't map video memory\n", self->dv_xname);
! 283: return;
! 284: }
! 285: ri->ri_bits = bus_space_vaddr(bt, bh);
! 286: ri->ri_hw = sc;
! 287:
! 288: fbwscons_init(&sc->sc_sunfb, isconsole ? 0 : RI_CLEAR);
! 289:
! 290: /*
! 291: * Watch out! rasops_init() invoked via fbwscons_init() did not
! 292: * compute ri_bits correctly when centering the display, because
! 293: * it has been tricked with the low depth value.
! 294: * Recompute now.
! 295: */
! 296: ri->ri_emustride = ri->ri_emuwidth * 4;
! 297: ri->ri_delta = ri->ri_stride - ri->ri_emustride;
! 298: ri->ri_pelbytes = 4;
! 299: ri->ri_xscale = ri->ri_font->fontwidth * 4;
! 300: ri->ri_bits = ri->ri_origbits;
! 301: ri->ri_bits += (((ri->ri_width * 4) - ri->ri_emustride) >> 1) & ~3;
! 302: ri->ri_bits += ((ri->ri_height - ri->ri_emuheight) >> 1) *
! 303: ri->ri_stride;
! 304: ri->ri_yorigin = (int)(ri->ri_bits - ri->ri_origbits)
! 305: / ri->ri_stride;
! 306: ri->ri_xorigin = (((int)(ri->ri_bits - ri->ri_origbits)
! 307: % ri->ri_stride) / 4);
! 308:
! 309: ri->ri_ops.copyrows = zx_copyrows;
! 310: ri->ri_ops.copycols = zx_copycols;
! 311: ri->ri_ops.eraserows = zx_eraserows;
! 312: ri->ri_ops.erasecols = zx_erasecols;
! 313: ri->ri_ops.putchar = zx_putchar;
! 314: ri->ri_do_cursor = zx_do_cursor;
! 315:
! 316: if (isconsole) {
! 317: /* zx_reset() below will clear screen, so restart at 1st row */
! 318: fbwscons_console_init(&sc->sc_sunfb, 0);
! 319: }
! 320:
! 321: /* reset cursor & frame buffer controls */
! 322: zx_reset(sc, WSDISPLAYIO_MODE_EMUL);
! 323:
! 324: /* enable video */
! 325: zx_burner(sc, 1, 0);
! 326:
! 327: fbwscons_attach(&sc->sc_sunfb, &zx_accessops, isconsole);
! 328: }
! 329:
! 330: int
! 331: zx_ioctl(void *dev, u_long cmd, caddr_t data, int flags, struct proc *p)
! 332: {
! 333: struct zx_softc *sc = dev;
! 334: struct wsdisplay_fbinfo *wdf;
! 335:
! 336: /*
! 337: * Note that, although the emulation (text) mode is running in
! 338: * a 8-bit plane, we advertize the frame buffer as the full-blown
! 339: * 32-bit beast it is.
! 340: */
! 341: switch (cmd) {
! 342: case WSDISPLAYIO_GTYPE:
! 343: *(u_int *)data = WSDISPLAY_TYPE_SUN24;
! 344: break;
! 345: case WSDISPLAYIO_GINFO:
! 346: wdf = (struct wsdisplay_fbinfo *)data;
! 347: wdf->height = sc->sc_sunfb.sf_height;
! 348: wdf->width = sc->sc_sunfb.sf_width;
! 349: wdf->depth = 32;
! 350: wdf->cmsize = 0;
! 351: break;
! 352: case WSDISPLAYIO_GETSUPPORTEDDEPTH:
! 353: *(u_int *)data = WSDISPLAYIO_DEPTH_24_32;
! 354: break;
! 355: case WSDISPLAYIO_LINEBYTES:
! 356: *(u_int *)data = sc->sc_sunfb.sf_linebytes;
! 357: break;
! 358:
! 359: case WSDISPLAYIO_GETCMAP:
! 360: case WSDISPLAYIO_PUTCMAP:
! 361: break;
! 362:
! 363: case WSDISPLAYIO_SMODE:
! 364: zx_reset(sc, *(u_int *)data);
! 365: break;
! 366:
! 367: case WSDISPLAYIO_SVIDEO:
! 368: case WSDISPLAYIO_GVIDEO:
! 369: break;
! 370:
! 371: default:
! 372: return (-1);
! 373: }
! 374:
! 375: return (0);
! 376: }
! 377:
! 378: int
! 379: zx_alloc_screen(void *v, const struct wsscreen_descr *type, void **cookiep,
! 380: int *curxp, int *curyp, long *attrp)
! 381: {
! 382: struct zx_softc *sc = v;
! 383:
! 384: if (sc->sc_nscreens > 0)
! 385: return (ENOMEM);
! 386:
! 387: *cookiep = &sc->sc_sunfb.sf_ro;
! 388: *curyp = 0;
! 389: *curxp = 0;
! 390: sc->sc_sunfb.sf_ro.ri_ops.alloc_attr(&sc->sc_sunfb.sf_ro,
! 391: WSCOL_BLACK, WSCOL_WHITE, WSATTR_WSCOLORS, attrp);
! 392: sc->sc_nscreens++;
! 393: return (0);
! 394: }
! 395:
! 396: void
! 397: zx_free_screen(void *v, void *cookie)
! 398: {
! 399: struct zx_softc *sc = v;
! 400:
! 401: sc->sc_nscreens--;
! 402: }
! 403:
! 404: int
! 405: zx_show_screen(void *v, void *cookie, int waitok, void (*cb)(void *, int, int),
! 406: void *cbarg)
! 407: {
! 408: return (0);
! 409: }
! 410:
! 411: /*
! 412: * Return the address that would map the given device at the given
! 413: * offset, allowing for the given protection, or return -1 for error.
! 414: */
! 415: paddr_t
! 416: zx_mmap(void *v, off_t offset, int prot)
! 417: {
! 418: struct zx_softc *sc = v;
! 419:
! 420: if (offset & PGOFSET)
! 421: return (-1);
! 422:
! 423: /* Allow mapping as a dumb framebuffer from offset 0 */
! 424: if (offset >= 0 && offset < sc->sc_sunfb.sf_fbsize) {
! 425: return (bus_space_mmap(sc->sc_bustag, sc->sc_paddr,
! 426: ZX_OFF_SS0 + offset, prot, BUS_SPACE_MAP_LINEAR));
! 427: }
! 428:
! 429: return (-1);
! 430: }
! 431:
! 432: void
! 433: zx_setcolor(void *v, u_int index, u_int8_t r, u_int8_t g, u_int8_t b)
! 434: {
! 435: struct zx_softc *sc = v;
! 436:
! 437: sc->sc_cmap.cm_red[index] = r;
! 438: sc->sc_cmap.cm_green[index] = g;
! 439: sc->sc_cmap.cm_blue[index] = b;
! 440: }
! 441:
! 442: void
! 443: zx_reset(struct zx_softc *sc, u_int mode)
! 444: {
! 445: volatile struct zx_draw *zd;
! 446: volatile struct zx_command *zc;
! 447: u_int32_t i;
! 448: const u_char *color;
! 449: u_int8_t *r, *g, *b;
! 450:
! 451: zd = sc->sc_zd_ss0;
! 452: zc = sc->sc_zc;
! 453:
! 454: if (mode == WSDISPLAYIO_MODE_EMUL) {
! 455: /* Back from X11 to emulation mode, or first reset */
! 456: zx_cross_loadwid(sc, ZX_WID_DBL_8, 0, 0x2c0);
! 457: zx_cross_loadwid(sc, ZX_WID_DBL_8, 1, 0x30);
! 458: zx_cross_loadwid(sc, ZX_WID_DBL_8, 2, 0x20);
! 459: zx_cross_loadwid(sc, ZX_WID_DBL_24, 1, 0x30);
! 460:
! 461: i = sc->sc_zd_ss1->zd_misc;
! 462: i |= ZX_SS1_MISC_ENABLE;
! 463: SETREG(sc->sc_zd_ss1->zd_misc, i);
! 464:
! 465: /*
! 466: * XXX
! 467: * If zc_fill is not set to that value, there will be black
! 468: * bars left in the margins. But then with this value, the
! 469: * screen gets cleared. Go figure.
! 470: */
! 471: SETREG(zd->zd_wid, 0xffffffff);
! 472: SETREG(zd->zd_wmask, 0xffff);
! 473: SETREG(zd->zd_vclipmin, 0);
! 474: SETREG(zd->zd_vclipmax, (sc->sc_sunfb.sf_width - 1) |
! 475: ((sc->sc_sunfb.sf_height - 1) << 16));
! 476: SETREG(zd->zd_fg, 0);
! 477: SETREG(zd->zd_planemask, 0xff000000);
! 478: SETREG(zd->zd_rop, ZX_STD_ROP);
! 479: SETREG(zd->zd_widclip, 0);
! 480:
! 481: SETREG(zc->zc_extent, ZX_COORDS(sc->sc_sunfb.sf_width - 1,
! 482: sc->sc_sunfb.sf_height - 1));
! 483: SETREG(zc->zc_addrspace, ZX_ADDRSPC_FONT_OBGR);
! 484: SETREG(zc->zc_fill, ZX_COORDS(0, 0) | ZX_EXTENT_DIR_BACKWARDS);
! 485: SETREG(zc->zc_fontt, 0);
! 486:
! 487: while ((zc->zc_csr & ZX_CSR_BLT_BUSY) != 0)
! 488: ;
! 489:
! 490: /*
! 491: * Initialize the 8-bit colormap
! 492: */
! 493: r = sc->sc_cmap.cm_red;
! 494: g = sc->sc_cmap.cm_green;
! 495: b = sc->sc_cmap.cm_blue;
! 496: color = rasops_cmap;
! 497: for (i = 0; i < 256; i++) {
! 498: *r++ = *color++;
! 499: *g++ = *color++;
! 500: *b++ = *color++;
! 501: }
! 502: fbwscons_setcolormap(&sc->sc_sunfb, zx_setcolor);
! 503: zx_putcmap(sc);
! 504: } else {
! 505: /* Starting X11 - switch to 24bit WID */
! 506: SETREG(zd->zd_wid, 1);
! 507: SETREG(zd->zd_widclip, 0);
! 508: SETREG(zd->zd_wmask, 0xffff);
! 509: SETREG(zd->zd_planemask, 0x00ffffff);
! 510: SETREG(zc->zc_extent, ZX_COORDS(sc->sc_sunfb.sf_width - 1,
! 511: sc->sc_sunfb.sf_height - 1));
! 512: SETREG(zc->zc_fill, 0);
! 513: while ((zc->zc_csr & ZX_CSR_BLT_BUSY) != 0)
! 514: ;
! 515:
! 516: SETREG(zc->zc_addrspace, ZX_ADDRSPC_OBGR);
! 517: SETREG(zd->zd_rop, ZX_ATTR_RGBE_ENABLE |
! 518: ZX_ROP_NEW /* | ZX_ATTR_FORCE_WID */);
! 519: }
! 520: }
! 521:
! 522: int
! 523: zx_cross_wait(struct zx_softc *sc)
! 524: {
! 525: volatile struct zx_cross *zx;
! 526: int i;
! 527:
! 528: zx = sc->sc_zx;
! 529:
! 530: for (i = 300000; i != 0; i--) {
! 531: if ((zx->zx_csr & ZX_CROSS_CSR_PROGRESS) == 0)
! 532: break;
! 533: DELAY(1);
! 534: }
! 535:
! 536: if (i == 0)
! 537: printf("%s: zx_cross_wait: timed out\n",
! 538: sc->sc_sunfb.sf_dev.dv_xname);
! 539:
! 540: return (i);
! 541: }
! 542:
! 543: int
! 544: zx_cross_loadwid(struct zx_softc *sc, u_int type, u_int index, u_int value)
! 545: {
! 546: volatile struct zx_cross *zx;
! 547: u_int tmp;
! 548:
! 549: zx = sc->sc_zx;
! 550: SETREG(zx->zx_type, ZX_CROSS_TYPE_WID);
! 551:
! 552: if (!zx_cross_wait(sc))
! 553: return (1);
! 554:
! 555: if (type == ZX_WID_DBL_8)
! 556: tmp = (index & 0x0f) + 0x40;
! 557: else if (type == ZX_WID_DBL_24)
! 558: tmp = index & 0x3f;
! 559:
! 560: SETREG(zx->zx_type, 0x5800 + tmp);
! 561: SETREG(zx->zx_value, value);
! 562: SETREG(zx->zx_type, ZX_CROSS_TYPE_WID);
! 563: SETREG(zx->zx_csr, ZX_CROSS_CSR_UNK | ZX_CROSS_CSR_UNK2);
! 564:
! 565: return (0);
! 566: }
! 567:
! 568: int
! 569: zx_putcmap(struct zx_softc *sc)
! 570: {
! 571: volatile struct zx_cross *zx;
! 572: u_int32_t i;
! 573: u_int8_t *r, *g, *b;
! 574:
! 575: zx = sc->sc_zx;
! 576:
! 577: SETREG(zx->zx_type, ZX_CROSS_TYPE_CLUT0);
! 578: if (!zx_cross_wait(sc))
! 579: return (1);
! 580:
! 581: SETREG(zx->zx_type, ZX_CROSS_TYPE_CLUTDATA);
! 582:
! 583: r = sc->sc_cmap.cm_red;
! 584: g = sc->sc_cmap.cm_green;
! 585: b = sc->sc_cmap.cm_blue;
! 586: for (i = 0; i < 256; i++) {
! 587: SETREG(zx->zx_value, *r++ | (*g++ << 8) | (*b++ << 16));
! 588: }
! 589:
! 590: SETREG(zx->zx_type, ZX_CROSS_TYPE_CLUT0);
! 591: i = zx->zx_csr;
! 592: i = i | ZX_CROSS_CSR_UNK | ZX_CROSS_CSR_UNK2;
! 593: SETREG(zx->zx_csr, i);
! 594: return (0);
! 595: }
! 596:
! 597: void
! 598: zx_burner(void *v, u_int on, u_int flags)
! 599: {
! 600: struct zx_softc *sc = v;
! 601: volatile struct zx_cross *zx;
! 602: u_int32_t i;
! 603:
! 604: zx = sc->sc_zx;
! 605:
! 606: SETREG(zx->zx_type, ZX_CROSS_TYPE_VIDEO);
! 607: i = zx->zx_csr;
! 608: if (on) {
! 609: i |= ZX_CROSS_CSR_ENABLE;
! 610: } else {
! 611: i &= ~ZX_CROSS_CSR_ENABLE;
! 612: }
! 613: SETREG(zx->zx_csr, i);
! 614: }
! 615:
! 616: void
! 617: zx_fillrect(struct rasops_info *ri, int x, int y, int w, int h, long attr,
! 618: int rop)
! 619: {
! 620: struct zx_softc *sc;
! 621: volatile struct zx_command *zc;
! 622: volatile struct zx_draw *zd;
! 623: int fg, bg;
! 624:
! 625: sc = ri->ri_hw;
! 626: zc = sc->sc_zc;
! 627: zd = sc->sc_zd_ss0;
! 628:
! 629: ri->ri_ops.unpack_attr(ri, attr, &fg, &bg, NULL);
! 630: x = x * ri->ri_font->fontwidth + ri->ri_xorigin;
! 631: y = y * ri->ri_font->fontheight + ri->ri_yorigin;
! 632: w = ri->ri_font->fontwidth * w - 1;
! 633: h = ri->ri_font->fontheight * h - 1;
! 634:
! 635: while ((zc->zc_csr & ZX_CSR_BLT_BUSY) != 0)
! 636: ;
! 637:
! 638: SETREG(zd->zd_rop, rop);
! 639: SETREG(zd->zd_fg, ri->ri_devcmap[bg] << 24);
! 640: SETREG(zc->zc_extent, ZX_COORDS(w, h));
! 641: SETREG(zc->zc_fill, ZX_COORDS(x, y) | ZX_EXTENT_DIR_BACKWARDS);
! 642: }
! 643:
! 644: void
! 645: zx_copyrect(struct rasops_info *ri, int sx, int sy, int dx, int dy, int w,
! 646: int h)
! 647: {
! 648: struct zx_softc *sc;
! 649: volatile struct zx_command *zc;
! 650: volatile struct zx_draw *zd;
! 651: int dir;
! 652:
! 653: sc = ri->ri_hw;
! 654: zc = sc->sc_zc;
! 655: zd = sc->sc_zd_ss0;
! 656:
! 657: sx = sx * ri->ri_font->fontwidth + ri->ri_xorigin;
! 658: sy = sy * ri->ri_font->fontheight + ri->ri_yorigin;
! 659: dx = dx * ri->ri_font->fontwidth + ri->ri_xorigin;
! 660: dy = dy * ri->ri_font->fontheight + ri->ri_yorigin;
! 661: w = w * ri->ri_font->fontwidth - 1;
! 662: h = h * ri->ri_font->fontheight - 1;
! 663:
! 664: if (sy < dy || sx < dx) {
! 665: dir = ZX_EXTENT_DIR_BACKWARDS;
! 666: sx += w;
! 667: sy += h;
! 668: dx += w;
! 669: dy += h;
! 670: } else
! 671: dir = ZX_EXTENT_DIR_FORWARDS;
! 672:
! 673: while ((zc->zc_csr & ZX_CSR_BLT_BUSY) != 0)
! 674: ;
! 675:
! 676: SETREG(zd->zd_rop, ZX_STD_ROP);
! 677: SETREG(zc->zc_extent, ZX_COORDS(w, h) | dir);
! 678: SETREG(zc->zc_src, ZX_COORDS(sx, sy));
! 679: SETREG(zc->zc_copy, ZX_COORDS(dx, dy));
! 680: }
! 681:
! 682: void
! 683: zx_do_cursor(struct rasops_info *ri)
! 684: {
! 685:
! 686: zx_fillrect(ri, ri->ri_ccol, ri->ri_crow, 1, 1, WSCOL_BLACK << 16,
! 687: ZX_ROP_NEW_XOR_OLD | ZX_ATTR_WE_ENABLE | ZX_ATTR_OE_ENABLE |
! 688: ZX_ATTR_FORCE_WID);
! 689: }
! 690:
! 691: void
! 692: zx_erasecols(void *cookie, int row, int col, int num, long attr)
! 693: {
! 694: struct rasops_info *ri;
! 695:
! 696: ri = (struct rasops_info *)cookie;
! 697:
! 698: zx_fillrect(ri, col, row, num, 1, attr, ZX_STD_ROP);
! 699: }
! 700:
! 701: void
! 702: zx_eraserows(void *cookie, int row, int num, long attr)
! 703: {
! 704: struct rasops_info *ri;
! 705: struct zx_softc *sc;
! 706: volatile struct zx_command *zc;
! 707: volatile struct zx_draw *zd;
! 708: int fg, bg;
! 709:
! 710: ri = (struct rasops_info *)cookie;
! 711:
! 712: if (num == ri->ri_rows && (ri->ri_flg & RI_FULLCLEAR)) {
! 713: sc = ri->ri_hw;
! 714: zc = sc->sc_zc;
! 715: zd = sc->sc_zd_ss0;
! 716:
! 717: ri->ri_ops.unpack_attr(cookie, attr, &fg, &bg, NULL);
! 718:
! 719: while ((zc->zc_csr & ZX_CSR_BLT_BUSY) != 0)
! 720: ;
! 721:
! 722: SETREG(zd->zd_rop, ZX_STD_ROP);
! 723: SETREG(zd->zd_fg, ri->ri_devcmap[bg] << 24);
! 724: SETREG(zc->zc_extent,
! 725: ZX_COORDS(ri->ri_width - 1, ri->ri_height - 1));
! 726: SETREG(zc->zc_fill, ZX_COORDS(0, 0) | ZX_EXTENT_DIR_BACKWARDS);
! 727: } else
! 728: zx_fillrect(ri, 0, row, ri->ri_cols, num, attr, ZX_STD_ROP);
! 729: }
! 730:
! 731: void
! 732: zx_copyrows(void *cookie, int src, int dst, int num)
! 733: {
! 734: struct rasops_info *ri;
! 735:
! 736: ri = (struct rasops_info *)cookie;
! 737:
! 738: zx_copyrect(ri, 0, src, 0, dst, ri->ri_cols, num);
! 739: }
! 740:
! 741: void
! 742: zx_copycols(void *cookie, int row, int src, int dst, int num)
! 743: {
! 744: struct rasops_info *ri;
! 745:
! 746: ri = (struct rasops_info *)cookie;
! 747:
! 748: zx_copyrect(ri, src, row, dst, row, num, 1);
! 749: }
! 750:
! 751: void
! 752: zx_putchar(void *cookie, int row, int col, u_int uc, long attr)
! 753: {
! 754: struct rasops_info *ri;
! 755: struct zx_softc *sc;
! 756: struct wsdisplay_font *font;
! 757: volatile struct zx_command *zc;
! 758: volatile struct zx_draw *zd;
! 759: volatile u_int32_t *dp;
! 760: u_int8_t *fb;
! 761: int fs, i, fg, bg, ul;
! 762:
! 763: ri = (struct rasops_info *)cookie;
! 764: font = ri->ri_font;
! 765: ri->ri_ops.unpack_attr(cookie, attr, &fg, &bg, &ul);
! 766: fg = ri->ri_devcmap[fg];
! 767: bg = ri->ri_devcmap[bg];
! 768:
! 769: dp = (volatile u_int32_t *)ri->ri_bits +
! 770: ZX_COORDS(col * font->fontwidth, row * font->fontheight);
! 771:
! 772: if (uc == ' ') {
! 773: zx_fillrect(ri, col, row, 1, 1, attr, ZX_STD_ROP);
! 774: if (ul == 0)
! 775: return;
! 776:
! 777: dp += font->fontheight << ZX_WWIDTH;
! 778:
! 779: while ((zc->zc_csr & ZX_CSR_BLT_BUSY) != 0)
! 780: ;
! 781:
! 782: SETREG(zd->zd_rop, ZX_STD_ROP);
! 783: SETREG(zd->zd_fg, fg << 24);
! 784: SETREG(zd->zd_bg, bg << 24);
! 785: SETREG(zc->zc_fontmsk, 0xffffffff << (32 - font->fontwidth));
! 786: } else {
! 787: sc = ri->ri_hw;
! 788: zc = sc->sc_zc;
! 789: zd = sc->sc_zd_ss0;
! 790:
! 791: fb = (u_int8_t *)font->data + (uc - font->firstchar) *
! 792: ri->ri_fontscale;
! 793: fs = font->stride;
! 794:
! 795: while ((zc->zc_csr & ZX_CSR_BLT_BUSY) != 0)
! 796: ;
! 797:
! 798: SETREG(zd->zd_rop, ZX_STD_ROP);
! 799: SETREG(zd->zd_fg, fg << 24);
! 800: SETREG(zd->zd_bg, bg << 24);
! 801: SETREG(zc->zc_fontmsk, 0xffffffff << (32 - font->fontwidth));
! 802:
! 803: if (font->fontwidth <= 8) {
! 804: for (i = font->fontheight; i != 0;
! 805: i--, dp += 1 << ZX_WWIDTH) {
! 806: *dp = *fb << 24;
! 807: fb += fs;
! 808: }
! 809: } else {
! 810: for (i = font->fontheight; i != 0;
! 811: i--, dp += 1 << ZX_WWIDTH) {
! 812: *dp = *((u_int16_t *)fb) << 16;
! 813: fb += fs;
! 814: }
! 815: }
! 816: }
! 817:
! 818: /* underline */
! 819: if (ul) {
! 820: dp -= 2 << ZX_WWIDTH;
! 821: *dp = 0xffffffff;
! 822: }
! 823: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to zx.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / sbus