root/dev/rasops/rasops.c

DEFINITIONS

1. rasops_init
2. rasops_reconfig
3. rasops_mapchar
4. rasops_alloc_cattr
5. rasops_alloc_mattr
6. rasops_copyrows
7. rasops_copycols
8. rasops_cursor
9. rasops_init_devcmap
10. rasops_unpack_attr
11. rasops_eraserows
12. rasops_do_cursor
13. rasops_erasecols
14. rasops_rotate_font
15. rasops_copychar
16. rasops_putchar_rotated
17. rasops_erasecols_rotated
18. rasops_copyrows_rotated
19. rasops_copycols_rotated
20. rasops_eraserows_rotated
21. slow_ovbcopy

    1 /*      $OpenBSD: rasops.c,v 1.17 2006/12/02 18:02:53 miod Exp $        */
    2 /*      $NetBSD: rasops.c,v 1.35 2001/02/02 06:01:01 marcus Exp $       */
    4 /*-
    5  * Copyright (c) 1999 The NetBSD Foundation, Inc.
    6  * All rights reserved.
    7  *
    8  * This code is derived from software contributed to The NetBSD Foundation
    9  * by Andrew Doran.
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions and the following disclaimer.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  * 3. All advertising materials mentioning features or use of this software
   20  *    must display the following acknowledgement:
   21  *      This product includes software developed by the NetBSD
   22  *      Foundation, Inc. and its contributors.
   23  * 4. Neither the name of The NetBSD Foundation nor the names of its
   24  *    contributors may be used to endorse or promote products derived
   25  *    from this software without specific prior written permission.
   26  *
   27  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   28  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   29  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   30  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   31  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   37  * POSSIBILITY OF SUCH DAMAGE.
   38  */
   40 #include <sys/param.h>
   41 #include <sys/systm.h>
   42 #include <sys/time.h>
   44 #include <machine/endian.h>
   46 #include <dev/wscons/wsdisplayvar.h>
   47 #include <dev/wscons/wsconsio.h>
   48 #include <dev/wsfont/wsfont.h>
   49 #include <dev/rasops/rasops.h>
   51 #ifndef _KERNEL
   52 #include <errno.h>
   53 #endif
   55 /* ANSI colormap (R,G,B) */
   57 #define NORMAL_BLACK    0x000000
   58 #define NORMAL_RED      0x7f0000
   59 #define NORMAL_GREEN    0x007f00
   60 #define NORMAL_BROWN    0x7f7f00
   61 #define NORMAL_BLUE     0x00007f
   62 #define NORMAL_MAGENTA  0x7f007f
   63 #define NORMAL_CYAN     0x007f7f
   64 #define NORMAL_WHITE    0xc7c7c7        /* XXX too dim? */
   66 #define HILITE_BLACK    0x7f7f7f
   67 #define HILITE_RED      0xff0000
   68 #define HILITE_GREEN    0x00ff00
   69 #define HILITE_BROWN    0xffff00
   70 #define HILITE_BLUE     0x0000ff
   71 #define HILITE_MAGENTA  0xff00ff
   72 #define HILITE_CYAN     0x00ffff
   73 #define HILITE_WHITE    0xffffff
   75 const u_char rasops_cmap[256 * 3] = {
   76 #define _C(x)   ((x) & 0xff0000) >> 16, ((x) & 0x00ff00) >> 8, ((x) & 0x0000ff)
_C(NORMAL_BLACK),
_C(NORMAL_RED),
_C(NORMAL_GREEN),
_C(NORMAL_BROWN),
_C(NORMAL_BLUE),
_C(NORMAL_MAGENTA),
_C(NORMAL_CYAN),
_C(NORMAL_WHITE),
_C(HILITE_BLACK),
_C(HILITE_RED),
_C(HILITE_GREEN),
_C(HILITE_BROWN),
_C(HILITE_BLUE),
_C(HILITE_MAGENTA),
_C(HILITE_CYAN),
_C(HILITE_WHITE),
   96         /*
   97          * For the cursor, we need the last 16 colors to be the
   98          * opposite of the first 16. Fill the intermediate space with
   99          * white completely for simplicity.
  100          */
  101 #define _CMWHITE16 \
_C(HILITE_WHITE), _C(HILITE_WHITE), _C(HILITE_WHITE), _C(HILITE_WHITE), \
_C(HILITE_WHITE), _C(HILITE_WHITE), _C(HILITE_WHITE), _C(HILITE_WHITE), \
_C(HILITE_WHITE), _C(HILITE_WHITE), _C(HILITE_WHITE), _C(HILITE_WHITE), \
_C(HILITE_WHITE), _C(HILITE_WHITE), _C(HILITE_WHITE), _C(HILITE_WHITE),
_CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16
_CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16
_CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16
  109 #undef _CMWHITE16
_C(~HILITE_WHITE),
_C(~HILITE_CYAN),
_C(~HILITE_MAGENTA),
_C(~HILITE_BLUE),
_C(~HILITE_BROWN),
_C(~HILITE_GREEN),
_C(~HILITE_RED),
_C(~HILITE_BLACK),
_C(~NORMAL_WHITE),
_C(~NORMAL_CYAN),
_C(~NORMAL_MAGENTA),
_C(~NORMAL_BLUE),
_C(~NORMAL_BROWN),
_C(~NORMAL_GREEN),
_C(~NORMAL_RED),
_C(~NORMAL_BLACK),
  129 #undef  _C
  130 };
  132 /* True if color is gray */
  133 const u_char rasops_isgray[16] = {
  134         1, 0, 0, 0,
  135         0, 0, 0, 1,
  136         1, 0, 0, 0,
  137         0, 0, 0, 1
  138 };
  140 /* Generic functions */
  141 void    rasops_copycols(void *, int, int, int, int);
  142 void    rasops_copyrows(void *, int, int, int);
  143 int     rasops_mapchar(void *, int, u_int *);
  144 void    rasops_cursor(void *, int, int, int);
  145 int     rasops_alloc_cattr(void *, int, int, int, long *);
  146 int     rasops_alloc_mattr(void *, int, int, int, long *);
  147 void    rasops_do_cursor(struct rasops_info *);
  148 void    rasops_init_devcmap(struct rasops_info *);
  149 void    rasops_unpack_attr(void *, long, int *, int *, int *);
  150 #if NRASOPS_BSWAP > 0
  151 static void slow_ovbcopy(void *, void *, size_t);
  152 #endif
  153 #if NRASOPS_ROTATION > 0
  154 void    rasops_copychar(void *, int, int, int, int);
  155 void    rasops_copycols_rotated(void *, int, int, int, int);
  156 void    rasops_copyrows_rotated(void *, int, int, int);
  157 void    rasops_erasecols_rotated(void *, int, int, int, long);
  158 void    rasops_eraserows_rotated(void *, int, int, long);
  159 void    rasops_putchar_rotated(void *, int, int, u_int, long);
  160 void    rasops_rotate_font(int *);
  162 /*
  163  * List of all rotated fonts
  164  */
