/* $Xorg: sunLyUtil.c,v 1.3 2000/08/17 19:48:37 cpqbld Exp $ */ /* * CG3 and CG6 utility functions for LynxOS, derived from NetBSD * Copyright 1996 by Thomas Mueller * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of Thomas Mueller not be used in * advertising or publicity pertaining to distribution of the software without * specific, written prior permission. Thomas Mueller makes no representations * about the suitability of this software for any purpose. It is provided * "as is" without express or implied warranty. * * THOMAS MUELLER DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THOMAS MUELLER BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. * */ /* $XFree86: xc/programs/Xserver/hw/sunLynx/sunLyUtil.c,v 3.2 2001/01/17 22:36:53 dawes Exp $ */ /* $NetBSD: bt_subr.c,v 1.4 1994/11/20 20:51:54 deraadt Exp $ */ /* * Copyright (c) 1993 * The Regents of the University of California. All rights reserved. * * This software was developed by the Computer Systems Engineering group * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and * contributed to Berkeley. * * All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Lawrence Berkeley Laboratory. * * 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 the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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. * * @(#)bt_subr.c 8.2 (Berkeley) 1/21/94 */ /* adaption for LynxOS microSPARC 2.4.0 and X11R6[.1] * Copyright 1996 by Thomas Mueller <tm@systrix.de> * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of Thomas Mueller not be used in * advertising or publicity pertaining to distribution of the software without * specific, written prior permission. Thomas Mueller makes no representations * about the suitability of this software for any purpose. It is provided * "as is" without express or implied warranty. * * THOMAS MUELLER DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THOMAS MUELLER BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. * */ #include "sun.h" #include "btreg.h" #include "btvar.h" #include "cgsixreg.h" #define useracc(a,b,c) (1) /* * Common code for dealing with Brooktree video DACs. * (Contains some software-only code as well, since the colormap * ioctls are shared between the cgthree and cgsix drivers.) */ /* * Implement an FBIOGETCMAP-like ioctl. */ int bt_getcmap(struct fbcmap *p, union bt_cmap *cm, int cmsize) { u_int i; u_int start; u_int count; u_char *cp; start = p->index; count = p->count; if (start >= cmsize || start + count > cmsize) return (EINVAL); if (!useracc(p->red, count, B_WRITE) || !useracc(p->green, count, B_WRITE) || !useracc(p->blue, count, B_WRITE)) return (EFAULT); for (cp = &cm->cm_map[start][0], i = 0; i < count; cp += 3, i++) { p->red[i] = cp[0]; p->green[i] = cp[1]; p->blue[i] = cp[2]; } return (0); } /* * Implement the software portion of an FBIOPUTCMAP-like ioctl. */ int bt_putcmap(struct fbcmap *p, union bt_cmap *cm, int cmsize) { u_int i; int start; int count; u_char *cp; start = p->index; count = p->count; if (start >= cmsize || start + count > cmsize) return (EINVAL); if (!useracc(p->red, count, B_READ) || !useracc(p->green, count, B_READ) || !useracc(p->blue, count, B_READ)) return (EFAULT); for (cp = &cm->cm_map[start][0], i = 0; i < count; cp += 3, i++) { cp[0] = p->red[i]; cp[1] = p->green[i]; cp[2] = p->blue[i]; } return (0); } union cursor_cmap { /* colormap, like bt_cmap, but tiny */ u_char cm_map[2][3]; /* 2 R/G/B entries */ u_int cm_chip[2]; /* 2 chip equivalents */ }; struct cg6_cursor { /* cg6 hardware cursor status */ short cc_enable; /* cursor is enabled */ struct fbcurpos cc_pos; /* position */ struct fbcurpos cc_hot; /* hot-spot */ struct fbcurpos cc_size; /* size of mask & image fields */ u_int cc_bits[2][32]; /* space for mask & image bits */ union cursor_cmap cc_color; /* cursor colormap */ }; static union bt_cmap sc_cmap; /* local copy of LUT */ static int blanked = 1; /* to jump-start it ... */ static struct cg6_cursor sc_cursor; /* cursor info */ /* * Clean up hardware state (e.g., after bootup or after X crashes). */ static void cg6_reset(fbFd * fb) { volatile struct cg6_tec_xxx *tec; int fhc; short fhcrev; volatile struct bt_regs *bt; /* hide the cursor, just in case */ ((volatile struct cg6_thc *) (fb->thc))->thc_cursxy = (THC_CURSOFF << 16) | THC_CURSOFF; /* turn off frobs in transform engine (makes X11 work) */ tec = fb->tec; tec->tec_mv = 0; tec->tec_clip = 0; tec->tec_vdc = 0; /* take care of hardware bugs in old revisions */ fhcrev = (*(int *) fb->fhc >> FHC_REV_SHIFT) & (FHC_REV_MASK >> FHC_REV_SHIFT); if (fhcrev < 5) { /* * Keep current resolution; set cpu to 68020, set test * window (size 1Kx1K), and for rev 1, disable dest cache. */ fhc = (*(int *) fb->fhc & FHC_RES_MASK) | FHC_CPU_68020 | FHC_TEST | (11 << FHC_TESTX_SHIFT) | (11 << FHC_TESTY_SHIFT); if (fhcrev < 2) fhc |= FHC_DST_DISABLE; *(int *) fb->fhc = fhc; } /* Enable cursor in Brooktree DAC. */ bt = fb->ramdac; bt->bt_addr = 0x06 << 24; bt->bt_ctrl |= 0x03 << 24; } static void cg6_loadcursor(fbFd * fb) { volatile struct cg6_thc *thc; u_int edgemask; u_int m; int i; /* * Keep the top size.x bits. Here we *throw out* the top * size.x bits from an all-one-bits word, introducing zeros in * the top size.x bits, then invert all the bits to get what * we really wanted as our mask. But this fails if size.x is * 32---a sparc uses only the low 5 bits of the shift count--- * so we have to special case that. */ edgemask = ~0; if (sc_cursor.cc_size.x < 32) edgemask = ~(edgemask >> sc_cursor.cc_size.x); thc = (volatile struct cg6_thc *) fb->thc; for (i = 0; i < 32; i++) { m = sc_cursor.cc_bits[0][i] & edgemask; thc->thc_cursmask[i] = m; thc->thc_cursbits[i] = m & sc_cursor.cc_bits[1][i]; } } static void cg6_setcursor(fbFd * fb) { /* we need to subtract the hot-spot value here */ #define COORD(f) (sc_cursor.cc_pos.f - sc_cursor.cc_hot.f) ((volatile struct cg6_thc *) (fb->thc))->thc_cursxy = sc_cursor.cc_enable ? ((COORD(x) << 16) | (COORD(y) & 0xffff)) : (THC_CURSOFF << 16) | THC_CURSOFF; #undef COORD } /* * Load the cursor (overlay `foreground' and `background') colors. */ static void cg6_loadomap(fbFd * fb) { volatile struct bt_regs *bt; u_int i; bt = (volatile struct bt_regs *) fb->ramdac; bt->bt_addr = 0x01 << 24; /* set background color */ i = sc_cursor.cc_color.cm_chip[0]; bt->bt_omap = i; /* R */ bt->bt_omap = i << 8; /* G */ bt->bt_omap = i << 16; /* B */ bt->bt_addr = 0x03 << 24; /* set foreground color */ bt->bt_omap = i << 24; /* R */ i = sc_cursor.cc_color.cm_chip[1]; bt->bt_omap = i; /* G */ bt->bt_omap = i << 8; /* B */ } /* * Load a subset of the current (new) colormap into the color DAC. */ static void cg6_loadcmap(fbFd * fb, union bt_cmap *cm, int start, int ncolors) { volatile struct bt_regs *bt; u_int *ip; u_int i; int count; ip = &cm->cm_chip[BT_D4M3(start)]; /* start/4 * 3 */ count = BT_D4M3(start + ncolors - 1) - BT_D4M3(start) + 3; bt = (struct bt_regs *) fb->ramdac; bt->bt_addr = BT_D4M4(start) << 24; while (--count >= 0) { i = *ip++; /* hardware that makes one want to pound boards with hammers */ bt->bt_cmap = i; bt->bt_cmap = i << 8; bt->bt_cmap = i << 16; bt->bt_cmap = i << 24; } } /* * Undo the effect of an FBIOSVIDEO that turns the video off on a CG6 */ static void cg6_unblank(fbFd * dev) { volatile struct cg6_thc *thc = (volatile struct cg6_thc *) dev->thc; unsigned long x; unsigned long y; if (blanked) { thc->thc_misc = (thc->thc_misc & ~THC_MISC_VIDEN) | THC_MISC_VIDEN; } blanked = 0; } /* * Load a subset of the current (new) colormap into the Brooktree DAC. */ static void cg3_loadcmap(fbFd * fb, union bt_cmap *cm, int start, int ncolors) { volatile struct bt_regs *bt; u_int *ip; int count; ip = &cm->cm_chip[BT_D4M3(start)]; /* start/4 * 3 */ count = BT_D4M3(start + ncolors - 1) - BT_D4M3(start) + 3; bt = (struct bt_regs *) fb->ramdac; bt->bt_addr = BT_D4M4(start); while (--count >= 0) bt->bt_cmap = *ip++; } /* * Undo the effect of an FBIOSVIDEO that turns the video off on a CG3 */ static void cg3_unblank(fbFd * dev) { volatile struct bt_regs *bt; if (blanked) { bt = (struct bt_regs *) dev->ramdac; /* restore color 0 (and R of color 1) */ bt->bt_addr = 0; bt->bt_cmap = sc_cmap.cm_chip[0]; /* restore read mask */ bt->bt_addr = 0x06; /* command reg */ bt->bt_ctrl = 0x73; /* overlay plane */ bt->bt_addr = 0x04; /* read mask */ bt->bt_ctrl = 0xff; /* color planes */ } blanked = 0; } int sunIoctl(fbFd * fb, int cmd, void *arg) { int error; int v; int i; u_int count; union cursor_cmap tcm; switch (cmd) { default: errno = EINVAL; return -1; case FBIOPUTCMAP: #define q ((struct fbcmap *)arg) if (error = bt_putcmap(q, &sc_cmap, 256)) return error; if (fb->thc) { /* CG6 */ cg6_loadcmap(fb, &sc_cmap, q->index, q->count); } else { /* CG3 */ cg3_loadcmap(fb, &sc_cmap, q->index, q->count); } break; case FBIOSVIDEO: if (fb->thc) { /* CG6 */ if (*(int *) arg) cg6_unblank(fb); else { if (!blanked) { volatile struct cg6_thc *thc = (volatile struct cg6_thc *) fb->thc; thc->thc_misc = (thc->thc_misc & ~THC_MISC_VIDEN); } blanked = 1; } } else { /* CG3 */ if (*(int *) arg) cg3_unblank(fb); else { if (!blanked) { volatile struct bt_regs *bt; bt = (struct bt_regs *) fb->ramdac; bt->bt_addr = 0x06; /* command reg */ bt->bt_ctrl = 0x70; /* overlay plane */ bt->bt_addr = 0x04; /* read mask */ bt->bt_ctrl = 0x00; /* color planes */ /* * Set color 0 to black -- note that this overwrites R of * color 1. */ bt->bt_addr = 0; bt->bt_cmap = 0; } blanked = 1; } } break; /* these are for both FBIOSCURSOR and FBIOGCURSOR */ #define p ((struct fbcursor *)arg) #define cc (&sc_cursor) case FBIOSCURSOR: if (!fb->thc) { /* reject non CG6 */ errno = EINVAL; return -1; } /* * For setcmap and setshape, verify parameters, so that * we do not get halfway through an update and then crap * out with the software state screwed up. */ v = p->set; if (v & FB_CUR_SETCMAP) { /* * This use of a temporary copy of the cursor * colormap is not terribly efficient, but these * copies are small (8 bytes)... */ tcm = cc->cc_color; error = bt_putcmap(&p->cmap, (union bt_cmap *) &tcm, 2); if (error) return (error); } if (v & FB_CUR_SETSHAPE) { if ((u_int) p->size.x > 32 || (u_int) p->size.y > 32) return (EINVAL); count = p->size.y * 32 / NBBY; if (!useracc(p->image, count, B_READ) || !useracc(p->mask, count, B_READ)) return (EFAULT); } /* parameters are OK; do it */ if (v & (FB_CUR_SETCUR | FB_CUR_SETPOS | FB_CUR_SETHOT)) { if (v & FB_CUR_SETCUR) cc->cc_enable = p->enable; if (v & FB_CUR_SETPOS) cc->cc_pos = p->pos; if (v & FB_CUR_SETHOT) cc->cc_hot = p->hot; cg6_setcursor(fb); } if (v & FB_CUR_SETCMAP) { cc->cc_color = tcm; cg6_loadomap(fb); /* XXX defer to vertical retrace */ } if (v & FB_CUR_SETSHAPE) { cc->cc_size = p->size; count = p->size.y * 32 / NBBY; bzero((caddr_t) cc->cc_bits, sizeof cc->cc_bits); bcopy(p->mask, (caddr_t) cc->cc_bits[0], count); bcopy(p->image, (caddr_t) cc->cc_bits[1], count); cg6_loadcursor(fb); } break; case FBIOSCURPOS: if (!fb->thc) { /* reject non CG6 */ errno = EINVAL; return -1; } sc_cursor.cc_pos = *(struct fbcurpos *) arg; cg6_setcursor(fb); break; case FBIOGCURMAX: if (!fb->thc) { /* reject non CG6 */ errno = EINVAL; return -1; } /* max cursor size is 32x32 */ ((struct fbcurpos *) arg)->x = 32; ((struct fbcurpos *) arg)->y = 32; break; case FBIORESET: if (!fb->thc) { /* reject non CG6 */ errno = EINVAL; return -1; } cg6_reset(fb); } return 0; }