sys/dev/rasops/rasops2.c

   1 /*      $NetBSD: rasops2.c,v 1.13 2009/03/14 15:36:20 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: rasops2.c,v 1.13 2009/03/14 15:36:20 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     rasops2_copycols(void *, int, int, int, int);
  48 static void     rasops2_erasecols(void *, int, int, int, long);
  49 static void     rasops2_do_cursor(struct rasops_info *);
  50 static void     rasops2_putchar(void *, int, int col, u_int, long);
  51 #ifndef RASOPS_SMALL
  52 static void     rasops2_putchar8(void *, int, int col, u_int, long);
  53 static void     rasops2_putchar12(void *, int, int col, u_int, long);
  54 static void     rasops2_putchar16(void *, int, int col, u_int, long);
  55 static void     rasops2_makestamp(struct rasops_info *, long);
  56
  57 /*
  58  * 4x1 stamp for optimized character blitting
  59  */
  60 static int8_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 rasops2_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 = rasops2_putchar8;
  76                 break;
  77         case 12:
  78                 ri->ri_ops.putchar = rasops2_putchar12;
  79                 break;
  80         case 16:
  81                 ri->ri_ops.putchar = rasops2_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 = rasops2_putchar;
  87                 break;
  88         }
  89
  90         if ((ri->ri_font->fontwidth & 3) != 0) {
  91                 ri->ri_ops.erasecols = rasops2_erasecols;
  92                 ri->ri_ops.copycols = rasops2_copycols;
  93                 ri->ri_do_cursor = rasops2_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 rasops2_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 rasops2_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 rasops2_makestamp(struct rasops_info *ri, long attr)
 225 {
 226         int i, fg, bg;
 227
 228         fg = ri->ri_devcmap[(attr >> 24) & 0xf] & 3;
 229         bg = ri->ri_devcmap[(attr >> 16) & 0xf] & 3;
 230         stamp_attr = attr;
 231
 232         for (i = 0; i < 16; i++) {
 233                 stamp[i] = (i & 1 ? fg : bg);
 234                 stamp[i] |= (i & 2 ? fg : bg) << 2;
 235                 stamp[i] |= (i & 4 ? fg : bg) << 4;
 236                 stamp[i] |= (i & 8 ? fg : bg) << 6;
 237         }
 238 }
 239
 240 /*
 241  * Put a single character. This is for 8-pixel wide fonts.
 242  */
 243 static void
 244 rasops2_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, *rp;
 249
 250         /* Can't risk remaking the stamp if it's already in use */
 251         if (stamp_mutex++) {
 252                 stamp_mutex--;
 253                 rasops2_putchar(cookie, row, col, uc, attr);
 254                 return;
 255         }
 256
 257         ri = (struct rasops_info *)cookie;
 258
 259 #ifdef RASOPS_CLIPPING
 260         /* Catches 'row < 0' case too */
 261         if ((unsigned)row >= (unsigned)ri->ri_rows) {
 262                 stamp_mutex--;
 263                 return;
 264         }
 265
 266         if ((unsigned)col >= (unsigned)ri->ri_cols) {
 267                 stamp_mutex--;
 268                 return;
 269         }
 270 #endif
 271
 272         rp = ri->ri_bits + row * ri->ri_yscale + col * ri->ri_xscale;
 273         height = ri->ri_font->fontheight;
 274         rs = ri->ri_stride;
 275
 276         /* Recompute stamp? */
 277         if (attr != stamp_attr)
 278                 rasops2_makestamp(ri, attr);
 279
 280         if (uc == ' ') {
 281                 int8_t c = stamp[0];
 282                 while (height--) {
 283                         *(int16_t *)rp = c;
 284                         rp += rs;
 285                 }
 286         } else {
 287                 uc -= ri->ri_font->firstchar;
 288                 fr = (u_char *)ri->ri_font->data + uc * ri->ri_fontscale;
 289                 fs = ri->ri_font->stride;
 290
 291                 while (height--) {
 292                         rp[0] = stamp[(*fr >> 4) & 0xf];
 293                         rp[1] = stamp[*fr & 0xf];
 294                         fr += fs;
 295                         rp += rs;
 296                 }
 297         }
 298
 299         /* Do underline */
 300         if ((attr & 1) != 0)
 301                 *(int16_t *)(rp - (ri->ri_stride << 1)) = stamp[15];
 302
 303         stamp_mutex--;
 304 }
 305
 306 /*
 307  * Put a single character. This is for 12-pixel wide fonts.
 308  */
 309 static void
 310 rasops2_putchar12(void *cookie, int row, int col, u_int uc, long attr)
 311 {
 312         struct rasops_info *ri;
 313         int height, fs, rs;
 314         u_char *fr, *rp;
 315
 316         /* Can't risk remaking the stamp if it's already in use */
 317         if (stamp_mutex++) {
 318                 stamp_mutex--;
 319                 rasops2_putchar(cookie, row, col, uc, attr);
 320                 return;
 321         }
 322
 323         ri = (struct rasops_info *)cookie;
 324
 325 #ifdef RASOPS_CLIPPING
 326         /* Catches 'row < 0' case too */
 327         if ((unsigned)row >= (unsigned)ri->ri_rows) {
 328                 stamp_mutex--;
 329                 return;
 330         }
 331
 332         if ((unsigned)col >= (unsigned)ri->ri_cols) {
 333                 stamp_mutex--;
 334                 return;
 335         }
 336 #endif
 337
 338         rp = ri->ri_bits + row * ri->ri_yscale + col * ri->ri_xscale;
 339         height = ri->ri_font->fontheight;
 340         rs = ri->ri_stride;
 341
 342         /* Recompute stamp? */
 343         if (attr != stamp_attr)
 344                 rasops2_makestamp(ri, attr);
 345
 346         if (uc == ' ') {
 347                 int8_t c = stamp[0];
 348                 while (height--) {
 349                         rp[0] = rp[1] = rp[2] = c;
 350                         rp += rs;
 351                 }
 352         } else {
 353                 uc -= ri->ri_font->firstchar;
 354                 fr = (u_char *)ri->ri_font->data + uc * ri->ri_fontscale;
 355                 fs = ri->ri_font->stride;
 356
 357                 while (height--) {
 358                         rp[0] = stamp[(fr[0] >> 4) & 0xf];
 359                         rp[1] = stamp[fr[0] & 0xf];
 360                         rp[2] = stamp[(fr[1] >> 4) & 0xf];
 361                         fr += fs;
 362                         rp += rs;
 363                 }
 364         }
 365
 366         /* Do underline */
 367         if ((attr & 1) != 0) {
 368                 rp -= ri->ri_stride << 1;
 369                 rp[0] = rp[1] = rp[2] = stamp[15];
 370         }
 371
 372         stamp_mutex--;
 373 }
 374
 375 /*
 376  * Put a single character. This is for 16-pixel wide fonts.
 377  */
 378 static void
 379 rasops2_putchar16(void *cookie, int row, int col, u_int uc, long attr)
 380 {
 381         struct rasops_info *ri;
 382         int height, fs, rs;
 383         u_char *fr, *rp;
 384
 385         /* Can't risk remaking the stamp if it's already in use */
 386         if (stamp_mutex++) {
 387                 stamp_mutex--;
 388                 rasops2_putchar(cookie, row, col, uc, attr);
 389                 return;
 390         }
 391
 392         ri = (struct rasops_info *)cookie;
 393
 394 #ifdef RASOPS_CLIPPING
 395         /* Catches 'row < 0' case too */
 396         if ((unsigned)row >= (unsigned)ri->ri_rows) {
 397                 stamp_mutex--;
 398                 return;
 399         }
 400
 401         if ((unsigned)col >= (unsigned)ri->ri_cols) {
 402                 stamp_mutex--;
 403                 return;
 404         }
 405 #endif
 406
 407         rp = ri->ri_bits + row * ri->ri_yscale + col * ri->ri_xscale;
 408         height = ri->ri_font->fontheight;
 409         rs = ri->ri_stride;
 410
 411         /* Recompute stamp? */
 412         if (attr != stamp_attr)
 413                 rasops2_makestamp(ri, attr);
 414
 415         if (uc == ' ') {
 416                 int8_t c = stamp[0];
 417                 while (height--) {
 418                         *(int32_t *)rp = c;
 419                         rp += rs;
 420                 }
 421         } else {
 422                 uc -= ri->ri_font->firstchar;
 423                 fr = (u_char *)ri->ri_font->data + uc * ri->ri_fontscale;
 424                 fs = ri->ri_font->stride;
 425
 426                 while (height--) {
 427                         rp[0] = stamp[(fr[0] >> 4) & 0xf];
 428                         rp[1] = stamp[fr[0] & 0xf];
 429                         rp[2] = stamp[(fr[1] >> 4) & 0xf];
 430                         rp[3] = stamp[fr[1] & 0xf];
 431                         fr += fs;
 432                         rp += rs;
 433                 }
 434         }
 435
 436         /* Do underline */
 437         if ((attr & 1) != 0)
 438                 *(int32_t *)(rp - (ri->ri_stride << 1)) = stamp[15];
 439
 440         stamp_mutex--;
 441 }
 442 #endif  /* !RASOPS_SMALL */
 443
 444 /*
 445  * Grab routines common to depths where (bpp < 8)
 446  */
 447 #define NAME(ident)     rasops2_##ident
 448 #define PIXEL_SHIFT     1
 449
 450 #include <dev/rasops/rasops_bitops.h>