SLIST_HEAD(, rotatedfont) rotatedfonts = SLIST_HEAD_INITIALIZER(rotatedfonts);
  166 struct  rotatedfont {
SLIST_ENTRY(rotatedfont) rf_next;
  168         int rf_cookie;
  169         int rf_rotated;
  170 };
  171 #endif
  173 /*
  174  * Initialize a 'rasops_info' descriptor.
  175  */
  176 int
rasops_init(ri, wantrows, wantcols)
  178         struct rasops_info *ri;
  179         int wantrows, wantcols;
  180 {
  182 #ifdef _KERNEL
  183         /* Select a font if the caller doesn't care */
  184         if (ri->ri_font == NULL) {
  185                 int cookie;
wsfont_init();
  189                 if (ri->ri_width > 80*12)
  190                         /* High res screen, choose a big font */
cookie = wsfont_find(NULL, 12, 0, 0);
  192                 else
  193                         /*  lower res, choose a 8 pixel wide font */
cookie = wsfont_find(NULL, 8, 0, 0);
  196                 if (cookie <= 0)
cookie = wsfont_find(NULL, 0, 0, 0);
  199                 if (cookie <= 0) {
printf("rasops_init: font table is empty\n");
  201                         return (-1);
  202                 }
  204 #if NRASOPS_ROTATION > 0
  205                 /*
  206                  * Pick the rotated version of this font. This will create it
  207                  * if necessary.
  208                  */
  209                 if (ri->ri_flg & RI_ROTATE_CW)
rasops_rotate_font(&cookie);
  211 #endif
  213                 if (wsfont_lock(cookie, &ri->ri_font,
WSDISPLAY_FONTORDER_L2R, WSDISPLAY_FONTORDER_L2R) <= 0) {
printf("rasops_init: couldn't lock font\n");
  216                         return (-1);
  217                 }
ri->ri_wsfcookie = cookie;
  220         }
  221 #endif
  223         /* This should never happen in reality... */
  224 #ifdef DEBUG
  225         if ((long)ri->ri_bits & 3) {
printf("rasops_init: bits not aligned on 32-bit boundary\n");
  227                 return (-1);
  228         }
  230         if ((int)ri->ri_stride & 3) {
printf("rasops_init: stride not aligned on 32-bit boundary\n");
  232                 return (-1);
  233         }
  234 #endif
  236         if (rasops_reconfig(ri, wantrows, wantcols))
  237                 return (-1);
rasops_init_devcmap(ri);
  240         return (0);
  241 }
  243 /*
  244  * Reconfigure (because parameters have changed in some way).
  245  */
  246 int
