Home | History | Annotate | Line # | Download | only in common
ite_subr.c revision 1.5.100.1 
      1 /*	$NetBSD: ite_subr.c,v 1.5.100.1 2011/03/05 20:50:25 rmind Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1988 University of Utah.
      5  * Copyright (c) 1990, 1993
      6  *	The Regents of the University of California.  All rights reserved.
      7  *
      8  * This code is derived from software contributed to Berkeley by
      9  * the Systems Programming Group of the University of Utah Computer
     10  * Science Department.
     11  *
     12  * Redistribution and use in source and binary forms, with or without
     13  * modification, are permitted provided that the following conditions
     14  * are met:
     15  * 1. Redistributions of source code must retain the above copyright
     16  *    notice, this list of conditions and the following disclaimer.
     17  * 2. Redistributions in binary form must reproduce the above copyright
     18  *    notice, this list of conditions and the following disclaimer in the
     19  *    documentation and/or other materials provided with the distribution.
     20  * 3. Neither the name of the University nor the names of its contributors
     21  *    may be used to endorse or promote products derived from this software
     22  *    without specific prior written permission.
     23  *
     24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     34  * SUCH DAMAGE.
     35  *
     36  * from: Utah $Hdr: ite_subr.c 1.2 92/01/20$
     37  *
     38  *	@(#)ite_subr.c	8.1 (Berkeley) 6/10/93
     39  */
     40 
     41 #ifdef ITECONSOLE
     42 
     43 #include <sys/param.h>
     44 
     45 #include <hp300/stand/common/itereg.h>
     46 
     47 #include <hp300/stand/common/samachdep.h>
     48 #include <hp300/stand/common/itevar.h>
     49 
     50 static void ite_writeglyph(struct ite_data *, u_char *, u_char *);
     51 
     52 void
     53 ite_fontinfo(struct ite_data *ip)
     54 {
     55 	u_long fontaddr = getword(ip, getword(ip, FONTROM) + FONTADDR);
     56 
     57 	ip->ftheight = getbyte(ip, fontaddr + FONTHEIGHT);
     58 	ip->ftwidth  = getbyte(ip, fontaddr + FONTWIDTH);
     59 	ip->rows     = ip->dheight / ip->ftheight;
     60 	ip->cols     = ip->dwidth / ip->ftwidth;
     61 
     62 	if (ip->fbwidth > ip->dwidth) {
     63 		/*
     64 		 * Stuff goes to right of display.
     65 		 */
     66 		ip->fontx    = ip->dwidth;
     67 		ip->fonty    = 0;
     68 		ip->cpl      = (ip->fbwidth - ip->dwidth) / ip->ftwidth;
     69 		ip->cblankx  = ip->dwidth;
     70 		ip->cblanky  = ip->fonty + ((128 / ip->cpl) +1) * ip->ftheight;
     71 	} else {
     72 		/*
     73 		 * Stuff goes below the display.
     74 		 */
     75 		ip->fontx   = 0;
     76 		ip->fonty   = ip->dheight;
     77 		ip->cpl     = ip->fbwidth / ip->ftwidth;
     78 		ip->cblankx = 0;
     79 		ip->cblanky = ip->fonty + ((128 / ip->cpl) + 1) * ip->ftheight;
     80 	}
     81 }
     82 
     83 void
     84 ite_fontinit1bpp(struct ite_data *ip)
     85 {
     86 	u_char *fbmem, *dp;
     87 	int c, l, b;
     88 	int stride, width;
     89 
     90 	dp = (u_char *)(getword(ip, getword(ip, FONTROM) + FONTADDR) +
     91 	    (char *)ip->regbase) + FONTDATA;
     92 	stride = ip->fbwidth >> 3;
     93 	width = (ip->ftwidth + 7) / 8;
     94 
     95 	for (c = 0; c < 128; c++) {
     96 		fbmem = (u_char *)FBBASE +
     97 		    (ip->fonty + (c / ip->cpl) * ip->ftheight) * stride;
     98 		fbmem += (ip->fontx >> 3) + (c % ip->cpl) * width;
     99 		for (l = 0; l < ip->ftheight; l++) {
    100 			for (b = 0; b < width; b++) {
    101 				*fbmem++ = *dp;
    102 				dp += 2;
    103 			}
    104 			fbmem -= width;
    105 			fbmem += stride;
    106 		}
    107 	}
    108 }
    109 
    110 void
    111 ite_fontinit8bpp(struct ite_data *ip)
    112 {
    113 	int bytewidth = (((ip->ftwidth - 1) / 8) + 1);
    114 	int glyphsize = bytewidth * ip->ftheight;
    115 	u_char fontbuf[500];
    116 	u_char *dp, *fbmem;
    117 	int c, i, romp;
    118 
    119 	romp = getword(ip, getword(ip, FONTROM) + FONTADDR) + FONTDATA;
    120 	for (c = 0; c < 128; c++) {
    121 		fbmem = (u_char *)(FBBASE +
    122 		     (ip->fonty + (c / ip->cpl) * ip->ftheight) * ip->fbwidth +
    123 		     (ip->fontx + (c % ip->cpl) * ip->ftwidth));
    124 		dp = fontbuf;
    125 		for (i = 0; i < glyphsize; i++) {
    126 			*dp++ = getbyte(ip, romp);
    127 			romp += 2;
    128 		}
    129 		ite_writeglyph(ip, fbmem, fontbuf);
    130 	}
    131 }
    132 
    133 static void
    134 ite_writeglyph(struct ite_data *ip, u_char *fbmem, u_char *glyphp)
    135 {
    136 	int bn;
    137 	int l, b;
    138 
    139 	for (l = 0; l < ip->ftheight; l++) {
    140 		bn = 7;
    141 		for (b = 0; b < ip->ftwidth; b++) {
    142 			if ((1 << bn) & *glyphp)
    143 				*fbmem++ = 1;
    144 			else
    145 				*fbmem++ = 0;
    146 			if (--bn < 0) {
    147 				bn = 7;
    148 				glyphp++;
    149 			}
    150 		}
    151 		if (bn < 7)
    152 			glyphp++;
    153 		fbmem -= ip->ftwidth;
    154 		fbmem += ip->fbwidth;
    155 	}
    156 }
    157 
    158 /*
    159  * The cursor is just an inverted space.
    160  */
    161 #define flip_cursor(ip) \
    162 	(*ip->bmv)(ip, ip->cblanky, ip->cblankx, ip->cursory * ip->ftheight, \
    163 	    ip->cursorx * ip->ftwidth, ip->ftheight, ip->ftwidth, RR_XOR)
    164 
    165 void
    166 ite_dio_cursor(struct ite_data *ip, int flag)
    167 {
    168 
    169 	switch (flag) {
    170 	case MOVE_CURSOR:
    171 		flip_cursor(ip);
    172 		/* FALLTHROUGH */
    173 	case DRAW_CURSOR:
    174 		ip->cursorx = ip->curx;
    175 		ip->cursory = ip->cury;
    176 		/* FALLTHROUGH */
    177 	default:
    178 		flip_cursor(ip);
    179 		break;
    180 	}
    181 }
    182 
    183 void
    184 ite_dio_putc1bpp(struct ite_data *ip, int c, int dy, int dx)
    185 {
    186 
    187 	ite_dio_windowmove1bpp(ip, charY(ip, c), charX1bpp(ip, c),
    188 	    dy * ip->ftheight, dx * ip->ftwidth,
    189 	    ip->ftheight, ip->ftwidth, RR_COPY);
    190 }
    191 
    192 void
    193 ite_dio_putc8bpp(struct ite_data *ip, int c, int dy, int dx)
    194 {
    195 
    196 	(*ip->bmv)(ip, charY(ip, c), charX(ip, c),
    197 	    dy * ip->ftheight, dx * ip->ftwidth,
    198 	    ip->ftheight, ip->ftwidth, RR_COPY);
    199 }
    200 
    201 void
    202 ite_dio_clear(struct ite_data *ip, int sy, int sx, int h, int w)
    203 {
    204 
    205 	(*ip->bmv)(ip, sy * ip->ftheight, sx * ip->ftwidth,
    206 	    sy * ip->ftheight, sx * ip->ftwidth,
    207 	    h  * ip->ftheight, w  * ip->ftwidth, RR_CLEAR);
    208 }
    209 
    210 void
    211 ite_dio_scroll(struct ite_data *ip)
    212 {
    213 
    214 	flip_cursor(ip);
    215 
    216 	(*ip->bmv)(ip, ip->ftheight, 0, 0, 0, (ip->rows - 1) * ip->ftheight,
    217 	    ip->cols * ip->ftwidth, RR_COPY);
    218 }
    219 
    220 #include <hp300/stand/common/maskbits.h>
    221 
    222 /* NOTE:
    223  * the first element in starttab could be 0xffffffff.  making it 0
    224  * lets us deal with a full first word in the middle loop, rather
    225  * than having to do the multiple reads and masks that we'd
    226  * have to do if we thought it was partial.
    227  */
    228 int starttab[32] = {
    229 	0x00000000,
    230 	0x7FFFFFFF,
    231 	0x3FFFFFFF,
    232 	0x1FFFFFFF,
    233 	0x0FFFFFFF,
    234 	0x07FFFFFF,
    235 	0x03FFFFFF,
    236 	0x01FFFFFF,
    237 	0x00FFFFFF,
    238 	0x007FFFFF,
    239 	0x003FFFFF,
    240 	0x001FFFFF,
    241 	0x000FFFFF,
    242 	0x0007FFFF,
    243 	0x0003FFFF,
    244 	0x0001FFFF,
    245 	0x0000FFFF,
    246 	0x00007FFF,
    247 	0x00003FFF,
    248 	0x00001FFF,
    249 	0x00000FFF,
    250 	0x000007FF,
    251 	0x000003FF,
    252 	0x000001FF,
    253 	0x000000FF,
    254 	0x0000007F,
    255 	0x0000003F,
    256 	0x0000001F,
    257 	0x0000000F,
    258 	0x00000007,
    259 	0x00000003,
    260 	0x00000001
    261 };
    262 
    263 int endtab[32] = {
    264 	0x00000000,
    265 	0x80000000,
    266 	0xC0000000,
    267 	0xE0000000,
    268 	0xF0000000,
    269 	0xF8000000,
    270 	0xFC000000,
    271 	0xFE000000,
    272 	0xFF000000,
    273 	0xFF800000,
    274 	0xFFC00000,
    275 	0xFFE00000,
    276 	0xFFF00000,
    277 	0xFFF80000,
    278 	0xFFFC0000,
    279 	0xFFFE0000,
    280 	0xFFFF0000,
    281 	0xFFFF8000,
    282 	0xFFFFC000,
    283 	0xFFFFE000,
    284 	0xFFFFF000,
    285 	0xFFFFF800,
    286 	0xFFFFFC00,
    287 	0xFFFFFE00,
    288 	0xFFFFFF00,
    289 	0xFFFFFF80,
    290 	0xFFFFFFC0,
    291 	0xFFFFFFE0,
    292 	0xFFFFFFF0,
    293 	0xFFFFFFF8,
    294 	0xFFFFFFFC,
    295 	0xFFFFFFFE
    296 };
    297 
    298 void
    299 ite_dio_windowmove1bpp(struct ite_data *ip, int sy, int sx, int dy, int dx,
    300     int h, int w, int func)
    301 {
    302 	int width;		/* add to get to same position in next line */
    303 
    304 	unsigned int *psrcLine, *pdstLine;
    305 				/* pointers to line with current src and dst */
    306 	unsigned int *psrc;	/* pointer to current src longword */
    307 	unsigned int *pdst;	/* pointer to current dst longword */
    308 
    309 				/* following used for looping through a line */
    310 	unsigned int startmask, endmask;  /* masks for writing ends of dst */
    311 	int nlMiddle;		/* whole longwords in dst */
    312 	int nl;			/* temp copy of nlMiddle */
    313 	unsigned int tmpSrc;	/* place to store full source word */
    314 	int xoffSrc;		/* offset (>= 0, < 32) from which to
    315 				   fetch whole longwords fetched
    316 				   in src */
    317 	int nstart;		/* number of ragged bits at start of dst */
    318 	int nend;		/* number of ragged bits at end of dst */
    319 	int srcStartOver;	/* pulling nstart bits from src
    320 				   overflows into the next word? */
    321 
    322 	if (h == 0 || w == 0)
    323 		return;
    324 
    325 	width = ip->fbwidth >> 5;
    326 	psrcLine = ((unsigned int *) ip->fbbase) + (sy * width);
    327 	pdstLine = ((unsigned int *) ip->fbbase) + (dy * width);
    328 
    329 	/* x direction doesn't matter for < 1 longword */
    330 	if (w <= 32) {
    331 		int srcBit, dstBit;     /* bit offset of src and dst */
    332 
    333 		pdstLine += (dx >> 5);
    334 		psrcLine += (sx >> 5);
    335 		psrc = psrcLine;
    336 		pdst = pdstLine;
    337 
    338 		srcBit = sx & 0x1f;
    339 		dstBit = dx & 0x1f;
    340 
    341 		while (h--) {
    342 			getandputrop(psrc, srcBit, dstBit, w, pdst, func);
    343 			pdst += width;
    344 			psrc += width;
    345 		}
    346 	} else {
    347 		maskbits(dx, w, startmask, endmask, nlMiddle);
    348 		if (startmask)
    349 			nstart = 32 - (dx & 0x1f);
    350 		else
    351 			nstart = 0;
    352 		if (endmask)
    353 			nend = (dx + w) & 0x1f;
    354 		else
    355 			nend = 0;
    356 
    357 		xoffSrc = ((sx & 0x1f) + nstart) & 0x1f;
    358 		srcStartOver = ((sx & 0x1f) + nstart) > 31;
    359 
    360 		pdstLine += (dx >> 5);
    361 		psrcLine += (sx >> 5);
    362 
    363 		while (h--) {
    364 			psrc = psrcLine;
    365 			pdst = pdstLine;
    366 
    367 			if (startmask) {
    368 				getandputrop(psrc, (sx & 0x1f), (dx & 0x1f),
    369 				    nstart, pdst, func);
    370 				pdst++;
    371 				if (srcStartOver)
    372 					psrc++;
    373 			}
    374 
    375 			/* special case for aligned operations */
    376 			if (xoffSrc == 0) {
    377 				nl = nlMiddle;
    378 				while (nl--) {
    379 					DoRop(*pdst, func, *psrc++, *pdst);
    380 					pdst++;
    381 				}
    382 			} else {
    383 				nl = nlMiddle + 1;
    384 				while (--nl) {
    385 					getunalignedword(psrc, xoffSrc, tmpSrc);
    386 					DoRop(*pdst, func, tmpSrc, *pdst);
    387 					pdst++;
    388 					psrc++;
    389 				}
    390 			}
    391 
    392 			if (endmask) {
    393 				getandputrop0(psrc, xoffSrc, nend, pdst, func);
    394 			}
    395 
    396 			pdstLine += width;
    397 			psrcLine += width;
    398 		}
    399 	}
    400 }
    401 #endif
    402