Home | History | Annotate | Line # | Download | only in rasops
rasops4.c revision 1.9 
      1 /* 	$NetBSD: rasops4.c,v 1.9 2009/03/14 21:04:22 dsl Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 1999 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Andrew Doran.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29  * POSSIBILITY OF SUCH DAMAGE.
     30  */
     31 
     32 #include <sys/cdefs.h>
     33 __KERNEL_RCSID(0, "$NetBSD: rasops4.c,v 1.9 2009/03/14 21:04:22 dsl Exp $");
     34 
     35 #include "opt_rasops.h"
     36 
     37 #include <sys/param.h>
     38 #include <sys/systm.h>
     39 #include <sys/time.h>
     40 #include <machine/endian.h>
     41 
     42 #include <dev/wscons/wsdisplayvar.h>
     43 #include <dev/wscons/wsconsio.h>
     44 #include <dev/rasops/rasops.h>
     45 #include <dev/rasops/rasops_masks.h>
     46 
     47 static void	rasops4_copycols(void *, int, int, int, int);
     48 static void	rasops4_erasecols(void *, int, int, int, long);
     49 static void	rasops4_do_cursor(struct rasops_info *);
     50 static void	rasops4_putchar(void *, int, int col, u_int, long);
     51 #ifndef RASOPS_SMALL
     52 static void	rasops4_putchar8(void *, int, int col, u_int, long);
     53 static void	rasops4_putchar12(void *, int, int col, u_int, long);
     54 static void	rasops4_putchar16(void *, int, int col, u_int, long);
     55 static void	rasops4_makestamp(struct rasops_info *, long);
     56 
     57 /*
     58  * 4x1 stamp for optimized character blitting
     59  */
     60 static u_int16_t	stamp[16];
     61 static long	stamp_attr;
     62 static int	stamp_mutex;	/* XXX see note in README */
     63 #endif
     64 
     65 /*
     66  * Initialize rasops_info struct for this colordepth.
     67  */
     68 void
     69 rasops4_init(struct rasops_info *ri)
     70 {
     71 
     72 	switch (ri->ri_font->fontwidth) {
     73 #ifndef RASOPS_SMALL
     74 	case 8:
     75 		ri->ri_ops.putchar = rasops4_putchar8;
     76 		break;
     77 	case 12:
     78 		ri->ri_ops.putchar = rasops4_putchar12;
     79 		break;
     80 	case 16:
     81 		ri->ri_ops.putchar = rasops4_putchar16;
     82 		break;
     83 #endif	/* !RASOPS_SMALL */
     84 	default:
     85 		panic("fontwidth not 8/12/16 or RASOPS_SMALL - fixme!");
     86 		ri->ri_ops.putchar = rasops4_putchar;
     87 		break;
     88 	}
     89 
     90 	if ((ri->ri_font->fontwidth & 1) != 0) {
     91 		ri->ri_ops.erasecols = rasops4_erasecols;
     92 		ri->ri_ops.copycols = rasops4_copycols;
     93 		ri->ri_do_cursor = rasops4_do_cursor;
     94 	}
     95 }
     96 
     97 #ifdef notyet
     98 /*
     99  * Paint a single character. This is the generic version, this is ugly.
    100  */
    101 static void
    102 rasops4_putchar(void *cookie, int row, int col, u_int uc, long attr)
    103 {
    104 	int height, width, fs, rs, fb, bg, fg, lmask, rmask;
    105 	struct rasops_info *ri;
    106 	int32_t *rp;
    107 	u_char *fr;
    108 
    109 	ri = (struct rasops_info *)cookie;
    110 
    111 #ifdef RASOPS_CLIPPING
    112 	/* Catches 'row < 0' case too */
    113 	if ((unsigned)row >= (unsigned)ri->ri_rows)
    114 		return;
    115 
    116 	if ((unsigned)col >= (unsigned)ri->ri_cols)
    117 		return;
    118 #endif
    119 
    120 	width = ri->ri_font->fontwidth << 1;
    121 	height = ri->ri_font->fontheight;
    122 	col *= width;
    123 	rp = (int32_t *)(ri->ri_bits + row * ri->ri_yscale + ((col >> 3) & ~3));
    124 	col = col & 31;
    125 	rs = ri->ri_stride;
    126 
    127 	bg = ri->ri_devcmap[(attr >> 16) & 0xf];
    128 	fg = ri->ri_devcmap[(attr >> 24) & 0xf];
    129 
    130 	/* If fg and bg match this becomes a space character */
    131 	if (fg == bg || uc == ' ') {
    132 		uc = (u_int)-1;
    133 		fr = 0;		/* shutup gcc */
    134 		fs = 0;		/* shutup gcc */
    135 	} else {
    136 		uc -= ri->ri_font->firstchar;
    137 		fr = (u_char *)ri->ri_font->data + uc * ri->ri_fontscale;
    138 		fs = ri->ri_font->stride;
    139 	}
    140 
    141 	/* Single word, one mask */
    142 	if ((col + width) <= 32) {
    143 		rmask = rasops_pmask[col][width];
    144 		lmask = ~rmask;
    145 
    146 		if (uc == (u_int)-1) {
    147 			bg &= rmask;
    148 
    149 			while (height--) {
    150 				*rp = (*rp & lmask) | bg;
    151 				DELTA(rp, rs, int32_t *);
    152 			}
    153 		} else {
    154 			while (height--) {
    155 				/* get bits, mask */
    156 				/* compose sl */
    157 				/* mask sl */
    158 				/* put word */
    159 			}
    160 		}
    161 
    162 		/* Do underline */
    163 		if (attr & 1) {
    164 			DELTA(rp, -(ri->ri_stride << 1), int32_t *);
    165 			*rp = (*rp & lmask) | (fg & rmask);
    166 		}
    167 	} else {
    168 		lmask = ~rasops_lmask[col];
    169 		rmask = ~rasops_rmask[(col + width) & 31];
    170 
    171 		if (uc == (u_int)-1) {
    172 			bg = bg & ~lmask;
    173 			width = bg & ~rmask;
    174 
    175 			while (height--) {
    176 				rp[0] = (rp[0] & lmask) | bg;
    177 				rp[1] = (rp[1] & rmask) | width;
    178 				DELTA(rp, rs, int32_t *);
    179 			}
    180 		} else {
    181 			width = 32 - col;
    182 
    183 			/* NOT fontbits if bg is white */
    184 			while (height--) {
    185 				fb = ~(fr[3] | (fr[2] << 8) |
    186 				    (fr[1] << 16) | (fr[0] << 24));
    187 
    188 				rp[0] = (rp[0] & lmask)
    189 				    | MBE((u_int)fb >> col);
    190 
    191 				rp[1] = (rp[1] & rmask)
    192 				   | (MBE((u_int)fb << width) & ~rmask);
    193 
    194 				fr += fs;
    195 				DELTA(rp, rs, int32_t *);
    196 			}
    197 		}
    198 
    199 		/* Do underline */
    200 		if (attr & 1) {
    201 			DELTA(rp, -(ri->ri_stride << 1), int32_t *);
    202 			rp[0] = (rp[0] & lmask) | (fg & ~lmask);
    203 			rp[1] = (rp[1] & rmask) | (fg & ~rmask);
    204 		}
    205 	}
    206 }
    207 #endif
    208 
    209 /*
    210  * Put a single character. This is the generic version.
    211  */
    212 static void
    213 rasops4_putchar(void *cookie, int row, int col, u_int uc, long attr)
    214 {
    215 
    216 	/* XXX punt */
    217 }
    218 
    219 #ifndef RASOPS_SMALL
    220 /*
    221  * Recompute the blitting stamp.
    222  */
    223 static void
    224 rasops4_makestamp(struct rasops_info *ri, long attr)
    225 {
    226 	int i, fg, bg;
    227 
    228 	fg = ri->ri_devcmap[(attr >> 24) & 0xf] & 0xf;
    229 	bg = ri->ri_devcmap[(attr >> 16) & 0xf] & 0xf;
    230 	stamp_attr = attr;
    231 
    232 	for (i = 0; i < 16; i++) {
    233 		stamp[i] =  (i & 1 ? fg : bg) << 8;
    234 		stamp[i] |= (i & 2 ? fg : bg) << 12;
    235 		stamp[i] |= (i & 4 ? fg : bg) << 0;
    236 		stamp[i] |= (i & 8 ? fg : bg) << 4;
    237 	}
    238 }
    239 
    240 /*
    241  * Put a single character. This is for 8-pixel wide fonts.
    242  */
    243 static void
    244 rasops4_putchar8(void *cookie, int row, int col, u_int uc, long attr)
    245 {
    246 	struct rasops_info *ri;
    247 	int height, fs, rs;
    248 	u_char *fr;
    249 	u_int16_t *rp;
    250 
    251 	/* Can't risk remaking the stamp if it's already in use */
    252 	if (stamp_mutex++) {
    253 		stamp_mutex--;
    254 		rasops4_putchar(cookie, row, col, uc, attr);
    255 		return;
    256 	}
    257 
    258 	ri = (struct rasops_info *)cookie;
    259 
    260 #ifdef RASOPS_CLIPPING
    261 	/* Catches 'row < 0' case too */
    262 	if ((unsigned)row >= (unsigned)ri->ri_rows) {
    263 		stamp_mutex--;
    264 		return;
    265 	}
    266 
    267 	if ((unsigned)col >= (unsigned)ri->ri_cols) {
    268 		stamp_mutex--;
    269 		return;
    270 	}
    271 #endif
    272 
    273 	rp = (u_int16_t *)(ri->ri_bits + row * ri->ri_yscale + col * ri->ri_xscale);
    274 	height = ri->ri_font->fontheight;
    275 	rs = ri->ri_stride / sizeof(*rp);
    276 
    277 	/* Recompute stamp? */
    278 	if (attr != stamp_attr)
    279 		rasops4_makestamp(ri, attr);
    280 
    281 	if (uc == ' ') {
    282 		u_int16_t c = stamp[0];
    283 		while (height--) {
    284 			rp[0] = c;
    285 			rp[1] = c;
    286 			rp += rs;
    287 		}
    288 	} else {
    289 		uc -= ri->ri_font->firstchar;
    290 		fr = (u_char *)ri->ri_font->data + uc * ri->ri_fontscale;
    291 		fs = ri->ri_font->stride;
    292 
    293 		while (height--) {
    294 			rp[0] = stamp[(*fr >> 4) & 0xf];
    295 			rp[1] = stamp[*fr & 0xf];
    296 			fr += fs;
    297 			rp += rs;
    298 		}
    299 	}
    300 
    301 	/* Do underline */
    302 	if ((attr & 1) != 0) {
    303 		rp -= (rs << 1);
    304 		rp[0] = stamp[15];
    305 		rp[1] = stamp[15];
    306 	}
    307 
    308 	stamp_mutex--;
    309 }
    310 
    311 /*
    312  * Put a single character. This is for 12-pixel wide fonts.
    313  */
    314 static void
    315 rasops4_putchar12(void *cookie, int row, int col, u_int uc, long attr)
    316 {
    317 	struct rasops_info *ri;
    318 	int height, fs, rs;
    319 	u_char *fr;
    320 	u_int16_t *rp;
    321 
    322 	/* Can't risk remaking the stamp if it's already in use */
    323 	if (stamp_mutex++) {
    324 		stamp_mutex--;
    325 		rasops4_putchar(cookie, row, col, uc, attr);
    326 		return;
    327 	}
    328 
    329 	ri = (struct rasops_info *)cookie;
    330 
    331 #ifdef RASOPS_CLIPPING
    332 	/* Catches 'row < 0' case too */
    333 	if ((unsigned)row >= (unsigned)ri->ri_rows) {
    334 		stamp_mutex--;
    335 		return;
    336 	}
    337 
    338 	if ((unsigned)col >= (unsigned)ri->ri_cols) {
    339 		stamp_mutex--;
    340 		return;
    341 	}
    342 #endif
    343 
    344 	rp = (u_int16_t *)(ri->ri_bits + row * ri->ri_yscale + col * ri->ri_xscale);
    345 	height = ri->ri_font->fontheight;
    346 	rs = ri->ri_stride / sizeof(*rp);
    347 
    348 	/* Recompute stamp? */
    349 	if (attr != stamp_attr)
    350 		rasops4_makestamp(ri, attr);
    351 
    352 	if (uc == ' ') {
    353 		u_int16_t c = stamp[0];
    354 		while (height--) {
    355 			rp[0] = c;
    356 			rp[1] = c;
    357 			rp[2] = c;
    358 			rp += rs;
    359 		}
    360 	} else {
    361 		uc -= ri->ri_font->firstchar;
    362 		fr = (u_char *)ri->ri_font->data + uc * ri->ri_fontscale;
    363 		fs = ri->ri_font->stride;
    364 
    365 		while (height--) {
    366 			rp[0] = stamp[(fr[0] >> 4) & 0xf];
    367 			rp[1] = stamp[fr[0] & 0xf];
    368 			rp[2] = stamp[(fr[1] >> 4) & 0xf];
    369 			fr += fs;
    370 			rp += rs;
    371 		}
    372 	}
    373 
    374 	/* Do underline */
    375 	if ((attr & 1) != 0) {
    376 		rp -= (rs << 1);
    377 		rp[0] = stamp[15];
    378 		rp[1] = stamp[15];
    379 		rp[2] = stamp[15];
    380 	}
    381 
    382 	stamp_mutex--;
    383 }
    384 
    385 /*
    386  * Put a single character. This is for 16-pixel wide fonts.
    387  */
    388 static void
    389 rasops4_putchar16(void *cookie, int row, int col, u_int uc, long attr)
    390 {
    391 	struct rasops_info *ri;
    392 	int height, fs, rs;
    393 	u_char *fr;
    394 	u_int16_t *rp;
    395 
    396 	/* Can't risk remaking the stamp if it's already in use */
    397 	if (stamp_mutex++) {
    398 		stamp_mutex--;
    399 		rasops4_putchar(cookie, row, col, uc, attr);
    400 		return;
    401 	}
    402 
    403 	ri = (struct rasops_info *)cookie;
    404 
    405 #ifdef RASOPS_CLIPPING
    406 	/* Catches 'row < 0' case too */
    407 	if ((unsigned)row >= (unsigned)ri->ri_rows) {
    408 		stamp_mutex--;
    409 		return;
    410 	}
    411 
    412 	if ((unsigned)col >= (unsigned)ri->ri_cols) {
    413 		stamp_mutex--;
    414 		return;
    415 	}
    416 #endif
    417 
    418 	rp = (u_int16_t *)(ri->ri_bits + row * ri->ri_yscale + col * ri->ri_xscale);
    419 	height = ri->ri_font->fontheight;
    420 	rs = ri->ri_stride / sizeof(*rp);
    421 
    422 	/* Recompute stamp? */
    423 	if (attr != stamp_attr)
    424 		rasops4_makestamp(ri, attr);
    425 
    426 	if (uc == ' ') {
    427 		u_int16_t c = stamp[0];
    428 		while (height--) {
    429 			rp[0] = c;
    430 			rp[1] = c;
    431 			rp[2] = c;
    432 			rp[3] = c;
    433 			rp += rs;
    434 		}
    435 	} else {
    436 		uc -= ri->ri_font->firstchar;
    437 		fr = (u_char *)ri->ri_font->data + uc * ri->ri_fontscale;
    438 		fs = ri->ri_font->stride;
    439 
    440 		while (height--) {
    441 			rp[0] = stamp[(fr[0] >> 4) & 0xf];
    442 			rp[1] = stamp[fr[0] & 0xf];
    443 			rp[2] = stamp[(fr[1] >> 4) & 0xf];
    444 			rp[3] = stamp[fr[1] & 0xf];
    445 			fr += fs;
    446 			rp += rs;
    447 		}
    448 	}
    449 
    450 	/* Do underline */
    451 	if ((attr & 1) != 0) {
    452 		rp -= (rs << 1);
    453 		rp[0] = stamp[15];
    454 		rp[1] = stamp[15];
    455 		rp[2] = stamp[15];
    456 		rp[3] = stamp[15];
    457 	}
    458 
    459 	stamp_mutex--;
    460 }
    461 #endif	/* !RASOPS_SMALL */
    462 
    463 /*
    464  * Grab routines common to depths where (bpp < 8)
    465  */
    466 #define NAME(ident)	rasops4_##ident
    467 #define PIXEL_SHIFT	3
    468 
    469 #include <dev/rasops/rasops_bitops.h>
    470