rasops_reconfig(ri, wantrows, wantcols)
  248         struct rasops_info *ri;
  249         int wantrows, wantcols;
  250 {
  251         int l, bpp, s;
s = splhigh();
  255         if (ri->ri_font->fontwidth > 32 || ri->ri_font->fontwidth < 4)
panic("rasops_init: fontwidth assumptions botched!");
  258         /* Need this to frob the setup below */
bpp = (ri->ri_depth == 15 ? 16 : ri->ri_depth);
  261         if ((ri->ri_flg & RI_CFGDONE) != 0)
ri->ri_bits = ri->ri_origbits;
  264         /* Don't care if the caller wants a hideously small console */
  265         if (wantrows < 10)
wantrows = 10;
  268         if (wantcols < 20)
wantcols = 20;
  271         /* Now constrain what they get */
ri->ri_emuwidth = ri->ri_font->fontwidth * wantcols;
ri->ri_emuheight = ri->ri_font->fontheight * wantrows;
  275         if (ri->ri_emuwidth > ri->ri_width)
ri->ri_emuwidth = ri->ri_width;
  278         if (ri->ri_emuheight > ri->ri_height)
ri->ri_emuheight = ri->ri_height;
  281         /* Reduce width until aligned on a 32-bit boundary */
  282         while ((ri->ri_emuwidth * bpp & 31) != 0)
ri->ri_emuwidth--;
  285 #if NRASOPS_ROTATION > 0
  286         if (ri->ri_flg & RI_ROTATE_CW) {
ri->ri_rows = ri->ri_emuwidth / ri->ri_font->fontwidth;
ri->ri_cols = ri->ri_emuheight / ri->ri_font->fontheight;
  289         } else
  290 #endif
  291         {
ri->ri_cols = ri->ri_emuwidth / ri->ri_font->fontwidth;
ri->ri_rows = ri->ri_emuheight / ri->ri_font->fontheight;
  294         }
ri->ri_emustride = ri->ri_emuwidth * bpp >> 3;
ri->ri_delta = ri->ri_stride - ri->ri_emustride;
ri->ri_ccol = 0;
ri->ri_crow = 0;
ri->ri_pelbytes = bpp >> 3;
ri->ri_xscale = (ri->ri_font->fontwidth * bpp) >> 3;
ri->ri_yscale = ri->ri_font->fontheight * ri->ri_stride;
ri->ri_fontscale = ri->ri_font->fontheight * ri->ri_font->stride;
  305 #ifdef DEBUG
  306         if ((ri->ri_delta & 3) != 0)
panic("rasops_init: ri_delta not aligned on 32-bit boundary");
  308 #endif
  309         /* Clear the entire display */
  310         if ((ri->ri_flg & RI_CLEAR) != 0) {
memset(ri->ri_bits, 0, ri->ri_stride * ri->ri_height);
ri->ri_flg &= ~RI_CLEARMARGINS;
  313         }
  315         /* Now centre our window if needs be */
ri->ri_origbits = ri->ri_bits;
  318         if ((ri->ri_flg & RI_CENTER) != 0) {
ri->ri_bits += (((ri->ri_width * bpp >> 3) -
ri->ri_emustride) >> 1) & ~3;
ri->ri_bits += ((ri->ri_height - ri->ri_emuheight) >> 1) *
ri->ri_stride;
ri->ri_yorigin = (int)(ri->ri_bits - ri->ri_origbits)
  325                    / ri->ri_stride;
ri->ri_xorigin = (((int)(ri->ri_bits - ri->ri_origbits)
  327                    % ri->ri_stride) * 8 / bpp);
  328         } else
ri->ri_xorigin = ri->ri_yorigin = 0;
  331         /* Clear the margins */
  332         if ((ri->ri_flg & RI_CLEARMARGINS) != 0) {
memset(ri->ri_origbits, 0, ri->ri_bits - ri->ri_origbits);
  334                 for (l = 0; l < ri->ri_emuheight; l++)
memset(ri->ri_bits + ri->ri_emustride +
l * ri->ri_stride, 0,
ri->ri_stride - ri->ri_emustride);
memset(ri->ri_bits + ri->ri_emuheight * ri->ri_stride, 0,
  339                     (ri->ri_origbits + ri->ri_height * ri->ri_stride) -
  340                     (ri->ri_bits + ri->ri_emuheight * ri->ri_stride));
  341         }
  343         /*
  344          * Fill in defaults for operations set.  XXX this nukes private
  345          * routines used by accelerated fb drivers.
  346          */
ri->ri_ops.mapchar = rasops_mapchar;
ri->ri_ops.copyrows = rasops_copyrows;
ri->ri_ops.copycols = rasops_copycols;
ri->ri_ops.erasecols = rasops_erasecols;
ri->ri_ops.eraserows = rasops_eraserows;
ri->ri_ops.cursor = rasops_cursor;
ri->ri_ops.unpack_attr = rasops_unpack_attr;
ri->ri_do_cursor = rasops_do_cursor;
ri->ri_updatecursor = NULL;
  357         if (ri->ri_depth < 8 || (ri->ri_flg & RI_FORCEMONO) != 0) {
ri->ri_ops.alloc_attr = rasops_alloc_mattr;
ri->ri_caps = WSSCREEN_UNDERLINE | WSSCREEN_REVERSE;
  360         } else {
ri->ri_ops.alloc_attr = rasops_alloc_cattr;
ri->ri_caps = WSSCREEN_UNDERLINE | WSSCREEN_HILIT |
WSSCREEN_WSCOLORS | WSSCREEN_REVERSE;
  364         }
  366         switch (ri->ri_depth) {
  367 #if NRASOPS1 > 0
  368         case 1:
rasops1_init(ri);
  370                 break;
  371 #endif
  372 #if NRASOPS2 > 0
  373         case 2:
rasops2_init(ri);
  375                 break;
  376 #endif
  377 #if NRASOPS4 > 0
  378         case 4:
rasops4_init(ri);
  380                 break;
  381 #endif
  382 #if NRASOPS8 > 0
  383         case 8:
rasops8_init(ri);
  385                 break;
  386 #endif
  387 #if NRASOPS15 > 0 || NRASOPS16 > 0
  388         case 15:
  389         case 16:
rasops15_init(ri);
  391                 break;
  392 #endif
  393 #if NRASOPS24 > 0
  394         case 24:
rasops24_init(ri);
  396                 break;
  397 #endif
  398 #if NRASOPS32 > 0
  399         case 32:
rasops32_init(ri);
  401                 break;
  402 #endif
  403         default:
ri->ri_flg &= ~RI_CFGDONE;
splx(s);
  406                 return (-1);
  407         }
  409 #if NRASOPS_ROTATION > 0
  410         if (ri->ri_flg & RI_ROTATE_CW) {
ri->ri_real_ops = ri->ri_ops;
ri->ri_ops.copycols = rasops_copycols_rotated;
ri->ri_ops.copyrows = rasops_copyrows_rotated;
ri->ri_ops.erasecols = rasops_erasecols_rotated;
ri->ri_ops.eraserows = rasops_eraserows_rotated;
ri->ri_ops.putchar = rasops_putchar_rotated;
  417         }
  418 #endif
ri->ri_flg |= RI_CFGDONE;
splx(s);
  422         return (0);
  423 }
  425 /*
  426  * Map a character.
  427  */
  428 int
