1 /* $NetBSD: rasops.c,v 1.58 2008/04/28 20:23:56 martin 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: rasops.c,v 1.58 2008/04/28 20:23:56 martin Exp $"); 34 35 #include "opt_rasops.h" 36 #include "rasops_glue.h" 37 #include "opt_wsmsgattrs.h" 38 39 #include <sys/param.h> 40 #include <sys/systm.h> 41 #include <sys/time.h> 42 43 #include <sys/bswap.h> 44 #include <machine/endian.h> 45 46 #include <dev/wscons/wsdisplayvar.h> 47 #include <dev/wscons/wsconsio.h> 48 #include <dev/wsfont/wsfont.h> 49 #include <dev/rasops/rasops.h> 50 51 #ifndef _KERNEL 52 #include <errno.h> 53 #endif 54 55 /* ANSI colormap (R,G,B). Upper 8 are high-intensity */ 56 const u_char rasops_cmap[256*3] = { 57 0x00, 0x00, 0x00, /* black */ 58 0x7f, 0x00, 0x00, /* red */ 59 0x00, 0x7f, 0x00, /* green */ 60 0x7f, 0x7f, 0x00, /* brown */ 61 0x00, 0x00, 0x7f, /* blue */ 62 0x7f, 0x00, 0x7f, /* magenta */ 63 0x00, 0x7f, 0x7f, /* cyan */ 64 0xc7, 0xc7, 0xc7, /* white - XXX too dim? */ 65 66 0x7f, 0x7f, 0x7f, /* black */ 67 0xff, 0x00, 0x00, /* red */ 68 0x00, 0xff, 0x00, /* green */ 69 0xff, 0xff, 0x00, /* brown */ 70 0x00, 0x00, 0xff, /* blue */ 71 0xff, 0x00, 0xff, /* magenta */ 72 0x00, 0xff, 0xff, /* cyan */ 73 0xff, 0xff, 0xff, /* white */ 74 75 /* 76 * For the cursor, we need at least the last (255th) 77 * color to be white. Fill up white completely for 78 * simplicity. 79 */ 80 #define _CMWHITE 0xff, 0xff, 0xff, 81 #define _CMWHITE16 _CMWHITE _CMWHITE _CMWHITE _CMWHITE \ 82 _CMWHITE _CMWHITE _CMWHITE _CMWHITE \ 83 _CMWHITE _CMWHITE _CMWHITE _CMWHITE \ 84 _CMWHITE _CMWHITE _CMWHITE _CMWHITE 85 _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16 86 _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16 87 _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16 /* but not the last one */ 88 #undef _CMWHITE16 89 #undef _CMWHITE 90 91 /* 92 * For the cursor the fg/bg indices are bit inverted, so 93 * provide complimentary colors in the upper 16 entries. 94 */ 95 0x7f, 0x7f, 0x7f, /* black */ 96 0xff, 0x00, 0x00, /* red */ 97 0x00, 0xff, 0x00, /* green */ 98 0xff, 0xff, 0x00, /* brown */ 99 0x00, 0x00, 0xff, /* blue */ 100 0xff, 0x00, 0xff, /* magenta */ 101 0x00, 0xff, 0xff, /* cyan */ 102 0xff, 0xff, 0xff, /* white */ 103 104 0x00, 0x00, 0x00, /* black */ 105 0x7f, 0x00, 0x00, /* red */ 106 0x00, 0x7f, 0x00, /* green */ 107 0x7f, 0x7f, 0x00, /* brown */ 108 0x00, 0x00, 0x7f, /* blue */ 109 0x7f, 0x00, 0x7f, /* magenta */ 110 0x00, 0x7f, 0x7f, /* cyan */ 111 0xc7, 0xc7, 0xc7, /* white - XXX too dim? */ 112 }; 113 114 /* True if color is gray */ 115 const u_char rasops_isgray[16] = { 116 1, 0, 0, 0, 117 0, 0, 0, 1, 118 1, 0, 0, 0, 119 0, 0, 0, 1 120 }; 121 122 /* Generic functions */ 123 static void rasops_copyrows(void *, int, int, int); 124 static int rasops_mapchar(void *, int, u_int *); 125 static void rasops_cursor(void *, int, int, int); 126 static int rasops_allocattr_color(void *, int, int, int, long *); 127 static int rasops_allocattr_mono(void *, int, int, int, long *); 128 static void rasops_do_cursor(struct rasops_info *); 129 static void rasops_init_devcmap(struct rasops_info *); 130 131 #if NRASOPS_ROTATION > 0 132 static void rasops_copychar(void *, int, int, int, int); 133 static void rasops_copycols_rotated(void *, int, int, int, int); 134 static void rasops_copyrows_rotated(void *, int, int, int); 135 static void rasops_erasecols_rotated(void *, int, int, int, long); 136 static void rasops_eraserows_rotated(void *, int, int, long); 137 static void rasops_putchar_rotated(void *, int, int, u_int, long); 138 static void rasops_rotate_font(int *); 139 140 /* 141 * List of all rotated fonts 142 */ 143 SLIST_HEAD(, rotatedfont) rotatedfonts = SLIST_HEAD_INITIALIZER(rotatedfonts); 144 struct rotatedfont { 145 SLIST_ENTRY(rotatedfont) rf_next; 146 int rf_cookie; 147 int rf_rotated; 148 }; 149 #endif /* NRASOPS_ROTATION > 0 */ 150 151 /* 152 * Initialize a 'rasops_info' descriptor. 153 */ 154 int 155 rasops_init(ri, wantrows, wantcols) 156 struct rasops_info *ri; 157 int wantrows, wantcols; 158 { 159 160 #ifdef _KERNEL 161 /* Select a font if the caller doesn't care */ 162 if (ri->ri_font == NULL) { 163 int cookie; 164 165 wsfont_init(); 166 167 /* Want 8 pixel wide, don't care about aestethics */ 168 cookie = wsfont_find(NULL, 8, 0, 0, WSDISPLAY_FONTORDER_L2R, 169 WSDISPLAY_FONTORDER_L2R); 170 if (cookie <= 0) 171 cookie = wsfont_find(NULL, 0, 0, 0, 172 WSDISPLAY_FONTORDER_L2R, WSDISPLAY_FONTORDER_L2R); 173 174 if (cookie <= 0) { 175 printf("rasops_init: font table is empty\n"); 176 return (-1); 177 } 178 179 #if NRASOPS_ROTATION > 0 180 /* 181 * Pick the rotated version of this font. This will create it 182 * if necessary. 183 */ 184 if (ri->ri_flg & RI_ROTATE_CW) 185 rasops_rotate_font(&cookie); 186 #endif 187 188 if (wsfont_lock(cookie, &ri->ri_font)) { 189 printf("rasops_init: couldn't lock font\n"); 190 return (-1); 191 } 192 193 ri->ri_wsfcookie = cookie; 194 } 195 #endif 196 197 /* This should never happen in reality... */ 198 #ifdef DEBUG 199 if ((long)ri->ri_bits & 3) { 200 printf("rasops_init: bits not aligned on 32-bit boundary\n"); 201 return (-1); 202 } 203 204 if ((int)ri->ri_stride & 3) { 205 printf("rasops_init: stride not aligned on 32-bit boundary\n"); 206 return (-1); 207 } 208 #endif 209 210 if (rasops_reconfig(ri, wantrows, wantcols)) 211 return (-1); 212 213 rasops_init_devcmap(ri); 214 return (0); 215 } 216 217 /* 218 * Reconfigure (because parameters have changed in some way). 219 */ 220 int 221 rasops_reconfig(ri, wantrows, wantcols) 222 struct rasops_info *ri; 223 int wantrows, wantcols; 224 { 225 int bpp, s; 226 227 s = splhigh(); 228 229 if (ri->ri_font->fontwidth > 32 || ri->ri_font->fontwidth < 4) 230 panic("rasops_init: fontwidth assumptions botched!"); 231 232 /* Need this to frob the setup below */ 233 bpp = (ri->ri_depth == 15 ? 16 : ri->ri_depth); 234 235 if ((ri->ri_flg & RI_CFGDONE) != 0) 236 ri->ri_bits = ri->ri_origbits; 237 238 /* Don't care if the caller wants a hideously small console */ 239 if (wantrows < 10) 240 wantrows = 10; 241 242 if (wantcols < 20) 243 wantcols = 20; 244 245 /* Now constrain what they get */ 246 ri->ri_emuwidth = ri->ri_font->fontwidth * wantcols; 247 ri->ri_emuheight = ri->ri_font->fontheight * wantrows; 248 249 if (ri->ri_emuwidth > ri->ri_width) 250 ri->ri_emuwidth = ri->ri_width; 251 252 if (ri->ri_emuheight > ri->ri_height) 253 ri->ri_emuheight = ri->ri_height; 254 255 /* Reduce width until aligned on a 32-bit boundary */ 256 while ((ri->ri_emuwidth * bpp & 31) != 0) 257 ri->ri_emuwidth--; 258 259 #if NRASOPS_ROTATION > 0 260 if (ri->ri_flg & RI_ROTATE_CW) { 261 ri->ri_rows = ri->ri_emuwidth / ri->ri_font->fontwidth; 262 ri->ri_cols = ri->ri_emuheight / ri->ri_font->fontheight; 263 } else 264 #endif 265 { 266 267 ri->ri_cols = ri->ri_emuwidth / ri->ri_font->fontwidth; 268 ri->ri_rows = ri->ri_emuheight / ri->ri_font->fontheight; 269 } 270 ri->ri_emustride = ri->ri_emuwidth * bpp >> 3; 271 ri->ri_delta = ri->ri_stride - ri->ri_emustride; 272 ri->ri_ccol = 0; 273 ri->ri_crow = 0; 274 ri->ri_pelbytes = bpp >> 3; 275 276 ri->ri_xscale = (ri->ri_font->fontwidth * bpp) >> 3; 277 ri->ri_yscale = ri->ri_font->fontheight * ri->ri_stride; 278 ri->ri_fontscale = ri->ri_font->fontheight * ri->ri_font->stride; 279 280 #ifdef DEBUG 281 if ((ri->ri_delta & 3) != 0) 282 panic("rasops_init: ri_delta not aligned on 32-bit boundary"); 283 #endif 284 /* Clear the entire display */ 285 if ((ri->ri_flg & RI_CLEAR) != 0) 286 memset(ri->ri_bits, 0, ri->ri_stride * ri->ri_height); 287 288 /* Now centre our window if needs be */ 289 ri->ri_origbits = ri->ri_bits; 290 291 if ((ri->ri_flg & RI_CENTER) != 0) { 292 ri->ri_bits += (((ri->ri_width * bpp >> 3) - 293 ri->ri_emustride) >> 1) & ~3; 294 ri->ri_bits += ((ri->ri_height - ri->ri_emuheight) >> 1) * 295 ri->ri_stride; 296 297 ri->ri_yorigin = (int)(ri->ri_bits - ri->ri_origbits) 298 / ri->ri_stride; 299 ri->ri_xorigin = (((int)(ri->ri_bits - ri->ri_origbits) 300 % ri->ri_stride) * 8 / bpp); 301 } else 302 ri->ri_xorigin = ri->ri_yorigin = 0; 303 304 /* 305 * Fill in defaults for operations set. XXX this nukes private 306 * routines used by accelerated fb drivers. 307 */ 308 ri->ri_ops.mapchar = rasops_mapchar; 309 ri->ri_ops.copyrows = rasops_copyrows; 310 ri->ri_ops.copycols = rasops_copycols; 311 ri->ri_ops.erasecols = rasops_erasecols; 312 ri->ri_ops.eraserows = rasops_eraserows; 313 ri->ri_ops.cursor = rasops_cursor; 314 ri->ri_do_cursor = rasops_do_cursor; 315 316 if (ri->ri_depth < 8 || (ri->ri_flg & RI_FORCEMONO) != 0) { 317 ri->ri_ops.allocattr = rasops_allocattr_mono; 318 ri->ri_caps = WSSCREEN_UNDERLINE | WSSCREEN_REVERSE; 319 } else { 320 ri->ri_ops.allocattr = rasops_allocattr_color; 321 ri->ri_caps = WSSCREEN_UNDERLINE | WSSCREEN_HILIT | 322 WSSCREEN_WSCOLORS | WSSCREEN_REVERSE; 323 } 324 325 switch (ri->ri_depth) { 326 #if NRASOPS1 > 0 327 case 1: 328 rasops1_init(ri); 329 break; 330 #endif 331 #if NRASOPS2 > 0 332 case 2: 333 rasops2_init(ri); 334 break; 335 #endif 336 #if NRASOPS4 > 0 337 case 4: 338 rasops4_init(ri); 339 break; 340 #endif 341 #if NRASOPS8 > 0 342 case 8: 343 rasops8_init(ri); 344 break; 345 #endif 346 #if NRASOPS15 > 0 || NRASOPS16 > 0 347 case 15: 348 case 16: 349 rasops15_init(ri); 350 break; 351 #endif 352 #if NRASOPS24 > 0 353 case 24: 354 rasops24_init(ri); 355 break; 356 #endif 357 #if NRASOPS32 > 0 358 case 32: 359 rasops32_init(ri); 360 break; 361 #endif 362 default: 363 ri->ri_flg &= ~RI_CFGDONE; 364 splx(s); 365 return (-1); 366 } 367 368 #if NRASOPS_ROTATION > 0 369 if (ri->ri_flg & RI_ROTATE_CW) { 370 ri->ri_real_ops = ri->ri_ops; 371 ri->ri_ops.copycols = rasops_copycols_rotated; 372 ri->ri_ops.copyrows = rasops_copyrows_rotated; 373 ri->ri_ops.erasecols = rasops_erasecols_rotated; 374 ri->ri_ops.eraserows = rasops_eraserows_rotated; 375 ri->ri_ops.putchar = rasops_putchar_rotated; 376 } 377 #endif 378 379 ri->ri_flg |= RI_CFGDONE; 380 splx(s); 381 return (0); 382 } 383 384 /* 385 * Map a character. 386 */ 387 static int 388 rasops_mapchar(cookie, c, cp) 389 void *cookie; 390 int c; 391 u_int *cp; 392 { 393 struct rasops_info *ri; 394 395 ri = (struct rasops_info *)cookie; 396 397 #ifdef DIAGNOSTIC 398 if (ri->ri_font == NULL) 399 panic("rasops_mapchar: no font selected"); 400 #endif 401 402 if (ri->ri_font->encoding != WSDISPLAY_FONTENC_ISO) { 403 if ( (c = wsfont_map_unichar(ri->ri_font, c)) < 0) { 404 *cp = ' '; 405 return (0); 406 407 } 408 } 409 410 if (c < ri->ri_font->firstchar) { 411 *cp = ' '; 412 return (0); 413 } 414 415 if (c - ri->ri_font->firstchar >= ri->ri_font->numchars) { 416 *cp = ' '; 417 return (0); 418 } 419 420 *cp = c; 421 return (5); 422 } 423 424 /* 425 * Allocate a color attribute. 426 */ 427 static int 428 rasops_allocattr_color(void *cookie, int fg, int bg, int flg, 429 long *attr) 430 { 431 int swap; 432 433 if (__predict_false((unsigned int)fg >= sizeof(rasops_isgray) || 434 (unsigned int)bg >= sizeof(rasops_isgray))) 435 return (EINVAL); 436 437 #ifdef RASOPS_CLIPPING 438 fg &= 7; 439 bg &= 7; 440 #endif 441 if ((flg & WSATTR_BLINK) != 0) 442 return (EINVAL); 443 444 if ((flg & WSATTR_WSCOLORS) == 0) { 445 #ifdef WS_DEFAULT_FG 446 fg = WS_DEFAULT_FG; 447 #else 448 fg = WSCOL_WHITE; 449 #endif 450 #ifdef WS_DEFAULT_BG 451 bg = WS_DEFAULT_BG; 452 #else 453 bg = WSCOL_BLACK; 454 #endif 455 } 456 457 if ((flg & WSATTR_REVERSE) != 0) { 458 swap = fg; 459 fg = bg; 460 bg = swap; 461 } 462 463 if ((flg & WSATTR_HILIT) != 0) 464 fg += 8; 465 466 flg = ((flg & WSATTR_UNDERLINE) ? 1 : 0); 467 468 if (rasops_isgray[fg]) 469 flg |= 2; 470 471 if (rasops_isgray[bg]) 472 flg |= 4; 473 474 *attr = (bg << 16) | (fg << 24) | flg; 475 return (0); 476 } 477 478 /* 479 * Allocate a mono attribute. 480 */ 481 static int 482 rasops_allocattr_mono(void *cookie, int fg, int bg, int flg, 483 long *attr) 484 { 485 int swap; 486 487 if ((flg & (WSATTR_BLINK | WSATTR_HILIT | WSATTR_WSCOLORS)) != 0) 488 return (EINVAL); 489 490 fg = 1; 491 bg = 0; 492 493 if ((flg & WSATTR_REVERSE) != 0) { 494 swap = fg; 495 fg = bg; 496 bg = swap; 497 } 498 499 *attr = (bg << 16) | (fg << 24) | ((flg & WSATTR_UNDERLINE) ? 7 : 6); 500 return (0); 501 } 502 503 /* 504 * Copy rows. 505 */ 506 static void 507 rasops_copyrows(cookie, src, dst, num) 508 void *cookie; 509 int src, dst, num; 510 { 511 int32_t *sp, *dp, *hp, *srp, *drp, *hrp; 512 struct rasops_info *ri; 513 int n8, n1, cnt, delta; 514 515 ri = (struct rasops_info *)cookie; 516 hp = hrp = NULL; 517 518 #ifdef RASOPS_CLIPPING 519 if (dst == src) 520 return; 521 522 if (src < 0) { 523 num += src; 524 src = 0; 525 } 526 527 if ((src + num) > ri->ri_rows) 528 num = ri->ri_rows - src; 529 530 if (dst < 0) { 531 num += dst; 532 dst = 0; 533 } 534 535 if ((dst + num) > ri->ri_rows) 536 num = ri->ri_rows - dst; 537 538 if (num <= 0) 539 return; 540 #endif 541 542 num *= ri->ri_font->fontheight; 543 n8 = ri->ri_emustride >> 5; 544 n1 = (ri->ri_emustride >> 2) & 7; 545 546 if (dst < src) { 547 srp = (int32_t *)(ri->ri_bits + src * ri->ri_yscale); 548 drp = (int32_t *)(ri->ri_bits + dst * ri->ri_yscale); 549 if (ri->ri_hwbits) 550 hrp = (int32_t *)(ri->ri_hwbits + dst * 551 ri->ri_yscale); 552 delta = ri->ri_stride; 553 } else { 554 src = ri->ri_font->fontheight * src + num - 1; 555 dst = ri->ri_font->fontheight * dst + num - 1; 556 srp = (int32_t *)(ri->ri_bits + src * ri->ri_stride); 557 drp = (int32_t *)(ri->ri_bits + dst * ri->ri_stride); 558 if (ri->ri_hwbits) 559 hrp = (int32_t *)(ri->ri_hwbits + dst * 560 ri->ri_stride); 561 562 delta = -ri->ri_stride; 563 } 564 565 while (num--) { 566 dp = drp; 567 sp = srp; 568 if (ri->ri_hwbits) 569 hp = hrp; 570 571 DELTA(drp, delta, int32_t *); 572 DELTA(srp, delta, int32_t *); 573 if (ri->ri_hwbits) 574 DELTA(hrp, delta, int32_t *); 575 576 for (cnt = n8; cnt; cnt--) { 577 dp[0] = sp[0]; 578 dp[1] = sp[1]; 579 dp[2] = sp[2]; 580 dp[3] = sp[3]; 581 dp[4] = sp[4]; 582 dp[5] = sp[5]; 583 dp[6] = sp[6]; 584 dp[7] = sp[7]; 585 dp += 8; 586 sp += 8; 587 } 588 if (ri->ri_hwbits) { 589 sp -= (8 * n8); 590 for (cnt = n8; cnt; cnt--) { 591 hp[0] = sp[0]; 592 hp[1] = sp[1]; 593 hp[2] = sp[2]; 594 hp[3] = sp[3]; 595 hp[4] = sp[4]; 596 hp[5] = sp[5]; 597 hp[6] = sp[6]; 598 hp[7] = sp[7]; 599 hp += 8; 600 sp += 8; 601 } 602 } 603 604 for (cnt = n1; cnt; cnt--) { 605 *dp++ = *sp++; 606 if (ri->ri_hwbits) 607 *hp++ = *(sp - 1); 608 } 609 } 610 } 611 612 /* 613 * Copy columns. This is slow, and hard to optimize due to alignment, 614 * and the fact that we have to copy both left->right and right->left. 615 * We simply cop-out here and use memmove(), since it handles all of 616 * these cases anyway. 617 */ 618 void 619 rasops_copycols(cookie, row, src, dst, num) 620 void *cookie; 621 int row, src, dst, num; 622 { 623 struct rasops_info *ri; 624 u_char *sp, *dp, *hp; 625 int height; 626 627 ri = (struct rasops_info *)cookie; 628 hp = NULL; 629 630 #ifdef RASOPS_CLIPPING 631 if (dst == src) 632 return; 633 634 /* Catches < 0 case too */ 635 if ((unsigned)row >= (unsigned)ri->ri_rows) 636 return; 637 638 if (src < 0) { 639 num += src; 640 src = 0; 641 } 642 643 if ((src + num) > ri->ri_cols) 644 num = ri->ri_cols - src; 645 646 if (dst < 0) { 647 num += dst; 648 dst = 0; 649 } 650 651 if ((dst + num) > ri->ri_cols) 652 num = ri->ri_cols - dst; 653 654 if (num <= 0) 655 return; 656 #endif 657 658 num *= ri->ri_xscale; 659 row *= ri->ri_yscale; 660 height = ri->ri_font->fontheight; 661 662 sp = ri->ri_bits + row + src * ri->ri_xscale; 663 dp = ri->ri_bits + row + dst * ri->ri_xscale; 664 if (ri->ri_hwbits) 665 hp = ri->ri_hwbits + row + dst * ri->ri_xscale; 666 667 while (height--) { 668 memmove(dp, sp, num); 669 if (ri->ri_hwbits) { 670 memcpy(hp, sp, num); 671 hp += ri->ri_stride; 672 } 673 dp += ri->ri_stride; 674 sp += ri->ri_stride; 675 } 676 } 677 678 /* 679 * Turn cursor off/on. 680 */ 681 static void 682 rasops_cursor(cookie, on, row, col) 683 void *cookie; 684 int on, row, col; 685 { 686 struct rasops_info *ri; 687 688 ri = (struct rasops_info *)cookie; 689 690 /* Turn old cursor off */ 691 if ((ri->ri_flg & RI_CURSOR) != 0) 692 #ifdef RASOPS_CLIPPING 693 if ((ri->ri_flg & RI_CURSORCLIP) == 0) 694 #endif 695 ri->ri_do_cursor(ri); 696 697 /* Select new cursor */ 698 #ifdef RASOPS_CLIPPING 699 ri->ri_flg &= ~RI_CURSORCLIP; 700 701 if (row < 0 || row >= ri->ri_rows) 702 ri->ri_flg |= RI_CURSORCLIP; 703 else if (col < 0 || col >= ri->ri_cols) 704 ri->ri_flg |= RI_CURSORCLIP; 705 #endif 706 ri->ri_crow = row; 707 ri->ri_ccol = col; 708 709 if (on) { 710 ri->ri_flg |= RI_CURSOR; 711 #ifdef RASOPS_CLIPPING 712 if ((ri->ri_flg & RI_CURSORCLIP) == 0) 713 #endif 714 ri->ri_do_cursor(ri); 715 } else 716 ri->ri_flg &= ~RI_CURSOR; 717 } 718 719 /* 720 * Make the device colormap 721 */ 722 static void 723 rasops_init_devcmap(ri) 724 struct rasops_info *ri; 725 { 726 const u_char *p; 727 int i, c; 728 729 switch (ri->ri_depth) { 730 case 1: 731 ri->ri_devcmap[0] = 0; 732 for (i = 1; i < 16; i++) 733 ri->ri_devcmap[i] = -1; 734 return; 735 736 case 2: 737 for (i = 1; i < 15; i++) 738 ri->ri_devcmap[i] = 0xaaaaaaaa; 739 740 ri->ri_devcmap[0] = 0; 741 ri->ri_devcmap[8] = 0x55555555; 742 ri->ri_devcmap[15] = -1; 743 return; 744 745 case 8: 746 for (i = 0; i < 16; i++) 747 ri->ri_devcmap[i] = i | (i<<8) | (i<<16) | (i<<24); 748 return; 749 } 750 751 p = rasops_cmap; 752 753 for (i = 0; i < 16; i++) { 754 if (ri->ri_rnum <= 8) 755 c = (*p >> (8 - ri->ri_rnum)) << ri->ri_rpos; 756 else 757 c = (*p << (ri->ri_rnum - 8)) << ri->ri_rpos; 758 p++; 759 760 if (ri->ri_gnum <= 8) 761 c |= (*p >> (8 - ri->ri_gnum)) << ri->ri_gpos; 762 else 763 c |= (*p << (ri->ri_gnum - 8)) << ri->ri_gpos; 764 p++; 765 766 if (ri->ri_bnum <= 8) 767 c |= (*p >> (8 - ri->ri_bnum)) << ri->ri_bpos; 768 else 769 c |= (*p << (ri->ri_bnum - 8)) << ri->ri_bpos; 770 p++; 771 772 /* Fill the word for generic routines, which want this */ 773 if (ri->ri_depth == 24) 774 c = c | ((c & 0xff) << 24); 775 else if (ri->ri_depth <= 16) 776 c = c | (c << 16); 777 778 /* 24bpp does bswap on the fly. {32,16,15}bpp do it here. */ 779 if ((ri->ri_flg & RI_BSWAP) == 0) 780 ri->ri_devcmap[i] = c; 781 else if (ri->ri_depth == 32) 782 ri->ri_devcmap[i] = bswap32(c); 783 else if (ri->ri_depth == 16 || ri->ri_depth == 15) 784 ri->ri_devcmap[i] = bswap16(c); 785 else 786 ri->ri_devcmap[i] = c; 787 } 788 } 789 790 /* 791 * Unpack a rasops attribute 792 */ 793 void 794 rasops_unpack_attr(attr, fg, bg, underline) 795 long attr; 796 int *fg, *bg, *underline; 797 { 798 799 *fg = ((u_int)attr >> 24) & 0xf; 800 *bg = ((u_int)attr >> 16) & 0xf; 801 if (underline != NULL) 802 *underline = (u_int)attr & 1; 803 } 804 805 /* 806 * Erase rows. This isn't static, since 24-bpp uses it in special cases. 807 */ 808 void 809 rasops_eraserows(cookie, row, num, attr) 810 void *cookie; 811 int row, num; 812 long attr; 813 { 814 struct rasops_info *ri; 815 int np, nw, cnt, delta; 816 int32_t *dp, *hp, clr; 817 int i; 818 819 ri = (struct rasops_info *)cookie; 820 hp = NULL; 821 822 #ifdef RASOPS_CLIPPING 823 if (row < 0) { 824 num += row; 825 row = 0; 826 } 827 828 if ((row + num) > ri->ri_rows) 829 num = ri->ri_rows - row; 830 831 if (num <= 0) 832 return; 833 #endif 834 835 clr = ri->ri_devcmap[(attr >> 16) & 0xf]; 836 837 /* 838 * XXX The wsdisplay_emulops interface seems a little deficient in 839 * that there is no way to clear the *entire* screen. We provide a 840 * workaround here: if the entire console area is being cleared, and 841 * the RI_FULLCLEAR flag is set, clear the entire display. 842 */ 843 if (num == ri->ri_rows && (ri->ri_flg & RI_FULLCLEAR) != 0) { 844 np = ri->ri_stride >> 5; 845 nw = (ri->ri_stride >> 2) & 7; 846 num = ri->ri_height; 847 dp = (int32_t *)ri->ri_origbits; 848 if (ri->ri_hwbits) 849 hp = (int32_t *)ri->ri_hwbits; 850 delta = 0; 851 } else { 852 np = ri->ri_emustride >> 5; 853 nw = (ri->ri_emustride >> 2) & 7; 854 num *= ri->ri_font->fontheight; 855 dp = (int32_t *)(ri->ri_bits + row * ri->ri_yscale); 856 if (ri->ri_hwbits) 857 hp = (int32_t *)(ri->ri_hwbits + row * 858 ri->ri_yscale); 859 delta = ri->ri_delta; 860 } 861 862 while (num--) { 863 for (cnt = np; cnt; cnt--) { 864 for (i = 0; i < 8; i++) { 865 dp[i] = clr; 866 if (ri->ri_hwbits) 867 hp[i] = clr; 868 } 869 dp += 8; 870 if (ri->ri_hwbits) 871 hp += 8; 872 } 873 874 for (cnt = nw; cnt; cnt--) { 875 *(int32_t *)dp = clr; 876 DELTA(dp, 4, int32_t *); 877 if (ri->ri_hwbits) { 878 *(int32_t *)hp = clr; 879 DELTA(hp, 4, int32_t *); 880 } 881 } 882 883 DELTA(dp, delta, int32_t *); 884 if (ri->ri_hwbits) 885 DELTA(hp, delta, int32_t *); 886 } 887 } 888 889 /* 890 * Actually turn the cursor on or off. This does the dirty work for 891 * rasops_cursor(). 892 */ 893 static void 894 rasops_do_cursor(ri) 895 struct rasops_info *ri; 896 { 897 int full1, height, cnt, slop1, slop2, row, col; 898 u_char *dp, *rp, *hrp, *hp; 899 900 hrp = hp = NULL; 901 902 #if NRASOPS_ROTATION > 0 903 if (ri->ri_flg & RI_ROTATE_CW) { 904 /* Rotate rows/columns */ 905 row = ri->ri_ccol; 906 col = ri->ri_rows - ri->ri_crow - 1; 907 } else 908 #endif 909 { 910 row = ri->ri_crow; 911 col = ri->ri_ccol; 912 } 913 914 rp = ri->ri_bits + row * ri->ri_yscale + col * ri->ri_xscale; 915 if (ri->ri_hwbits) 916 hrp = ri->ri_hwbits + row * ri->ri_yscale + col 917 * ri->ri_xscale; 918 height = ri->ri_font->fontheight; 919 slop1 = (4 - ((long)rp & 3)) & 3; 920 921 if (slop1 > ri->ri_xscale) 922 slop1 = ri->ri_xscale; 923 924 slop2 = (ri->ri_xscale - slop1) & 3; 925 full1 = (ri->ri_xscale - slop1 - slop2) >> 2; 926 927 if ((slop1 | slop2) == 0) { 928 /* A common case */ 929 while (height--) { 930 dp = rp; 931 rp += ri->ri_stride; 932 if (ri->ri_hwbits) { 933 hp = hrp; 934 hrp += ri->ri_stride; 935 } 936 937 for (cnt = full1; cnt; cnt--) { 938 *(int32_t *)dp ^= ~0; 939 dp += 4; 940 if (ri->ri_hwbits) { 941 dp -= 4; 942 *(int32_t *)hp = *(int32_t *)dp; 943 hp += 4; 944 dp += 4; 945 } 946 } 947 } 948 } else { 949 /* XXX this is stupid.. use masks instead */ 950 while (height--) { 951 dp = rp; 952 rp += ri->ri_stride; 953 if (ri->ri_hwbits) { 954 hp = hrp; 955 hrp += ri->ri_stride; 956 } 957 958 if (slop1 & 1) { 959 *dp++ ^= ~0; 960 if (ri->ri_hwbits) { 961 *hp++ = *(dp - 1); 962 } 963 } 964 965 if (slop1 & 2) { 966 *(int16_t *)dp ^= ~0; 967 dp += 2; 968 if (ri->ri_hwbits) { 969 dp -= 2; 970 *(int16_t *)hp = *(int16_t *)dp; 971 hp += 2; 972 dp += 2; 973 } 974 } 975 976 for (cnt = full1; cnt; cnt--) { 977 *(int32_t *)dp ^= ~0; 978 dp += 4; 979 if (ri->ri_hwbits) { 980 dp -= 4; 981 *(int32_t *)hp = *(int32_t *)dp; 982 hp += 4; 983 dp += 4; 984 } 985 } 986 987 if (slop2 & 1) { 988 *dp++ ^= ~0; 989 if (ri->ri_hwbits) 990 *hp++ = *(dp - 1); 991 } 992 993 if (slop2 & 2) { 994 *(int16_t *)dp ^= ~0; 995 if (ri->ri_hwbits) 996 *(int16_t *)hp = *(int16_t *)(dp - 2); 997 } 998 } 999 } 1000 } 1001 1002 /* 1003 * Erase columns. 1004 */ 1005 void 1006 rasops_erasecols(cookie, row, col, num, attr) 1007 void *cookie; 1008 int row, col, num; 1009 long attr; 1010 { 1011 int n8, height, cnt, slop1, slop2, clr; 1012 struct rasops_info *ri; 1013 int32_t *rp, *dp, *hrp, *hp; 1014 int i; 1015 1016 ri = (struct rasops_info *)cookie; 1017 hrp = hp = NULL; 1018 1019 #ifdef RASOPS_CLIPPING 1020 if ((unsigned)row >= (unsigned)ri->ri_rows) 1021 return; 1022 1023 if (col < 0) { 1024 num += col; 1025 col = 0; 1026 } 1027 1028 if ((col + num) > ri->ri_cols) 1029 num = ri->ri_cols - col; 1030 1031 if (num <= 0) 1032 return; 1033 #endif 1034 1035 num = num * ri->ri_xscale; 1036 rp = (int32_t *)(ri->ri_bits + row*ri->ri_yscale + col*ri->ri_xscale); 1037 if (ri->ri_hwbits) 1038 hrp = (int32_t *)(ri->ri_hwbits + row*ri->ri_yscale + 1039 col*ri->ri_xscale); 1040 height = ri->ri_font->fontheight; 1041 clr = ri->ri_devcmap[(attr >> 16) & 0xf]; 1042 1043 /* Don't bother using the full loop for <= 32 pels */ 1044 if (num <= 32) { 1045 if (((num | ri->ri_xscale) & 3) == 0) { 1046 /* Word aligned blt */ 1047 num >>= 2; 1048 1049 while (height--) { 1050 dp = rp; 1051 DELTA(rp, ri->ri_stride, int32_t *); 1052 if (ri->ri_hwbits) { 1053 hp = hrp; 1054 DELTA(hrp, ri->ri_stride, int32_t *); 1055 } 1056 1057 for (cnt = num; cnt; cnt--) { 1058 *dp++ = clr; 1059 if (ri->ri_hwbits) 1060 *hp++ = clr; 1061 } 1062 } 1063 } else if (((num | ri->ri_xscale) & 1) == 0) { 1064 /* 1065 * Halfword aligned blt. This is needed so the 1066 * 15/16 bit ops can use this function. 1067 */ 1068 num >>= 1; 1069 1070 while (height--) { 1071 dp = rp; 1072 DELTA(rp, ri->ri_stride, int32_t *); 1073 if (ri->ri_hwbits) { 1074 hp = hrp; 1075 DELTA(hrp, ri->ri_stride, int32_t *); 1076 } 1077 1078 for (cnt = num; cnt; cnt--) { 1079 *(int16_t *)dp = clr; 1080 DELTA(dp, 2, int32_t *); 1081 if (ri->ri_hwbits) { 1082 *(int16_t *)hp = clr; 1083 DELTA(hp, 2, int32_t *); 1084 } 1085 } 1086 } 1087 } else { 1088 while (height--) { 1089 dp = rp; 1090 DELTA(rp, ri->ri_stride, int32_t *); 1091 if (ri->ri_hwbits) { 1092 hp = hrp; 1093 DELTA(hrp, ri->ri_stride, int32_t *); 1094 } 1095 1096 for (cnt = num; cnt; cnt--) { 1097 *(u_char *)dp = clr; 1098 DELTA(dp, 1, int32_t *); 1099 if (ri->ri_hwbits) { 1100 *(u_char *)hp = clr; 1101 DELTA(hp, 1, int32_t *); 1102 } 1103 } 1104 } 1105 } 1106 1107 return; 1108 } 1109 1110 slop1 = (4 - ((long)rp & 3)) & 3; 1111 slop2 = (num - slop1) & 3; 1112 num -= slop1 + slop2; 1113 n8 = num >> 5; 1114 num = (num >> 2) & 7; 1115 1116 while (height--) { 1117 dp = rp; 1118 DELTA(rp, ri->ri_stride, int32_t *); 1119 if (ri->ri_hwbits) { 1120 hp = hrp; 1121 DELTA(hrp, ri->ri_stride, int32_t *); 1122 } 1123 1124 /* Align span to 4 bytes */ 1125 if (slop1 & 1) { 1126 *(u_char *)dp = clr; 1127 DELTA(dp, 1, int32_t *); 1128 if (ri->ri_hwbits) { 1129 *(u_char *)hp = clr; 1130 DELTA(hp, 1, int32_t *); 1131 } 1132 } 1133 1134 if (slop1 & 2) { 1135 *(int16_t *)dp = clr; 1136 DELTA(dp, 2, int32_t *); 1137 if (ri->ri_hwbits) { 1138 *(int16_t *)hp = clr; 1139 DELTA(hp, 2, int32_t *); 1140 } 1141 } 1142 1143 /* Write 32 bytes per loop */ 1144 for (cnt = n8; cnt; cnt--) { 1145 for (i = 0; i < 8; i++) { 1146 dp[i] = clr; 1147 if (ri->ri_hwbits) 1148 hp[i] = clr; 1149 } 1150 dp += 8; 1151 if (ri->ri_hwbits) 1152 hp += 8; 1153 } 1154 1155 /* Write 4 bytes per loop */ 1156 for (cnt = num; cnt; cnt--) { 1157 *dp++ = clr; 1158 if (ri->ri_hwbits) 1159 *hp++ = clr; 1160 } 1161 1162 /* Write unaligned trailing slop */ 1163 if (slop2 & 1) { 1164 *(u_char *)dp = clr; 1165 DELTA(dp, 1, int32_t *); 1166 if (ri->ri_hwbits) { 1167 *(u_char *)hp = clr; 1168 DELTA(hp, 1, int32_t *); 1169 } 1170 } 1171 1172 if (slop2 & 2) { 1173 *(int16_t *)dp = clr; 1174 if (ri->ri_hwbits) 1175 *(int16_t *)hp = clr; 1176 } 1177 } 1178 } 1179 1180 #if NRASOPS_ROTATION > 0 1181 /* 1182 * Quarter clockwise rotation routines (originally intended for the 1183 * built-in Zaurus C3x00 display in 16bpp). 1184 */ 1185 1186 #include <sys/malloc.h> 1187 1188 static void 1189 rasops_rotate_font(int *cookie) 1190 { 1191 struct rotatedfont *f; 1192 int ncookie; 1193 1194 SLIST_FOREACH(f, &rotatedfonts, rf_next) { 1195 if (f->rf_cookie == *cookie) { 1196 *cookie = f->rf_rotated; 1197 return; 1198 } 1199 } 1200 1201 /* 1202 * We did not find a rotated version of this font. Ask the wsfont 1203 * code to compute one for us. 1204 */ 1205 1206 f = malloc(sizeof(struct rotatedfont), M_DEVBUF, M_WAITOK); 1207 if (f == NULL) 1208 return; 1209 1210 if ((ncookie = wsfont_rotate(*cookie)) == -1) 1211 return; 1212 1213 f->rf_cookie = *cookie; 1214 f->rf_rotated = ncookie; 1215 SLIST_INSERT_HEAD(&rotatedfonts, f, rf_next); 1216 1217 *cookie = ncookie; 1218 } 1219 1220 static void 1221 rasops_copychar(cookie, srcrow, dstrow, srccol, dstcol) 1222 void *cookie; 1223 int srcrow, dstrow, srccol, dstcol; 1224 { 1225 struct rasops_info *ri; 1226 u_char *sp, *dp; 1227 int height; 1228 int r_srcrow, r_dstrow, r_srccol, r_dstcol; 1229 1230 ri = (struct rasops_info *)cookie; 1231 1232 r_srcrow = srccol; 1233 r_dstrow = dstcol; 1234 r_srccol = ri->ri_rows - srcrow - 1; 1235 r_dstcol = ri->ri_rows - dstrow - 1; 1236 1237 r_srcrow *= ri->ri_yscale; 1238 r_dstrow *= ri->ri_yscale; 1239 height = ri->ri_font->fontheight; 1240 1241 sp = ri->ri_bits + r_srcrow + r_srccol * ri->ri_xscale; 1242 dp = ri->ri_bits + r_dstrow + r_dstcol * ri->ri_xscale; 1243 1244 while (height--) { 1245 memmove(dp, sp, ri->ri_xscale); 1246 dp += ri->ri_stride; 1247 sp += ri->ri_stride; 1248 } 1249 } 1250 1251 static void 1252 rasops_putchar_rotated(cookie, row, col, uc, attr) 1253 void *cookie; 1254 int row, col; 1255 u_int uc; 1256 long attr; 1257 { 1258 struct rasops_info *ri; 1259 u_char *rp; 1260 int height; 1261 1262 ri = (struct rasops_info *)cookie; 1263 1264 if (__predict_false((unsigned int)row > ri->ri_rows || 1265 (unsigned int)col > ri->ri_cols)) 1266 return; 1267 1268 /* Avoid underflow */ 1269 if ((ri->ri_rows - row - 1) < 0) 1270 return; 1271 1272 /* Do rotated char sans (side)underline */ 1273 ri->ri_real_ops.putchar(cookie, col, ri->ri_rows - row - 1, uc, 1274 attr & ~1); 1275 1276 /* Do rotated underline */ 1277 rp = ri->ri_bits + col * ri->ri_yscale + (ri->ri_rows - row - 1) * 1278 ri->ri_xscale; 1279 height = ri->ri_font->fontheight; 1280 1281 /* XXX this assumes 16-bit color depth */ 1282 if ((attr & 1) != 0) { 1283 int16_t c = (int16_t)ri->ri_devcmap[((u_int)attr >> 24) & 0xf]; 1284 1285 while (height--) { 1286 *(int16_t *)rp = c; 1287 rp += ri->ri_stride; 1288 } 1289 } 1290 } 1291 1292 static void 1293 rasops_erasecols_rotated(cookie, row, col, num, attr) 1294 void *cookie; 1295 int row, col, num; 1296 long attr; 1297 { 1298 struct rasops_info *ri; 1299 int i; 1300 1301 ri = (struct rasops_info *)cookie; 1302 1303 for (i = col; i < col + num; i++) 1304 ri->ri_ops.putchar(cookie, row, i, ' ', attr); 1305 } 1306 1307 /* XXX: these could likely be optimised somewhat. */ 1308 static void 1309 rasops_copyrows_rotated(cookie, src, dst, num) 1310 void *cookie; 1311 int src, dst, num; 1312 { 1313 struct rasops_info *ri = (struct rasops_info *)cookie; 1314 int col, roff; 1315 1316 if (src > dst) 1317 for (roff = 0; roff < num; roff++) 1318 for (col = 0; col < ri->ri_cols; col++) 1319 rasops_copychar(cookie, src + roff, dst + roff, 1320 col, col); 1321 else 1322 for (roff = num - 1; roff >= 0; roff--) 1323 for (col = 0; col < ri->ri_cols; col++) 1324 rasops_copychar(cookie, src + roff, dst + roff, 1325 col, col); 1326 } 1327 1328 static void 1329 rasops_copycols_rotated(cookie, row, src, dst, num) 1330 void *cookie; 1331 int row, src, dst, num; 1332 { 1333 int coff; 1334 1335 if (src > dst) 1336 for (coff = 0; coff < num; coff++) 1337 rasops_copychar(cookie, row, row, src + coff, dst + coff); 1338 else 1339 for (coff = num - 1; coff >= 0; coff--) 1340 rasops_copychar(cookie, row, row, src + coff, dst + coff); 1341 } 1342 1343 static void 1344 rasops_eraserows_rotated(cookie, row, num, attr) 1345 void *cookie; 1346 int row, num; 1347 long attr; 1348 { 1349 struct rasops_info *ri; 1350 int col, rn; 1351 1352 ri = (struct rasops_info *)cookie; 1353 1354 for (rn = row; rn < row + num; rn++) 1355 for (col = 0; col < ri->ri_cols; col++) 1356 ri->ri_ops.putchar(cookie, rn, col, ' ', attr); 1357 } 1358 #endif /* NRASOPS_ROTATION */ 1359