diff options
Diffstat (limited to 'sys/arch/vax/vsa/smg.c')
| -rw-r--r-- | sys/arch/vax/vsa/smg.c | 261 |
1 files changed, 257 insertions, 4 deletions
diff --git a/sys/arch/vax/vsa/smg.c b/sys/arch/vax/vsa/smg.c index e9e2186db9d..afd93291245 100644 --- a/sys/arch/vax/vsa/smg.c +++ b/sys/arch/vax/vsa/smg.c @@ -1,4 +1,4 @@ -/* $OpenBSD: smg.c,v 1.15 2006/08/03 18:44:32 miod Exp $ */ +/* $OpenBSD: smg.c,v 1.16 2006/08/05 10:00:30 miod Exp $ */ /* $NetBSD: smg.c,v 1.21 2000/03/23 06:46:44 thorpej Exp $ */ /* * Copyright (c) 2006, Miodrag Vallat @@ -54,6 +54,45 @@ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* + * Copyright (c) 1996 Jason R. Thorpe. All rights reserved. + * Copyright (c) 1991 University of Utah. + * Copyright (c) 1990, 1993 + * The Regents of the University of California. All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * the Systems Programming Group of the University of Utah Computer + * Science Department and Mark Davies of the Department of Computer + * Science, Victoria University of Wellington, New Zealand. + * + * 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. 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. + * + * from: Utah $Hdr: grf_hy.c 1.2 93/08/13$ + * + * @(#)grf_hy.c 8.4 (Berkeley) 1/12/94 + */ #include <sys/param.h> #include <sys/device.h> @@ -81,9 +120,7 @@ #include <dev/wscons/wsconsio.h> #include <dev/wscons/wsdisplayvar.h> #include <dev/rasops/rasops.h> -#include <dev/wsfont/wsfont.h> - -#include "dzkbd.h" +#include <dev/rasops/rasops_masks.h> /* Screen hardware defs */ #define SM_XWIDTH 1024 @@ -156,6 +193,11 @@ const struct wsdisplay_accessops smg_accessops = { smg_burner }; +void smg_blockmove(struct rasops_info *, u_int, u_int, u_int, u_int, u_int, + int); +void smg_copycols(void *, int, int, int, int); +void smg_erasecols(void *, int, int, int, long); + int smg_getcursor(struct smg_screen *, struct wsdisplay_cursor *); int smg_setup_screen(struct smg_screen *); int smg_setcursor(struct smg_screen *, struct wsdisplay_cursor *); @@ -312,6 +354,9 @@ smg_setup_screen(struct smg_screen *ss) if (rasops_init(ri, 160, 160) != 0) return (-1); + ri->ri_ops.copycols = smg_copycols; + ri->ri_ops.erasecols = smg_erasecols; + smg_stdscreen.ncols = ri->ri_cols; smg_stdscreen.nrows = ri->ri_rows; smg_stdscreen.textops = &ri->ri_ops; @@ -552,6 +597,214 @@ smg_updatecursor(struct smg_screen *ss, u_int which) } /* + * Faster console operations + */ + +#include <vax/vsa/maskbits.h> + +void +smg_blockmove(struct rasops_info *ri, u_int sx, u_int y, u_int dx, u_int cx, + u_int cy, int rop) +{ + int width; /* add to get to same position in next line */ + + unsigned int *psrcLine, *pdstLine; + /* pointers to line with current src and dst */ + unsigned int *psrc; /* pointer to current src longword */ + unsigned int *pdst; /* pointer to current dst longword */ + + /* following used for looping through a line */ + unsigned int startmask, endmask; /* masks for writing ends of dst */ + int nlMiddle; /* whole longwords in dst */ + int nl; /* temp copy of nlMiddle */ + int xoffSrc; /* offset (>= 0, < 32) from which to + fetch whole longwords fetched in src */ + int nstart; /* number of ragged bits at start of dst */ + int nend; /* number of ragged bits at end of dst */ + int srcStartOver; /* pulling nstart bits from src + overflows into the next word? */ + + width = SM_XWIDTH >> 5; + + /* start at first scanline */ + psrcLine = pdstLine = ((u_int *)ri->ri_bits) + (y * width); + + /* x direction doesn't matter for < 1 longword */ + if (cx <= 32) { + int srcBit, dstBit; /* bit offset of src and dst */ + + pdstLine += (dx >> 5); + psrcLine += (sx >> 5); + psrc = psrcLine; + pdst = pdstLine; + + srcBit = sx & 0x1f; + dstBit = dx & 0x1f; + + while (cy--) { + getandputrop(psrc, srcBit, dstBit, cx, pdst, rop); + pdst += width; + psrc += width; + } + } else { + maskbits(dx, cx, startmask, endmask, nlMiddle); + if (startmask) + nstart = 32 - (dx & 0x1f); + else + nstart = 0; + if (endmask) + nend = (dx + cx) & 0x1f; + else + nend = 0; + + xoffSrc = ((sx & 0x1f) + nstart) & 0x1f; + srcStartOver = ((sx & 0x1f) + nstart) > 31; + + if (sx >= dx) { /* move left to right */ + pdstLine += (dx >> 5); + psrcLine += (sx >> 5); + + while (cy--) { + psrc = psrcLine; + pdst = pdstLine; + + if (startmask) { + getandputrop(psrc, (sx & 0x1f), + (dx & 0x1f), nstart, pdst, rop); + pdst++; + if (srcStartOver) + psrc++; + } + + /* special case for aligned operations */ + if (xoffSrc == 0) { + nl = nlMiddle; + while (nl--) { + switch (rop) { + case RR_CLEAR: + *pdst = 0; + break; + case RR_SET: + *pdst = ~0; + break; + default: + *pdst = *psrc; + break; + } + psrc++; + pdst++; + } + } else { + nl = nlMiddle + 1; + while (--nl) { + switch (rop) { + case RR_CLEAR: + *pdst = 0; + break; + case RR_SET: + *pdst = ~0; + break; + default: + getunalignedword(psrc, + xoffSrc, *pdst); + break; + } + pdst++; + psrc++; + } + } + + if (endmask) { + getandputrop(psrc, xoffSrc, 0, nend, + pdst, rop); + } + + pdstLine += width; + psrcLine += width; + } + } else { /* move right to left */ + pdstLine += ((dx + cx) >> 5); + psrcLine += ((sx + cx) >> 5); + /* + * If fetch of last partial bits from source crosses + * a longword boundary, start at the previous longword + */ + if (xoffSrc + nend >= 32) + --psrcLine; + + while (cy--) { + psrc = psrcLine; + pdst = pdstLine; + + if (endmask) { + getandputrop(psrc, xoffSrc, 0, nend, + pdst, rop); + } + + nl = nlMiddle + 1; + while (--nl) { + --psrc; + --pdst; + switch (rop) { + case RR_CLEAR: + *pdst = 0; + break; + case RR_SET: + *pdst = ~0; + break; + default: + getunalignedword(psrc, xoffSrc, + *pdst); + break; + } + } + + if (startmask) { + if (srcStartOver) + --psrc; + --pdst; + getandputrop(psrc, (sx & 0x1f), + (dx & 0x1f), nstart, pdst, rop); + } + + pdstLine += width; + psrcLine += width; + } + } + } +} + +void +smg_copycols(void *cookie, int row, int src, int dst, int n) +{ + struct rasops_info *ri = cookie; + + n *= ri->ri_font->fontwidth; + src *= ri->ri_font->fontwidth; + dst *= ri->ri_font->fontwidth; + row *= ri->ri_font->fontheight; + + smg_blockmove(ri, src, row, dst, n, ri->ri_font->fontheight, + RR_COPY); +} + +void +smg_erasecols(void *cookie, int row, int col, int num, long attr) +{ + struct rasops_info *ri = cookie; + int fg, bg; + + rasops_unpack_attr(attr, &fg, &bg, NULL); + + num *= ri->ri_font->fontwidth; + col *= ri->ri_font->fontwidth; + row *= ri->ri_font->fontheight; + + smg_blockmove(ri, col, row, col, num, ri->ri_font->fontheight, + bg == 0 ? RR_CLEAR : RR_SET); +} + +/* * Console support code */ |