rasops_mapchar(cookie, c, cp)
  430         void *cookie;
  431         int c;
u_int *cp;
  433 {
  434         struct rasops_info *ri;
ri = (struct rasops_info *)cookie;
  438 #ifdef DIAGNOSTIC
  439         if (ri->ri_font == NULL)
panic("rasops_mapchar: no font selected");
  441 #endif
  442         if (ri->ri_font->encoding != WSDISPLAY_FONTENC_ISO) {
  444                 if ( (c = wsfont_map_unichar(ri->ri_font, c)) < 0) {
  446                         *cp = ' ';
  447                         return (0);
  449                 }
  450         }
  453         if (c < ri->ri_font->firstchar) {
  454                 *cp = ' ';
  455                 return (0);
  456         }
  458         if (c - ri->ri_font->firstchar >= ri->ri_font->numchars) {
  459                 *cp = ' ';
  460                 return (0);
  461         }
  463         *cp = c;
  464         return (5);
  465 }
  467 /*
  468  * Allocate a color attribute.
  469  */
  470 int
rasops_alloc_cattr(cookie, fg, bg, flg, attr)
  472         void *cookie;
  473         int fg, bg, flg;
  474         long *attr;
  475 {
  476         int swap;
  478 #ifdef RASOPS_CLIPPING
fg &= 7;
bg &= 7;
  481 #endif
  482         if ((flg & WSATTR_BLINK) != 0)
  483                 return (EINVAL);
  485         if ((flg & WSATTR_WSCOLORS) == 0) {
fg = WSCOL_WHITE;
bg = WSCOL_BLACK;
  488         }
  490         if ((flg & WSATTR_REVERSE) != 0) {
swap = fg;
fg = bg;
bg = swap;
  494         }
  496         if ((flg & WSATTR_HILIT) != 0)
fg += 8;
flg = ((flg & WSATTR_UNDERLINE) ? 1 : 0);
  501         if (rasops_isgray[fg])
flg |= 2;
  504         if (rasops_isgray[bg])
flg |= 4;
  507         *attr = (bg << 16) | (fg << 24) | flg;
  508         return (0);
  509 }
  511 /*
  512  * Allocate a mono attribute.
  513  */
  514 int
rasops_alloc_mattr(cookie, fg, bg, flg, attr)
  516         void *cookie;
  517         int fg, bg, flg;
  518         long *attr;
  519 {
  520         int swap;
  522         if ((flg & (WSATTR_BLINK | WSATTR_HILIT | WSATTR_WSCOLORS)) != 0)
  523                 return (EINVAL);
fg = 1;
bg = 0;
  528         if ((flg & WSATTR_REVERSE) != 0) {
swap = fg;
fg = bg;
bg = swap;
  532         }
  534         *attr = (bg << 16) | (fg << 24) | ((flg & WSATTR_UNDERLINE) ? 7 : 6);
  535         return (0);
  536 }
  538 /*
  539  * Copy rows.
  540  */
  541 void
rasops_copyrows(cookie, src, dst, num)
  543         void *cookie;
  544         int src, dst, num;
  545 {
int32_t *sp, *dp, *srp, *drp;
  547         struct rasops_info *ri;
  548         int n8, n1, cnt, delta;
ri = (struct rasops_info *)cookie;
  552 #ifdef RASOPS_CLIPPING
  553         if (dst == src)
  554                 return;
  556         if (src < 0) {
num += src;
src = 0;
  559         }
  561         if ((src + num) > ri->ri_rows)
num = ri->ri_rows - src;
  564         if (dst < 0) {
num += dst;
dst = 0;
  567         }
  569         if ((dst + num) > ri->ri_rows)
num = ri->ri_rows - dst;
  572         if (num <= 0)
  573                 return;
  574 #endif
num *= ri->ri_font->fontheight;
n8 = ri->ri_emustride >> 5;
n1 = (ri->ri_emustride >> 2) & 7;
  580         if (dst < src) {
srp = (int32_t *)(ri->ri_bits + src * ri->ri_yscale);
drp = (int32_t *)(ri->ri_bits + dst * ri->ri_yscale);
delta = ri->ri_stride;
  584         } else {
src = ri->ri_font->fontheight * src + num - 1;
dst = ri->ri_font->fontheight * dst + num - 1;
srp = (int32_t *)(ri->ri_bits + src * ri->ri_stride);
drp = (int32_t *)(ri->ri_bits + dst * ri->ri_stride);
delta = -ri->ri_stride;
  590         }
  592         while (num--) {
dp = drp;
sp = srp;
DELTA(drp, delta, int32_t *);
DELTA(srp, delta, int32_t *);
  598                 for (cnt = n8; cnt; cnt--) {
dp[0] = sp[0];
dp[1] = sp[1];
dp[2] = sp[2];
dp[3] = sp[3];
dp[4] = sp[4];
dp[5] = sp[5];
dp[6] = sp[6];
dp[7] = sp[7];
dp += 8;
sp += 8;
  609                 }
  611                 for (cnt = n1; cnt; cnt--)
  612                         *dp++ = *sp++;
  613         }
  614 }
  616 /*
  617  * Copy columns. This is slow, and hard to optimize due to alignment,
  618  * and the fact that we have to copy both left->right and right->left.
  619  * We simply cop-out here and use ovbcopy(), since it handles all of
  620  * these cases anyway.
  621  */
  622 void
