Annotation of sys/dev/sbus/tvtwo.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: tvtwo.c,v 1.11 2007/03/13 19:40:49 miod Exp $ */
! 2: /*
! 3: * Copyright (c) 2003, 2006, Miodrag Vallat.
! 4: * All rights reserved.
! 5: *
! 6: * Redistribution and use in source and binary forms, with or without
! 7: * modification, are permitted provided that the following conditions
! 8: * are met:
! 9: * 1. Redistributions of source code must retain the above copyright
! 10: * notice, this list of conditions and the following disclaimer.
! 11: * 2. Redistributions in binary form must reproduce the above copyright
! 12: * notice, this list of conditions and the following disclaimer in the
! 13: * documentation and/or other materials provided with the distribution.
! 14: *
! 15: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 16: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
! 17: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
! 18: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
! 19: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
! 20: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
! 21: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 22: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
! 23: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
! 24: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 25: * POSSIBILITY OF SUCH DAMAGE.
! 26: *
! 27: */
! 28:
! 29: /*
! 30: * Driver for the Parallax XVideo and PowerVideo graphics boards.
! 31: *
! 32: * Some details about these board are available at:
! 33: * http://www.jlw.com/~woolsey/parallax/support/developers/xvideotech.html
! 34: */
! 35:
! 36: /*
! 37: * The Parallax XVideo series frame buffers are 8/24-bit accelerated
! 38: * frame buffers, with hardware MPEG capabilities using a CCube chipset.
! 39: */
! 40:
! 41: /*
! 42: * Currently, this driver can only handle the 8-bit and 24-bit planes of the
! 43: * frame buffer, in an unaccelerated mode.
! 44: *
! 45: * TODO:
! 46: * - nvram handling
! 47: * - use the accelerator
! 48: * - interface to the c^3
! 49: */
! 50:
! 51: #include <sys/param.h>
! 52: #include <sys/systm.h>
! 53: #include <sys/buf.h>
! 54: #include <sys/device.h>
! 55: #include <sys/ioctl.h>
! 56: #include <sys/mman.h>
! 57: #include <sys/conf.h>
! 58:
! 59: #include <uvm/uvm_extern.h>
! 60:
! 61: #include <machine/autoconf.h>
! 62: #include <machine/bus.h>
! 63: #include <machine/pmap.h>
! 64: #include <machine/cpu.h>
! 65: #include <machine/conf.h>
! 66:
! 67: #include <dev/wscons/wsconsio.h>
! 68: #include <dev/wscons/wsdisplayvar.h>
! 69: #include <dev/rasops/rasops.h>
! 70: #include <machine/fbvar.h>
! 71:
! 72: #include <dev/sbus/sbusvar.h>
! 73:
! 74: /*
! 75: * The memory layout of the board is as follows:
! 76: *
! 77: * PROM0 000000 - 00ffff
! 78: * overlay plane 010000 - 037fff
! 79: * registers 040000 - 0404d0
! 80: * CCube 050000 - 05ffff
! 81: * 8-bit plane 080000 - 17ffff
! 82: * 24-bit plane 200000 - 6fffff
! 83: * PROM1 7f0000 - 7fffff
! 84: *
! 85: * Older XVideo provide two sets of SBus registers:
! 86: * R0 040000 - 040800
! 87: * R1 080000 - 17d200
! 88: * While the more recent revisions provide only one register:
! 89: * R0 000000 - 7fffff
! 90: *
! 91: * We currently refuse to attach to the old version because mapping
! 92: * things requires us to play with the sbus register ranges, and I
! 93: * don't want to play this game without the hardware at hand -- miod
! 94: */
! 95:
! 96: #define PX_PROM0_OFFSET 0x000000
! 97: #define PX_OVERLAY_OFFSET 0x010000
! 98: #define PX_REG_OFFSET 0x040000
! 99: #define PX_CCUBE_OFFSET 0x050000
! 100: #define PX_PLANE8_OFFSET 0x080000
! 101: #define PX_PLANE24_OFFSET 0x200000
! 102: #define PX_PROM1_OFFSET 0x7f0000
! 103:
! 104: /*
! 105: * Partial registers layout
! 106: */
! 107:
! 108: #define PX_REG_DISPKLUDGE 0x00b8 /* write only */
! 109: #define DISPKLUDGE_DEFAULT 0xc41f
! 110: #define DISPKLUDGE_BLANK (1 << 12)
! 111: #define DISPKLUDGE_SYNC (1 << 13)
! 112:
! 113: #define PX_REG_BT463_RED 0x0480
! 114: #define PX_REG_BT463_GREEN 0x0490
! 115: #define PX_REG_BT463_BLUE 0x04a0
! 116: #define PX_REG_BT463_ALL 0x04b0
! 117:
! 118: #define PX_REG_SIZE 0x04d0
! 119:
! 120:
! 121: /* per-display variables */
! 122: struct tvtwo_softc {
! 123: struct sunfb sc_sunfb; /* common base device */
! 124:
! 125: bus_space_tag_t sc_bustag;
! 126: bus_addr_t sc_paddr;
! 127:
! 128: volatile u_int8_t *sc_m8;
! 129: volatile u_int8_t *sc_m24;
! 130: volatile u_int8_t *sc_regs;
! 131:
! 132: int sc_nscreens;
! 133: };
! 134:
! 135: int tvtwo_ioctl(void *, u_long, caddr_t, int, struct proc *);
! 136: int tvtwo_alloc_screen(void *, const struct wsscreen_descr *, void **,
! 137: int *, int *, long *);
! 138: void tvtwo_free_screen(void *, void *);
! 139: int tvtwo_show_screen(void *, void *, int, void (*cb)(void *, int, int),
! 140: void *);
! 141: paddr_t tvtwo_mmap(void *, off_t, int);
! 142: void tvtwo_burner(void *, u_int, u_int);
! 143:
! 144: struct wsdisplay_accessops tvtwo_accessops = {
! 145: tvtwo_ioctl,
! 146: tvtwo_mmap,
! 147: tvtwo_alloc_screen,
! 148: tvtwo_free_screen,
! 149: tvtwo_show_screen,
! 150: NULL, /* load_font */
! 151: NULL, /* scrollback */
! 152: NULL, /* getchar */
! 153: tvtwo_burner,
! 154: };
! 155:
! 156: void tvtwo_directcmap(struct tvtwo_softc *);
! 157: static __inline__
! 158: void tvtwo_ramdac_wraddr(struct tvtwo_softc *, u_int32_t);
! 159: void tvtwo_reset(struct tvtwo_softc *, u_int);
! 160: void tvtwo_setcolor(void *, u_int, u_int8_t, u_int8_t, u_int8_t);
! 161:
! 162: int tvtwomatch(struct device *, void *, void *);
! 163: void tvtwoattach(struct device *, struct device *, void *);
! 164:
! 165: struct cfattach tvtwo_ca = {
! 166: sizeof(struct tvtwo_softc), tvtwomatch, tvtwoattach
! 167: };
! 168:
! 169: struct cfdriver tvtwo_cd = {
! 170: NULL, "tvtwo", DV_DULL
! 171: };
! 172:
! 173: /*
! 174: * Default frame buffer resolution, depending upon the "freqcode"
! 175: */
! 176: #define NFREQCODE 5
! 177: const int defwidth[NFREQCODE] = { 1152, 1152, 1152, 1024, 640 };
! 178: const int defheight[NFREQCODE] = { 900, 900, 900, 768, 480 };
! 179:
! 180: /*
! 181: * Match an XVideo or PowerVideo card.
! 182: */
! 183: int
! 184: tvtwomatch(struct device *parent, void *vcf, void *aux)
! 185: {
! 186: struct sbus_attach_args *sa = aux;
! 187:
! 188: if (strcmp(sa->sa_name, "PGI,tvtwo") == 0 ||
! 189: strcmp(sa->sa_name, "PGI,tvthree") == 0)
! 190: return (1);
! 191:
! 192: return (0);
! 193: }
! 194:
! 195: /*
! 196: * Attach a display.
! 197: */
! 198: void
! 199: tvtwoattach(struct device *parent, struct device *self, void *args)
! 200: {
! 201: struct tvtwo_softc *sc = (struct tvtwo_softc *)self;
! 202: struct sbus_attach_args *sa = args;
! 203: bus_space_tag_t bt;
! 204: bus_space_handle_t bh;
! 205: int node, width, height, freqcode;
! 206: int isconsole;
! 207: char *freqstring;
! 208:
! 209: bt = sa->sa_bustag;
! 210: node = sa->sa_node;
! 211:
! 212: printf(": %s", getpropstring(node, "model"));
! 213: printf(", revision %s\n", getpropstring(node, "revision"));
! 214:
! 215: /* We do not handle older boards yet. */
! 216: if (sa->sa_nreg != 1) {
! 217: printf("%s: old-style boards with %d registers are not supported\n"
! 218: "%s: please report this to <sparc@openbsd.org>\n",
! 219: self->dv_xname, sa->sa_nreg,
! 220: self->dv_xname);
! 221: return;
! 222: }
! 223:
! 224: isconsole = node == fbnode;
! 225:
! 226: /* Map registers. */
! 227: sc->sc_bustag = bt;
! 228: if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + PX_REG_OFFSET,
! 229: PX_REG_SIZE, BUS_SPACE_MAP_LINEAR, 0, &bh) != 0) {
! 230: printf("%s: couldn't map registers\n", self->dv_xname);
! 231: return;
! 232: }
! 233: sc->sc_regs = bus_space_vaddr(bt, bh);
! 234:
! 235: /* Compute framebuffer size. */
! 236: freqstring = getpropstring(node, "freqcode");
! 237: freqcode = (int)*freqstring;
! 238: if (freqcode == 'g') {
! 239: width = height = 1024;
! 240: } else {
! 241: if (freqcode < '1' || freqcode > '6')
! 242: freqcode = 0;
! 243: else
! 244: freqcode -= '1';
! 245: width = defwidth[freqcode];
! 246: height = defheight[freqcode];
! 247: }
! 248:
! 249: width = getpropint(node, "hres", width);
! 250: height = getpropint(node, "vres", height);
! 251:
! 252: /*
! 253: * Since the depth property is usually missing, we could do
! 254: * fb_setsize(&sc->sc_sunfb, 8, width, height, node, 0);
! 255: * but for safety in case it would exist and be set to 32, do it
! 256: * manually...
! 257: */
! 258: sc->sc_sunfb.sf_depth = 8;
! 259: sc->sc_sunfb.sf_width = width;
! 260: sc->sc_sunfb.sf_height = height;
! 261: sc->sc_sunfb.sf_linebytes = width >= 1024 ? width : 1024;
! 262: sc->sc_sunfb.sf_fbsize = sc->sc_sunfb.sf_linebytes * height;
! 263:
! 264: /* Map the frame buffer memory area we're interested in. */
! 265: sc->sc_paddr = sbus_bus_addr(bt, sa->sa_slot, sa->sa_offset);
! 266: if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + PX_PLANE8_OFFSET,
! 267: round_page(sc->sc_sunfb.sf_fbsize), BUS_SPACE_MAP_LINEAR, 0,
! 268: &bh) != 0) {
! 269: printf("%s: couldn't map 8-bit video plane\n", self->dv_xname);
! 270: return;
! 271: }
! 272: sc->sc_m8 = bus_space_vaddr(bt, bh);
! 273: if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + PX_PLANE24_OFFSET,
! 274: round_page(4 * sc->sc_sunfb.sf_fbsize), BUS_SPACE_MAP_LINEAR, 0,
! 275: &bh) != 0) {
! 276: printf("%s: couldn't map 32-bit video plane\n", self->dv_xname);
! 277: return;
! 278: }
! 279: sc->sc_m24 = bus_space_vaddr(bt, bh);
! 280:
! 281: /* Enable video. */
! 282: tvtwo_burner(sc, 1, 0);
! 283:
! 284: sc->sc_sunfb.sf_ro.ri_hw = sc;
! 285: sc->sc_sunfb.sf_ro.ri_bits = (u_char *)sc->sc_m8;
! 286:
! 287: /*
! 288: * If the framebuffer width is under 1024, we will switch from
! 289: * the PROM font to the more adequate 8x16 font here.
! 290: */
! 291: fbwscons_init(&sc->sc_sunfb,
! 292: isconsole && (width >= 1024) ? RI_CLEARMARGINS : RI_CLEAR);
! 293: fbwscons_setcolormap(&sc->sc_sunfb, tvtwo_setcolor);
! 294:
! 295: if (isconsole) {
! 296: fbwscons_console_init(&sc->sc_sunfb,
! 297: width >= 1024 ? -1 : 0);
! 298: }
! 299:
! 300: printf("%s: %dx%d\n", self->dv_xname,
! 301: sc->sc_sunfb.sf_width, sc->sc_sunfb.sf_height);
! 302:
! 303: fbwscons_attach(&sc->sc_sunfb, &tvtwo_accessops, isconsole);
! 304: }
! 305:
! 306: int
! 307: tvtwo_ioctl(void *dev, u_long cmd, caddr_t data, int flags, struct proc *p)
! 308: {
! 309: struct tvtwo_softc *sc = dev;
! 310: struct wsdisplay_fbinfo *wdf;
! 311:
! 312: /*
! 313: * Note that, although the emulation (text) mode is running in a
! 314: * 8-bit plane, we advertize the frame buffer as 32-bit.
! 315: */
! 316: switch (cmd) {
! 317: case WSDISPLAYIO_GTYPE:
! 318: *(u_int *)data = WSDISPLAY_TYPE_SUN24;
! 319: break;
! 320: case WSDISPLAYIO_GINFO:
! 321: wdf = (struct wsdisplay_fbinfo *)data;
! 322: wdf->height = sc->sc_sunfb.sf_height;
! 323: wdf->width = sc->sc_sunfb.sf_width;
! 324: wdf->depth = 32;
! 325: wdf->cmsize = 0;
! 326: break;
! 327: case WSDISPLAYIO_GETSUPPORTEDDEPTH:
! 328: *(u_int *)data = WSDISPLAYIO_DEPTH_24_32;
! 329: break;
! 330: case WSDISPLAYIO_LINEBYTES:
! 331: *(u_int *)data = sc->sc_sunfb.sf_linebytes * 4;
! 332: break;
! 333:
! 334: case WSDISPLAYIO_GETCMAP:
! 335: case WSDISPLAYIO_PUTCMAP:
! 336: break;
! 337:
! 338: case WSDISPLAYIO_SMODE:
! 339: if (*(int *)data == WSDISPLAYIO_MODE_EMUL) {
! 340: /* Back from X11 to text mode */
! 341: tvtwo_reset(sc, 8);
! 342: } else {
! 343: /* Starting X11, initialize 32-bit mode */
! 344: tvtwo_reset(sc, 32);
! 345: }
! 346: break;
! 347:
! 348: case WSDISPLAYIO_SVIDEO:
! 349: case WSDISPLAYIO_GVIDEO:
! 350: break;
! 351:
! 352: case WSDISPLAYIO_GCURPOS:
! 353: case WSDISPLAYIO_SCURPOS:
! 354: case WSDISPLAYIO_GCURMAX:
! 355: case WSDISPLAYIO_GCURSOR:
! 356: case WSDISPLAYIO_SCURSOR:
! 357: default:
! 358: return (-1);
! 359: }
! 360:
! 361: return (0);
! 362: }
! 363:
! 364: /*
! 365: * Return the address that would map the given device at the given
! 366: * offset, allowing for the given protection, or return -1 for error.
! 367: */
! 368: paddr_t
! 369: tvtwo_mmap(void *v, off_t offset, int prot)
! 370: {
! 371: struct tvtwo_softc *sc = v;
! 372:
! 373: if (offset & PGOFSET)
! 374: return (-1);
! 375:
! 376: /* Allow mapping as a dumb framebuffer from offset 0 */
! 377: if (offset >= 0 && offset < sc->sc_sunfb.sf_fbsize * 4) {
! 378: return (bus_space_mmap(sc->sc_bustag, sc->sc_paddr,
! 379: PX_PLANE24_OFFSET + offset, prot, BUS_SPACE_MAP_LINEAR));
! 380: }
! 381:
! 382: return (-1);
! 383: }
! 384:
! 385: int
! 386: tvtwo_alloc_screen(void *v, const struct wsscreen_descr *type,
! 387: void **cookiep, int *curxp, int *curyp, long *attrp)
! 388: {
! 389: struct tvtwo_softc *sc = v;
! 390:
! 391: if (sc->sc_nscreens > 0)
! 392: return (ENOMEM);
! 393:
! 394: *cookiep = &sc->sc_sunfb.sf_ro;
! 395: *curyp = 0;
! 396: *curxp = 0;
! 397: sc->sc_sunfb.sf_ro.ri_ops.alloc_attr(&sc->sc_sunfb.sf_ro,
! 398: 0, 0, 0, attrp);
! 399: sc->sc_nscreens++;
! 400: return (0);
! 401: }
! 402:
! 403: void
! 404: tvtwo_free_screen(void *v, void *cookie)
! 405: {
! 406: struct tvtwo_softc *sc = v;
! 407:
! 408: sc->sc_nscreens--;
! 409: }
! 410:
! 411: int
! 412: tvtwo_show_screen(void *v, void *cookie, int waitok,
! 413: void (*cb)(void *, int, int), void *cbarg)
! 414: {
! 415: return (0);
! 416: }
! 417:
! 418: void
! 419: tvtwo_burner(void *v, u_int on, u_int flags)
! 420: {
! 421: struct tvtwo_softc *sc = v;
! 422: u_int32_t dispkludge;
! 423:
! 424: if (on)
! 425: dispkludge = DISPKLUDGE_DEFAULT & ~DISPKLUDGE_BLANK;
! 426: else {
! 427: dispkludge = DISPKLUDGE_DEFAULT | DISPKLUDGE_BLANK;
! 428: if (flags & WSDISPLAY_BURN_VBLANK)
! 429: dispkludge |= DISPKLUDGE_SYNC;
! 430: }
! 431:
! 432: *(volatile u_int32_t *)(sc->sc_regs + PX_REG_DISPKLUDGE) =
! 433: dispkludge;
! 434: }
! 435:
! 436: void
! 437: tvtwo_reset(struct tvtwo_softc *sc, u_int depth)
! 438: {
! 439: if (depth == 32) {
! 440: /* Initialize a direct color map. */
! 441: tvtwo_directcmap(sc);
! 442: } else {
! 443: fbwscons_setcolormap(&sc->sc_sunfb, tvtwo_setcolor);
! 444: }
! 445: }
! 446:
! 447: /*
! 448: * Simple Bt463 programming routines.
! 449: */
! 450:
! 451: static __inline__ void
! 452: tvtwo_ramdac_wraddr(struct tvtwo_softc *sc, u_int32_t addr)
! 453: {
! 454: volatile u_int32_t *dac = (u_int32_t *)(sc->sc_regs + PX_REG_BT463_RED);
! 455:
! 456: dac[0] = (addr & 0xff); /* lo addr */
! 457: dac[1] = ((addr >> 8) & 0xff); /* hi addr */
! 458: }
! 459:
! 460: void
! 461: tvtwo_directcmap(struct tvtwo_softc *sc)
! 462: {
! 463: volatile u_int32_t *dac = (u_int32_t *)(sc->sc_regs + PX_REG_BT463_RED);
! 464: u_int32_t c;
! 465:
! 466: tvtwo_ramdac_wraddr(sc, 0);
! 467: for (c = 0; c < 256; c++) {
! 468: dac[3] = c; /* R */
! 469: dac[3] = c; /* G */
! 470: dac[3] = c; /* B */
! 471: }
! 472: }
! 473:
! 474: void
! 475: tvtwo_setcolor(void *v, u_int index, u_int8_t r, u_int8_t g, u_int8_t b)
! 476: {
! 477: struct tvtwo_softc *sc = v;
! 478: volatile u_int32_t *dac = (u_int32_t *)(sc->sc_regs + PX_REG_BT463_RED);
! 479:
! 480: tvtwo_ramdac_wraddr(sc, index);
! 481: dac[3] = r;
! 482: dac[3] = g;
! 483: dac[3] = b;
! 484: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to tvtwo.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / sbus