rasops_copycols(cookie, row, src, dst, num)
  624         void *cookie;
  625         int row, src, dst, num;
  626 {
  627         struct rasops_info *ri;
u_char *sp, *dp;
  629         int height;
ri = (struct rasops_info *)cookie;
  633 #ifdef RASOPS_CLIPPING
  634         if (dst == src)
  635                 return;
  637         /* Catches < 0 case too */
  638         if ((unsigned)row >= (unsigned)ri->ri_rows)
  639                 return;
  641         if (src < 0) {
num += src;
src = 0;
  644         }
  646         if ((src + num) > ri->ri_cols)
num = ri->ri_cols - src;
  649         if (dst < 0) {
num += dst;
dst = 0;
  652         }
  654         if ((dst + num) > ri->ri_cols)
num = ri->ri_cols - dst;
  657         if (num <= 0)
  658                 return;
  659 #endif
num *= ri->ri_xscale;
row *= ri->ri_yscale;
height = ri->ri_font->fontheight;
sp = ri->ri_bits + row + src * ri->ri_xscale;
dp = ri->ri_bits + row + dst * ri->ri_xscale;
  668 #if NRASOPS_BSWAP > 0
  669         if (ri->ri_flg & RI_BSWAP) {
  670                 while (height--) {
slow_ovbcopy(sp, dp, num);
dp += ri->ri_stride;
sp += ri->ri_stride;
  674                 }
  675         } else
  676 #endif
  677         {
  678                 while (height--) {
ovbcopy(sp, dp, num);
dp += ri->ri_stride;
sp += ri->ri_stride;
  682                 }
  683         }
  684 }
  686 /*
  687  * Turn cursor off/on.
  688  */
  689 void
rasops_cursor(cookie, on, row, col)
  691         void *cookie;
  692         int on, row, col;
  693 {
  694         struct rasops_info *ri;
ri = (struct rasops_info *)cookie;
  698         /* Turn old cursor off */
  699         if ((ri->ri_flg & RI_CURSOR) != 0)
  700 #ifdef RASOPS_CLIPPING
  701                 if ((ri->ri_flg & RI_CURSORCLIP) == 0)
  702 #endif
ri->ri_do_cursor(ri);
  705         /* Select new cursor */
  706 #ifdef RASOPS_CLIPPING
ri->ri_flg &= ~RI_CURSORCLIP;
  709         if (row < 0 || row >= ri->ri_rows)
ri->ri_flg |= RI_CURSORCLIP;
  711         else if (col < 0 || col >= ri->ri_cols)
ri->ri_flg |= RI_CURSORCLIP;
  713 #endif
ri->ri_crow = row;
ri->ri_ccol = col;
  717         if (ri->ri_updatecursor != NULL)
ri->ri_updatecursor(ri);
  720         if (on) {
ri->ri_flg |= RI_CURSOR;
  722 #ifdef RASOPS_CLIPPING
  723                 if ((ri->ri_flg & RI_CURSORCLIP) == 0)
  724 #endif
ri->ri_do_cursor(ri);
  726         } else
ri->ri_flg &= ~RI_CURSOR;
  728 }
  730 /*
  731  * Make the device colormap
  732  */
  733 void
rasops_init_devcmap(ri)
  735         struct rasops_info *ri;
  736 {
  737         int i;
  738 #if NRASOPS15 > 0 || NRASOPS16 > 0 || NRASOPS24 > 0 || NRASOPS32 > 0
  739         const u_char *p;
  740 #endif
  741 #if NRASOPS4 > 0 || NRASOPS15 > 0 || NRASOPS16 > 0 || NRASOPS24 > 0 || NRASOPS32 > 0
  742         int c;
  743 #endif
  745         switch (ri->ri_depth) {
  746 #if NRASOPS1 > 0
  747         case 1:
ri->ri_devcmap[0] = 0;
  749                 for (i = 1; i < 16; i++)
ri->ri_devcmap[i] = 0xffffffff;
  751                 return;
  752 #endif
  753 #if NRASOPS2 > 0
  754         case 2:
  755                 for (i = 1; i < 15; i++)
ri->ri_devcmap[i] = 0xaaaaaaaa;
ri->ri_devcmap[0] = 0;
ri->ri_devcmap[8] = 0x55555555;
ri->ri_devcmap[15] = 0xffffffff;
  761                 return;
  762 #endif
  763 #if NRASOPS4 > 0
  764         case 4:
  765                 for (i = 0; i < 16; i++) {
c = i | (i << 4);
ri->ri_devcmap[i] = c | (c<<8) | (c<<16) | (c<<24);
  768                 }
  769                 return;
  770 #endif
  771 #if NRASOPS8 > 0
  772         case 8:
  773                 for (i = 0; i < 16; i++)
ri->ri_devcmap[i] = i | (i<<8) | (i<<16) | (i<<24);
  775                 return;
  776 #endif
  777         default:
  778                 break;
  779         }
  781 #if NRASOPS15 > 0 || NRASOPS16 > 0 || NRASOPS24 > 0 || NRASOPS32 > 0
p = rasops_cmap;
  784         for (i = 0; i < 16; i++) {
  785                 if (ri->ri_rnum <= 8)
c = (*p >> (8 - ri->ri_rnum)) << ri->ri_rpos;
  787                 else
c = (*p << (ri->ri_rnum - 8)) << ri->ri_rpos;
p++;
  791                 if (ri->ri_gnum <= 8)
c |= (*p >> (8 - ri->ri_gnum)) << ri->ri_gpos;
  793                 else
c |= (*p << (ri->ri_gnum - 8)) << ri->ri_gpos;
p++;
  797                 if (ri->ri_bnum <= 8)
c |= (*p >> (8 - ri->ri_bnum)) << ri->ri_bpos;
  799                 else
c |= (*p << (ri->ri_bnum - 8)) << ri->ri_bpos;
p++;
  803                 /* Fill the word for generic routines, which want this */
  804                 if (ri->ri_depth == 24)
c = c | ((c & 0xff) << 24);
  806                 else if (ri->ri_depth <= 16)
c = c | (c << 16);
  809                 /* 24bpp does bswap on the fly. {32,16,15}bpp do it here. */
  810 #if NRASOPS_BSWAP > 0
  811                 if ((ri->ri_flg & RI_BSWAP) == 0)
ri->ri_devcmap[i] = c;
  813                 else if (ri->ri_depth == 32)
ri->ri_devcmap[i] = swap32(c);
  815                 else if (ri->ri_depth == 16 || ri->ri_depth == 15)
ri->ri_devcmap[i] = swap16(c);
  817                 else
ri->ri_devcmap[i] = c;
  819 #else
ri->ri_devcmap[i] = c;
  821 #endif
  822         }
  823 #endif
  824 }
  826 /*
  827  * Unpack a rasops attribute
  828  */
  829 void
rasops_unpack_attr(cookie, attr, fg, bg, underline)
  831         void *cookie;
  832         long attr;
  833         int *fg, *bg, *underline;
  834 {
  835         *fg = ((u_int)attr >> 24) & 0xf;
  836         *bg = ((u_int)attr >> 16) & 0xf;
  837         if (underline != NULL)
  838                 *underline = (u_int)attr & 1;
  839 }
  841 /*
  842  * Erase rows
  843  */
  844 void
rasops_eraserows(cookie, row, num, attr)
  846         void *cookie;
  847         int row, num;
  848         long attr;
  849 {
  850         struct rasops_info *ri;
  851         int np, nw, cnt, delta;
int32_t *dp, clr;
ri = (struct rasops_info *)cookie;
  856 #ifdef RASOPS_CLIPPING
  857         if (row < 0) {
num += row;
row = 0;
  860         }
  862         if ((row + num) > ri->ri_rows)
num = ri->ri_rows - row;
  865         if (num <= 0)
  866                 return;
  867 #endif
clr = ri->ri_devcmap[(attr >> 16) & 0xf];
  871         /*
  872          * XXX The wsdisplay_emulops interface seems a little deficient in
  873          * that there is no way to clear the *entire* screen. We provide a
  874          * workaround here: if the entire console area is being cleared, and
  875          * the RI_FULLCLEAR flag is set, clear the entire display.
  876          */
  877         if (num == ri->ri_rows && (ri->ri_flg & RI_FULLCLEAR) != 0) {
np = ri->ri_stride >> 5;
nw = (ri->ri_stride >> 2) & 7;
num = ri->ri_height;
dp = (int32_t *)ri->ri_origbits;
delta = 0;
  883         } else {
np = ri->ri_emustride >> 5;
nw = (ri->ri_emustride >> 2) & 7;
num *= ri->ri_font->fontheight;
dp = (int32_t *)(ri->ri_bits + row * ri->ri_yscale);
delta = ri->ri_delta;
  889         }
  891         while (num--) {
  892                 for (cnt = np; cnt; cnt--) {
dp[0] = clr;
dp[1] = clr;
dp[2] = clr;
dp[3] = clr;
dp[4] = clr;
dp[5] = clr;
dp[6] = clr;
dp[7] = clr;
dp += 8;
  902                 }
  904                 for (cnt = nw; cnt; cnt--) {
  905                         *(int32_t *)dp = clr;
DELTA(dp, 4, int32_t *);
  907                 }
DELTA(dp, delta, int32_t *);
  910         }
  911 }
  913 /*
  914  * Actually turn the cursor on or off. This does the dirty work for
  915  * rasops_cursor().
  916  */
  917 void
rasops_do_cursor(ri)
  919         struct rasops_info *ri;
  920 {
  921         int full1, height, cnt, slop1, slop2, row, col;
u_char *dp, *rp;
  924 #if NRASOPS_ROTATION > 0
  925         if (ri->ri_flg & RI_ROTATE_CW) {
  926                 /* Rotate rows/columns */
row = ri->ri_ccol;
col = ri->ri_rows - ri->ri_crow - 1;
  929         } else
  930 #endif
  931         {
row = ri->ri_crow;
col = ri->ri_ccol;
  934         }
rp = ri->ri_bits + row * ri->ri_yscale + col * ri->ri_xscale;
height = ri->ri_font->fontheight;
slop1 = (4 - ((long)rp & 3)) & 3;
  940         if (slop1 > ri->ri_xscale)
slop1 = ri->ri_xscale;
slop2 = (ri->ri_xscale - slop1) & 3;
full1 = (ri->ri_xscale - slop1 - slop2) >> 2;
  946         if ((slop1 | slop2) == 0) {
  947                 /* A common case */
  948                 while (height--) {
dp = rp;
rp += ri->ri_stride;
  952                         for (cnt = full1; cnt; cnt--) {
  953                                 *(int32_t *)dp ^= ~0;
dp += 4;
  955                         }
  956                 }
  957         } else {
  958                 /* XXX this is stupid.. use masks instead */
  959                 while (height--) {
dp = rp;
rp += ri->ri_stride;
  963                         if (slop1 & 1)
  964                                 *dp++ ^= ~0;
  966                         if (slop1 & 2) {
  967                                 *(int16_t *)dp ^= ~0;
dp += 2;
  969                         }
  971                         for (cnt = full1; cnt; cnt--) {
  972                                 *(int32_t *)dp ^= ~0;
dp += 4;
  974                         }
  976                         if (slop2 & 1)
  977                                 *dp++ ^= ~0;
  979                         if (slop2 & 2)
  980                                 *(int16_t *)dp ^= ~0;
  981                 }
  982         }
  983 }
  985 /*
  986  * Erase columns.
  987  */
  988 void
rasops_erasecols(cookie, row, col, num, attr)
  990         void *cookie;
  991         int row, col, num;
  992         long attr;
  993 {
  994         int n8, height, cnt, slop1, slop2, clr;
  995         struct rasops_info *ri;
int32_t *rp, *dp;
ri = (struct rasops_info *)cookie;
 1000 #ifdef RASOPS_CLIPPING
 1001         if ((unsigned)row >= (unsigned)ri->ri_rows)
 1002                 return;
 1004         if (col < 0) {
num += col;
col = 0;
 1007         }
 1009         if ((col + num) > ri->ri_cols)
num = ri->ri_cols - col;
 1012         if (num <= 0)
 1013                 return;
 1014 #endif
num = num * ri->ri_xscale;
rp = (int32_t *)(ri->ri_bits + row*ri->ri_yscale + col*ri->ri_xscale);
height = ri->ri_font->fontheight;
clr = ri->ri_devcmap[(attr >> 16) & 0xf];
 1021         /* Don't bother using the full loop for <= 32 pels */
 1022         if (num <= 32) {
 1023                 if (((num | ri->ri_xscale) & 3) == 0) {
 1024                         /* Word aligned blt */
num >>= 2;
 1027                         while (height--) {
dp = rp;
DELTA(rp, ri->ri_stride, int32_t *);
 1031                                 for (cnt = num; cnt; cnt--)
 1032                                         *dp++ = clr;
 1033                         }
 1034                 } else if (((num | ri->ri_xscale) & 1) == 0) {
 1035                         /*
 1036                          * Halfword aligned blt. This is needed so the
 1037                          * 15/16 bit ops can use this function.
 1038                          */
num >>= 1;
 1041                         while (height--) {
dp = rp;
DELTA(rp, ri->ri_stride, int32_t *);
 1045                                 for (cnt = num; cnt; cnt--) {
 1046                                         *(int16_t *)dp = clr;
DELTA(dp, 2, int32_t *);
 1048                                 }
 1049                         }
 1050                 } else {
 1051                         while (height--) {
dp = rp;
DELTA(rp, ri->ri_stride, int32_t *);
 1055                                 for (cnt = num; cnt; cnt--) {
 1056                                         *(u_char *)dp = clr;
DELTA(dp, 1, int32_t *);
 1058                                 }
 1059                         }
 1060                 }
 1062                 return;
 1063         }
slop1 = (4 - ((long)rp & 3)) & 3;
slop2 = (num - slop1) & 3;
num -= slop1 + slop2;
n8 = num >> 5;
num = (num >> 2) & 7;
 1071         while (height--) {
dp = rp;
DELTA(rp, ri->ri_stride, int32_t *);
 1075                 /* Align span to 4 bytes */
 1076                 if (slop1 & 1) {
 1077                         *(u_char *)dp = clr;
DELTA(dp, 1, int32_t *);
 1079                 }
 1081                 if (slop1 & 2) {
 1082                         *(int16_t *)dp = clr;
DELTA(dp, 2, int32_t *);
 1084                 }
 1086                 /* Write 32 bytes per loop */
 1087                 for (cnt = n8; cnt; cnt--) {
dp[0] = clr;
dp[1] = clr;
dp[2] = clr;
dp[3] = clr;
dp[4] = clr;
dp[5] = clr;
dp[6] = clr;
dp[7] = clr;
dp += 8;
 1097                 }
 1099                 /* Write 4 bytes per loop */
 1100                 for (cnt = num; cnt; cnt--)
 1101                         *dp++ = clr;
 1103                 /* Write unaligned trailing slop */
 1104                 if (slop2 & 1) {
 1105                         *(u_char *)dp = clr;
DELTA(dp, 1, int32_t *);
 1107                 }
 1109                 if (slop2 & 2)
 1110                         *(int16_t *)dp = clr;
 1111         }
 1112 }
 1114 #if NRASOPS_ROTATION > 0
 1115 /*
 1116  * Quarter clockwise rotation routines (originally intended for the
 1117  * built-in Zaurus C3x00 display in 16bpp).
 1118  */
 1120 #include <sys/malloc.h>
 1122 void
rasops_rotate_font(int *cookie)
 1124 {
 1125         struct rotatedfont *f;
 1126         int ncookie;
SLIST_FOREACH(f, &rotatedfonts, rf_next) {
 1129                 if (f->rf_cookie == *cookie) {
 1130                         *cookie = f->rf_rotated;
 1131                         return;
 1132                 }
 1133         }
 1135         /*
 1136          * We did not find a rotated version of this font. Ask the wsfont
 1137          * code to compute one for us.
 1138          */
f = malloc(sizeof(struct rotatedfont), M_DEVBUF, M_WAITOK);
 1141         if (f == NULL)
 1142                 return;
 1144         if ((ncookie = wsfont_rotate(*cookie)) == -1)
 1145                 return;
f->rf_cookie = *cookie;
f->rf_rotated = ncookie;
SLIST_INSERT_HEAD(&rotatedfonts, f, rf_next);
 1151         *cookie = ncookie;
 1152 }
 1154 void
rasops_copychar(cookie, srcrow, dstrow, srccol, dstcol)
 1156         void *cookie;
 1157         int srcrow, dstrow, srccol, dstcol;
 1158 {
 1159         struct rasops_info *ri;
u_char *sp, *dp;
 1161         int height;
 1162         int r_srcrow, r_dstrow, r_srccol, r_dstcol;
ri = (struct rasops_info *)cookie;
r_srcrow = srccol;
r_dstrow = dstcol;
r_srccol = ri->ri_rows - srcrow - 1;
r_dstcol = ri->ri_rows - dstrow - 1;
r_srcrow *= ri->ri_yscale;
r_dstrow *= ri->ri_yscale;
height = ri->ri_font->fontheight;
sp = ri->ri_bits + r_srcrow + r_srccol * ri->ri_xscale;
dp = ri->ri_bits + r_dstrow + r_dstcol * ri->ri_xscale;
 1178 #if NRASOPS_BSWAP > 0
 1179         if (ri->ri_flg & RI_BSWAP) {
 1180                 while (height--) {
slow_ovbcopy(sp, dp, ri->ri_xscale);
dp += ri->ri_stride;
sp += ri->ri_stride;
 1184                 }
 1185         } else
 1186 #endif
 1187         {
 1188                 while (height--) {
ovbcopy(sp, dp, ri->ri_xscale);
dp += ri->ri_stride;
sp += ri->ri_stride;
 1192                 }
 1193         }
 1194 }
 1196 void
rasops_putchar_rotated(cookie, row, col, uc, attr)
 1198         void *cookie;
 1199         int row, col;
u_int uc;
 1201         long attr;
 1202 {
 1203         struct rasops_info *ri;
u_char *rp;
 1205         int height;
ri = (struct rasops_info *)cookie;
 1209         /* Do rotated char sans (side)underline */
ri->ri_real_ops.putchar(cookie, col, ri->ri_rows - row - 1, uc,
attr & ~1);
 1213         /* Do rotated underline */
rp = ri->ri_bits + col * ri->ri_yscale + (ri->ri_rows - row - 1) * 
ri->ri_xscale;
height = ri->ri_font->fontheight;
 1218         /* XXX this assumes 16-bit color depth */
 1219         if ((attr & 1) != 0) {
int16_t c = (int16_t)ri->ri_devcmap[((u_int)attr >> 24) & 0xf];
 1222                 while (height--) {
 1223                         *(int16_t *)rp = c;
rp += ri->ri_stride;
 1225                 }
 1226         }
 1227 }
 1229 void
rasops_erasecols_rotated(cookie, row, col, num, attr)
 1231         void *cookie;
 1232         int row, col, num;
 1233         long attr;
 1234 {
 1235         struct rasops_info *ri;
 1236         int i;
ri = (struct rasops_info *)cookie;
 1240         for (i = col; i < col + num; i++)
ri->ri_ops.putchar(cookie, row, i, ' ', attr);
 1242 }
 1244 /* XXX: these could likely be optimised somewhat. */
 1245 void
rasops_copyrows_rotated(cookie, src, dst, num)
 1247         void *cookie;
 1248         int src, dst, num;
 1249 {
 1250         struct rasops_info *ri = (struct rasops_info *)cookie;
 1251         int col, roff;
 1253         if (src > dst)
 1254                 for (roff = 0; roff < num; roff++)
 1255                         for (col = 0; col < ri->ri_cols; col++)
rasops_copychar(cookie, src + roff, dst + roff,
col, col);
 1258         else
 1259                 for (roff = num - 1; roff >= 0; roff--)
 1260                         for (col = 0; col < ri->ri_cols; col++)
rasops_copychar(cookie, src + roff, dst + roff,
col, col);
 1263 }
 1265 void
rasops_copycols_rotated(cookie, row, src, dst, num)
 1267         void *cookie;
 1268         int row, src, dst, num;
 1269 {
 1270         int coff;
 1272         if (src > dst)
 1273                 for (coff = 0; coff < num; coff++)
rasops_copychar(cookie, row, row, src + coff, dst + coff);
 1275         else
 1276                 for (coff = num - 1; coff >= 0; coff--)
rasops_copychar(cookie, row, row, src + coff, dst + coff);
 1278 }
 1280 void
rasops_eraserows_rotated(cookie, row, num, attr)
 1282         void *cookie;
 1283         int row, num;
 1284         long attr;
 1285 {
 1286         struct rasops_info *ri;
 1287         int col, rn;
ri = (struct rasops_info *)cookie;
 1291         for (rn = row; rn < row + num; rn++)
 1292                 for (col = 0; col < ri->ri_cols; col++)
ri->ri_ops.putchar(cookie, rn, col, ' ', attr);
 1294 }
 1295 #endif  /* NRASOPS_ROTATION */
 1297 #if NRASOPS_BSWAP > 0
 1298 /*
 1299  * Strictly byte-only ovbcopy() version, to be used with RI_BSWAP, as the
 1300  * regular ovbcopy() may want to optimize things by doing larger-than-byte
 1301  * reads or write. This may confuse things if src and dst have different
 1302  * alignments.
 1303  */
 1304 void
slow_ovbcopy(void *s, void *d, size_t len)
 1306 {
u_int8_t *src = s;
u_int8_t *dst = d;
 1310         if ((vaddr_t)dst <= (vaddr_t)src) {
 1311                 while (len-- != 0)
 1312                         *dst++ = *src++;
 1313         } else {
src += len;
dst += len;
 1316                 if (len != 0)
 1317                         while (--len != 0)
 1318                                 *--dst = *--src;
 1319         }
 1320 }
 1321 #endif  /* NRASOPS_BSWAP */