rasops.c revision 1.97
1 /* $NetBSD: rasops.c,v 1.97 2019/07/29 16:17:29 rin 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.97 2019/07/29 16:17:29 rin 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/bswap.h> 41 #include <sys/kmem.h> 42 #include <sys/systm.h> 43 #include <sys/time.h> 44 45 #include <machine/endian.h> 46 47 #include <dev/wscons/wsdisplayvar.h> 48 #include <dev/wscons/wsconsio.h> 49 #include <dev/wsfont/wsfont.h> 50 #include <dev/rasops/rasops.h> 51 52 #ifndef _KERNEL 53 #include <errno.h> 54 #endif 55 56 #ifdef RASOPS_DEBUG 57 #define DPRINTF(...) aprint_error(...) 58 #else 59 #define DPRINTF(...) __nothing 60 #endif 61 62 struct rasops_matchdata { 63 struct rasops_info *ri; 64 int wantcols, wantrows; 65 int bestscore; 66 struct wsdisplay_font *pick; 67 int ident; 68 }; 69 70 /* ANSI colormap (R,G,B). Upper 8 are high-intensity */ 71 const uint8_t rasops_cmap[256 * 3] = { 72 0x00, 0x00, 0x00, /* black */ 73 0x7f, 0x00, 0x00, /* red */ 74 0x00, 0x7f, 0x00, /* green */ 75 0x7f, 0x7f, 0x00, /* brown */ 76 0x00, 0x00, 0x7f, /* blue */ 77 0x7f, 0x00, 0x7f, /* magenta */ 78 0x00, 0x7f, 0x7f, /* cyan */ 79 0xc7, 0xc7, 0xc7, /* white - XXX too dim? */ 80 81 0x7f, 0x7f, 0x7f, /* black */ 82 0xff, 0x00, 0x00, /* red */ 83 0x00, 0xff, 0x00, /* green */ 84 0xff, 0xff, 0x00, /* brown */ 85 0x00, 0x00, 0xff, /* blue */ 86 0xff, 0x00, 0xff, /* magenta */ 87 0x00, 0xff, 0xff, /* cyan */ 88 0xff, 0xff, 0xff, /* white */ 89 90 /* 91 * For the cursor, we need at least the last (255th) 92 * color to be white. Fill up white completely for 93 * simplicity. 94 */ 95 #define _CMWHITE 0xff, 0xff, 0xff, 96 #define _CMWHITE16 _CMWHITE _CMWHITE _CMWHITE _CMWHITE \ 97 _CMWHITE _CMWHITE _CMWHITE _CMWHITE \ 98 _CMWHITE _CMWHITE _CMWHITE _CMWHITE \ 99 _CMWHITE _CMWHITE _CMWHITE _CMWHITE 100 _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16 101 _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16 102 _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16 /* but not the last one */ 103 #undef _CMWHITE16 104 #undef _CMWHITE 105 106 /* 107 * For the cursor the fg/bg indices are bit inverted, so 108 * provide complimentary colors in the upper 16 entries. 109 */ 110 0x7f, 0x7f, 0x7f, /* black */ 111 0xff, 0x00, 0x00, /* red */ 112 0x00, 0xff, 0x00, /* green */ 113 0xff, 0xff, 0x00, /* brown */ 114 0x00, 0x00, 0xff, /* blue */ 115 0xff, 0x00, 0xff, /* magenta */ 116 0x00, 0xff, 0xff, /* cyan */ 117 0xff, 0xff, 0xff, /* white */ 118 119 0x00, 0x00, 0x00, /* black */ 120 0x7f, 0x00, 0x00, /* red */ 121 0x00, 0x7f, 0x00, /* green */ 122 0x7f, 0x7f, 0x00, /* brown */ 123 0x00, 0x00, 0x7f, /* blue */ 124 0x7f, 0x00, 0x7f, /* magenta */ 125 0x00, 0x7f, 0x7f, /* cyan */ 126 0xc7, 0xc7, 0xc7, /* white - XXX too dim? */ 127 }; 128 129 /* True if color is gray */ 130 const uint8_t rasops_isgray[16] = { 131 1, 0, 0, 0, 132 0, 0, 0, 1, 133 1, 0, 0, 0, 134 0, 0, 0, 1, 135 }; 136 137 #ifdef RASOPS_APPLE_PALETTE 138 /* 139 * Approximate ANSI colormap for legacy Apple color palettes 140 */ 141 static const uint8_t apple8_devcmap[16] = { 142 0xff, /* black 0x00, 0x00, 0x00 */ 143 0x6b, /* red 0x99, 0x00, 0x00 */ 144 0xc5, /* green 0x00, 0x99, 0x00 */ 145 0x59, /* yellow 0x99, 0x99, 0x00 */ 146 0xd4, /* blue 0x00, 0x00, 0x99 */ 147 0x68, /* magenta 0x99, 0x00, 0x99 */ 148 0xc2, /* cyan 0x00, 0x99, 0x99 */ 149 0x2b, /* white 0xcc, 0xcc, 0xcc */ 150 151 0x56, /* black 0x99, 0x99, 0x99 */ 152 0x23, /* red 0xff, 0x00, 0x00 */ 153 0xb9, /* green 0x00, 0xff, 0x00 */ 154 0x05, /* yellow 0xff, 0xff, 0x00 */ 155 0xd2, /* blue 0x00, 0x00, 0xff */ 156 0x1e, /* magenta 0xff, 0x00, 0xff */ 157 0xb4, /* cyan 0x00, 0xff, 0xff */ 158 0x00, /* white 0xff, 0xff, 0xff */ 159 }; 160 161 static const uint8_t apple4_devcmap[16] = { 162 15, /* black */ 163 3, /* red */ 164 8, /* green */ 165 1, /* yellow */ 166 6, /* blue */ 167 4, /* magenta */ 168 7, /* cyan */ 169 12, /* light grey */ 170 171 13, /* medium grey */ 172 3, /* red */ 173 8, /* green */ 174 1, /* yellow */ 175 6, /* blue */ 176 4, /* magenta */ 177 7, /* cyan */ 178 0, /* white */ 179 }; 180 #endif 181 182 /* Generic functions */ 183 static void rasops_copyrows(void *, int, int, int); 184 static int rasops_mapchar(void *, int, u_int *); 185 static void rasops_cursor(void *, int, int, int); 186 static int rasops_allocattr_color(void *, int, int, int, long *); 187 static int rasops_allocattr_mono(void *, int, int, int, long *); 188 static void rasops_do_cursor(struct rasops_info *); 189 static void rasops_init_devcmap(struct rasops_info *); 190 191 #if NRASOPS_ROTATION > 0 192 static void rasops_rotate_font(int *, int); 193 static void rasops_copychar(void *, int, int, int, int); 194 195 /* rotate clockwise */ 196 static void rasops_copycols_rotated_cw(void *, int, int, int, int); 197 static void rasops_copyrows_rotated_cw(void *, int, int, int); 198 static void rasops_erasecols_rotated_cw(void *, int, int, int, long); 199 static void rasops_eraserows_rotated_cw(void *, int, int, long); 200 static void rasops_putchar_rotated_cw(void *, int, int, u_int, long); 201 202 /* rotate counter-clockwise */ 203 static void rasops_copychar_ccw(void *, int, int, int, int); 204 static void rasops_copycols_rotated_ccw(void *, int, int, int, int); 205 static void rasops_copyrows_rotated_ccw(void *, int, int, int); 206 #define rasops_erasecols_rotated_ccw rasops_erasecols_rotated_cw 207 #define rasops_eraserows_rotated_ccw rasops_eraserows_rotated_cw 208 static void rasops_putchar_rotated_ccw(void *, int, int, u_int, long); 209 210 /* 211 * List of all rotated fonts 212 */ 213 SLIST_HEAD(, rotatedfont) rotatedfonts = SLIST_HEAD_INITIALIZER(rotatedfonts); 214 struct rotatedfont { 215 SLIST_ENTRY(rotatedfont) rf_next; 216 int rf_cookie; 217 int rf_rotated; 218 }; 219 #endif /* NRASOPS_ROTATION > 0 */ 220 221 void rasops_make_box_chars_8(struct rasops_info *); 222 void rasops_make_box_chars_16(struct rasops_info *); 223 void rasops_make_box_chars_32(struct rasops_info *); 224 void rasops_make_box_chars_alpha(struct rasops_info *); 225 226 extern int cold; 227 228 /* 229 * Initialize a 'rasops_info' descriptor. 230 */ 231 int 232 rasops_init(struct rasops_info *ri, int wantrows, int wantcols) 233 { 234 235 memset(&ri->ri_optfont, 0, sizeof(ri->ri_optfont)); 236 #ifdef _KERNEL 237 /* Select a font if the caller doesn't care */ 238 if (ri->ri_font == NULL) { 239 int cookie = -1; 240 int flags; 241 242 wsfont_init(); 243 244 /* 245 * first, try to find something that's as close as possible 246 * to the caller's requested terminal size 247 */ 248 if (wantrows == 0) 249 wantrows = RASOPS_DEFAULT_HEIGHT; 250 if (wantcols == 0) 251 wantcols = RASOPS_DEFAULT_WIDTH; 252 253 flags = WSFONT_FIND_BESTWIDTH | WSFONT_FIND_BITMAP; 254 if ((ri->ri_flg & RI_ENABLE_ALPHA) != 0) 255 flags |= WSFONT_FIND_ALPHA; 256 if ((ri->ri_flg & RI_PREFER_ALPHA) != 0) 257 flags |= WSFONT_PREFER_ALPHA; 258 cookie = wsfont_find(NULL, 259 ri->ri_width / wantcols, 260 0, 261 0, 262 WSDISPLAY_FONTORDER_L2R, 263 WSDISPLAY_FONTORDER_L2R, 264 flags); 265 266 /* 267 * this means there is no supported font in the list 268 */ 269 if (cookie <= 0) { 270 aprint_error("%s: font table is empty\n", __func__); 271 return -1; 272 } 273 274 #if NRASOPS_ROTATION > 0 275 /* 276 * Pick the rotated version of this font. This will create it 277 * if necessary. 278 */ 279 if (ri->ri_flg & RI_ROTATE_MASK) { 280 if (ri->ri_flg & RI_ROTATE_CW) 281 rasops_rotate_font(&cookie, WSFONT_ROTATE_CW); 282 else if (ri->ri_flg & RI_ROTATE_CCW) 283 rasops_rotate_font(&cookie, WSFONT_ROTATE_CCW); 284 } 285 #endif 286 287 if (wsfont_lock(cookie, &ri->ri_font)) { 288 aprint_error("%s: couldn't lock font\n", __func__); 289 return -1; 290 } 291 292 ri->ri_wsfcookie = cookie; 293 } 294 #endif 295 296 /* This should never happen in reality... */ 297 if ((uintptr_t)ri->ri_bits & 3) { 298 aprint_error("%s: bits not aligned on 32-bit boundary\n", 299 __func__); 300 return -1; 301 } 302 303 if (ri->ri_stride & 3) { 304 aprint_error("%s: stride not aligned on 32-bit boundary\n", 305 __func__); 306 return -1; 307 } 308 309 if (rasops_reconfig(ri, wantrows, wantcols)) 310 return -1; 311 312 rasops_init_devcmap(ri); 313 return 0; 314 } 315 316 /* 317 * Reconfigure (because parameters have changed in some way). 318 */ 319 int 320 rasops_reconfig(struct rasops_info *ri, int wantrows, int wantcols) 321 { 322 int bpp, s; 323 size_t len; 324 325 s = splhigh(); 326 327 if (wantrows == 0) 328 wantrows = RASOPS_DEFAULT_HEIGHT; 329 if (wantcols == 0) 330 wantcols = RASOPS_DEFAULT_WIDTH; 331 332 /* throw away old line drawing character bitmaps, if we have any */ 333 if (ri->ri_optfont.data != NULL) { 334 kmem_free(ri->ri_optfont.data, ri->ri_optfont.stride * 335 ri->ri_optfont.fontheight * ri->ri_optfont.numchars); 336 ri->ri_optfont.data = NULL; 337 } 338 339 /* autogenerate box drawing characters */ 340 ri->ri_optfont.firstchar = WSFONT_FLAG_OPT; 341 ri->ri_optfont.numchars = 16; 342 ri->ri_optfont.fontwidth = ri->ri_font->fontwidth; 343 ri->ri_optfont.fontheight = ri->ri_font->fontheight; 344 ri->ri_optfont.stride = ri->ri_font->stride; 345 len = ri->ri_optfont.fontheight * ri->ri_optfont.stride * 346 ri->ri_optfont.numchars; 347 348 if (ri->ri_font->fontwidth > 32 || ri->ri_font->fontwidth < 4) { 349 aprint_error("%s: fontwidth assumptions botched", __func__); 350 splx(s); 351 return -1; 352 } 353 354 if ((ri->ri_flg & RI_NO_AUTO) == 0) { 355 ri->ri_optfont.data = kmem_zalloc(len, KM_SLEEP); 356 if (FONT_IS_ALPHA(&ri->ri_optfont)) 357 rasops_make_box_chars_alpha(ri); 358 else { 359 switch (ri->ri_optfont.stride) { 360 case 1: 361 rasops_make_box_chars_8(ri); 362 break; 363 case 2: 364 rasops_make_box_chars_16(ri); 365 break; 366 case 4: 367 rasops_make_box_chars_32(ri); 368 break; 369 default: 370 aprint_error( 371 "%s: font stride assumptions botched", 372 __func__); 373 splx(s); 374 return -1; 375 } 376 } 377 } else 378 memset(&ri->ri_optfont, 0, sizeof(ri->ri_optfont)); 379 380 /* Need this to frob the setup below */ 381 bpp = (ri->ri_depth == 15 ? 16 : ri->ri_depth); 382 383 if ((ri->ri_flg & RI_CFGDONE) != 0) { 384 ri->ri_bits = ri->ri_origbits; 385 ri->ri_hwbits = ri->ri_hworigbits; 386 } 387 388 /* Don't care if the caller wants a hideously small console */ 389 if (wantrows < 10) 390 wantrows = 10; 391 392 if (wantcols < 20) 393 wantcols = 20; 394 395 /* Now constrain what they get */ 396 ri->ri_emuwidth = ri->ri_font->fontwidth * wantcols; 397 ri->ri_emuheight = ri->ri_font->fontheight * wantrows; 398 399 if (ri->ri_emuwidth > ri->ri_width) 400 ri->ri_emuwidth = ri->ri_width; 401 402 if (ri->ri_emuheight > ri->ri_height) 403 ri->ri_emuheight = ri->ri_height; 404 405 /* Reduce width until aligned on a 32-bit boundary */ 406 while ((ri->ri_emuwidth * bpp & 31) != 0) 407 ri->ri_emuwidth--; 408 409 #if NRASOPS_ROTATION > 0 410 if (ri->ri_flg & (RI_ROTATE_CW|RI_ROTATE_CCW)) { 411 ri->ri_rows = ri->ri_emuwidth / ri->ri_font->fontwidth; 412 ri->ri_cols = ri->ri_emuheight / ri->ri_font->fontheight; 413 } else 414 #endif 415 { 416 417 ri->ri_cols = ri->ri_emuwidth / ri->ri_font->fontwidth; 418 ri->ri_rows = ri->ri_emuheight / ri->ri_font->fontheight; 419 } 420 ri->ri_emustride = ri->ri_emuwidth * bpp >> 3; 421 ri->ri_delta = ri->ri_stride - ri->ri_emustride; 422 ri->ri_ccol = 0; 423 ri->ri_crow = 0; 424 ri->ri_pelbytes = bpp >> 3; 425 426 ri->ri_xscale = (ri->ri_font->fontwidth * bpp) >> 3; 427 ri->ri_yscale = ri->ri_font->fontheight * ri->ri_stride; 428 ri->ri_fontscale = ri->ri_font->fontheight * ri->ri_font->stride; 429 430 if ((ri->ri_delta & 3) != 0) { 431 aprint_error( 432 "%s: ri_delta not aligned on 32-bit boundary", __func__); 433 splx(s); 434 return -1; 435 } 436 ri->ri_origbits = ri->ri_bits; 437 ri->ri_hworigbits = ri->ri_hwbits; 438 439 /* Clear the entire display */ 440 if ((ri->ri_flg & RI_CLEAR) != 0) 441 memset(ri->ri_bits, 0, ri->ri_stride * ri->ri_height); 442 443 /* Now centre our window if needs be */ 444 if ((ri->ri_flg & RI_CENTER) != 0) { 445 ri->ri_bits += (((ri->ri_width * bpp >> 3) - 446 ri->ri_emustride) >> 1) & ~3; 447 ri->ri_bits += ((ri->ri_height - ri->ri_emuheight) >> 1) * 448 ri->ri_stride; 449 if (ri->ri_hwbits != NULL) { 450 ri->ri_hwbits += (((ri->ri_width * bpp >> 3) - 451 ri->ri_emustride) >> 1) & ~3; 452 ri->ri_hwbits += 453 ((ri->ri_height - ri->ri_emuheight) >> 1) * 454 ri->ri_stride; 455 } 456 ri->ri_yorigin = (int)(ri->ri_bits - ri->ri_origbits) / 457 ri->ri_stride; 458 ri->ri_xorigin = (((int)(ri->ri_bits - ri->ri_origbits) % 459 ri->ri_stride) * 8 / bpp); 460 } else 461 ri->ri_xorigin = ri->ri_yorigin = 0; 462 463 /* 464 * Fill in defaults for operations set. XXX this nukes private 465 * routines used by accelerated fb drivers. 466 */ 467 ri->ri_ops.mapchar = rasops_mapchar; 468 ri->ri_ops.copyrows = rasops_copyrows; 469 ri->ri_ops.copycols = rasops_copycols; 470 ri->ri_ops.erasecols = rasops_erasecols; 471 ri->ri_ops.eraserows = rasops_eraserows; 472 ri->ri_ops.cursor = rasops_cursor; 473 ri->ri_do_cursor = rasops_do_cursor; 474 475 ri->ri_caps &= ~(WSSCREEN_UNDERLINE | WSSCREEN_HILIT | 476 WSSCREEN_WSCOLORS | WSSCREEN_REVERSE); 477 478 if ((ri->ri_flg & RI_FORCEMONO) != 0 || 479 #ifdef RASOPS_APPLE_PALETTE 480 ri->ri_depth == 1 481 #else 482 ri->ri_depth < 8 483 #endif 484 ) { 485 ri->ri_ops.allocattr = rasops_allocattr_mono; 486 ri->ri_caps |= WSSCREEN_UNDERLINE | WSSCREEN_REVERSE; 487 } else { 488 ri->ri_ops.allocattr = rasops_allocattr_color; 489 ri->ri_caps |= WSSCREEN_UNDERLINE | WSSCREEN_HILIT | 490 WSSCREEN_WSCOLORS | WSSCREEN_REVERSE; 491 } 492 493 switch (ri->ri_depth) { 494 #if NRASOPS1 > 0 495 case 1: 496 rasops1_init(ri); 497 break; 498 #endif 499 #if NRASOPS2 > 0 500 case 2: 501 rasops2_init(ri); 502 break; 503 #endif 504 #if NRASOPS4 > 0 505 case 4: 506 rasops4_init(ri); 507 break; 508 #endif 509 #if NRASOPS8 > 0 510 case 8: 511 rasops8_init(ri); 512 break; 513 #endif 514 #if (NRASOPS15 + NRASOPS16) > 0 515 case 15: 516 case 16: 517 rasops15_init(ri); 518 break; 519 #endif 520 #if NRASOPS24 > 0 521 case 24: 522 rasops24_init(ri); 523 break; 524 #endif 525 #if NRASOPS32 > 0 526 case 32: 527 rasops32_init(ri); 528 break; 529 #endif 530 default: 531 ri->ri_flg &= ~RI_CFGDONE; 532 aprint_error("%s: depth not supported\n", __func__); 533 splx(s); 534 return -1; 535 } 536 537 #if NRASOPS_ROTATION > 0 538 if (ri->ri_flg & RI_ROTATE_MASK) { 539 if (ri->ri_flg & RI_ROTATE_CW) { 540 ri->ri_real_ops = ri->ri_ops; 541 ri->ri_ops.copycols = rasops_copycols_rotated_cw; 542 ri->ri_ops.copyrows = rasops_copyrows_rotated_cw; 543 ri->ri_ops.erasecols = rasops_erasecols_rotated_cw; 544 ri->ri_ops.eraserows = rasops_eraserows_rotated_cw; 545 ri->ri_ops.putchar = rasops_putchar_rotated_cw; 546 } else if (ri->ri_flg & RI_ROTATE_CCW) { 547 ri->ri_real_ops = ri->ri_ops; 548 ri->ri_ops.copycols = rasops_copycols_rotated_ccw; 549 ri->ri_ops.copyrows = rasops_copyrows_rotated_ccw; 550 ri->ri_ops.erasecols = rasops_erasecols_rotated_ccw; 551 ri->ri_ops.eraserows = rasops_eraserows_rotated_ccw; 552 ri->ri_ops.putchar = rasops_putchar_rotated_ccw; 553 } 554 } 555 #endif 556 557 ri->ri_flg |= RI_CFGDONE; 558 splx(s); 559 return 0; 560 } 561 562 /* 563 * Map a character. 564 */ 565 static int 566 rasops_mapchar(void *cookie, int c, u_int *cp) 567 { 568 struct rasops_info *ri = (struct rasops_info *)cookie; 569 570 KASSERT(ri->ri_font != NULL); 571 572 if ((c = wsfont_map_unichar(ri->ri_font, c)) < 0 || 573 c < ri->ri_font->firstchar) { 574 *cp = ' '; 575 return 0; 576 } 577 578 #if 0 /* XXXRO */ 579 if (CHAR_IN_FONT(c, ri->ri_font)) { 580 *cp = ' '; 581 return 0; 582 } 583 #endif 584 585 *cp = c; 586 return 5; 587 } 588 589 /* 590 * Allocate a color attribute. 591 */ 592 static int 593 rasops_allocattr_color(void *cookie, int fg0, int bg0, int flg, long *attr) 594 { 595 uint32_t fg = fg0, bg = bg0; 596 597 if (__predict_false(fg >= sizeof(rasops_isgray) || 598 bg >= sizeof(rasops_isgray))) 599 return EINVAL; 600 601 #ifdef RASOPS_CLIPPING 602 fg &= 7; 603 bg &= 7; 604 #endif 605 if ((flg & WSATTR_BLINK) != 0) 606 return EINVAL; 607 608 if ((flg & WSATTR_WSCOLORS) == 0) { 609 #ifdef WS_DEFAULT_FG 610 fg = WS_DEFAULT_FG; 611 #else 612 fg = WSCOL_WHITE; 613 #endif 614 #ifdef WS_DEFAULT_BG 615 bg = WS_DEFAULT_BG; 616 #else 617 bg = WSCOL_BLACK; 618 #endif 619 } 620 621 if ((flg & WSATTR_REVERSE) != 0) { 622 uint32_t swap = fg; 623 fg = bg; 624 bg = swap; 625 } 626 627 if ((flg & WSATTR_HILIT) != 0) 628 fg += 8; 629 630 flg = flg & WSATTR_USERMASK; 631 632 if (rasops_isgray[fg]) 633 flg |= WSATTR_PRIVATE1; 634 635 if (rasops_isgray[bg]) 636 flg |= WSATTR_PRIVATE2; 637 638 *attr = (bg << 16) | (fg << 24) | flg; 639 return 0; 640 } 641 642 /* 643 * Allocate a mono attribute. 644 */ 645 static int 646 rasops_allocattr_mono(void *cookie, int fg0, int bg0, int flg, long *attr) 647 { 648 uint32_t fg = fg0, bg = bg0; 649 650 if ((flg & (WSATTR_BLINK | WSATTR_HILIT | WSATTR_WSCOLORS)) != 0) 651 return EINVAL; 652 653 fg = 1; 654 bg = 0; 655 656 if ((flg & WSATTR_REVERSE) != 0) { 657 uint32_t swap = fg; 658 fg = bg; 659 bg = swap; 660 } 661 662 *attr = (bg << 16) | (fg << 24) | flg; 663 return 0; 664 } 665 666 /* 667 * Copy rows. 668 */ 669 static void 670 rasops_copyrows(void *cookie, int src, int dst, int num) 671 { 672 struct rasops_info *ri = (struct rasops_info *)cookie; 673 uint8_t *sp, *dp, *hp; 674 int n; 675 676 hp = NULL; /* XXX GCC */ 677 678 #ifdef RASOPS_CLIPPING 679 if (dst == src) 680 return; 681 682 if (src < 0) { 683 num += src; 684 src = 0; 685 } 686 687 if (src + num > ri->ri_rows) 688 num = ri->ri_rows - src; 689 690 if (dst < 0) { 691 num += dst; 692 dst = 0; 693 } 694 695 if (dst + num > ri->ri_rows) 696 num = ri->ri_rows - dst; 697 698 if (num <= 0) 699 return; 700 #endif 701 702 num *= ri->ri_font->fontheight; 703 n = ri->ri_emustride; 704 705 sp = ri->ri_bits + src * ri->ri_yscale; 706 dp = ri->ri_bits + dst * ri->ri_yscale; 707 if (ri->ri_hwbits) 708 hp = ri->ri_hwbits + dst * ri->ri_yscale; 709 710 while (num--) { 711 memmove(dp, sp, n); 712 dp += n; 713 if (ri->ri_hwbits) { 714 memcpy(hp, sp, n); 715 hp += n; 716 } 717 sp += n; 718 } 719 } 720 721 /* 722 * Copy columns. This is slow, and hard to optimize due to alignment, 723 * and the fact that we have to copy both left->right and right->left. 724 * We simply cop-out here and use memmove(), since it handles all of 725 * these cases anyway. 726 */ 727 void 728 rasops_copycols(void *cookie, int row, int src, int dst, int num) 729 { 730 struct rasops_info *ri = (struct rasops_info *)cookie; 731 uint8_t *sp, *dp, *hp; 732 int height; 733 734 hp = NULL; /* XXX GCC */ 735 736 #ifdef RASOPS_CLIPPING 737 if (dst == src) 738 return; 739 740 /* Catches < 0 case too */ 741 if ((unsigned)row >= (unsigned)ri->ri_rows) 742 return; 743 744 if (src < 0) { 745 num += src; 746 src = 0; 747 } 748 749 if (src + num > ri->ri_cols) 750 num = ri->ri_cols - src; 751 752 if (dst < 0) { 753 num += dst; 754 dst = 0; 755 } 756 757 if (dst + num > ri->ri_cols) 758 num = ri->ri_cols - dst; 759 760 if (num <= 0) 761 return; 762 #endif 763 764 num *= ri->ri_xscale; 765 row *= ri->ri_yscale; 766 height = ri->ri_font->fontheight; 767 768 sp = ri->ri_bits + row + src * ri->ri_xscale; 769 dp = ri->ri_bits + row + dst * ri->ri_xscale; 770 if (ri->ri_hwbits) 771 hp = ri->ri_hwbits + row + dst * ri->ri_xscale; 772 773 while (height--) { 774 memmove(dp, sp, num); 775 dp += ri->ri_stride; 776 if (ri->ri_hwbits) { 777 memcpy(hp, sp, num); 778 hp += ri->ri_stride; 779 } 780 sp += ri->ri_stride; 781 } 782 } 783 784 /* 785 * Turn cursor off/on. 786 */ 787 static void 788 rasops_cursor(void *cookie, int on, int row, int col) 789 { 790 struct rasops_info *ri = (struct rasops_info *)cookie; 791 792 /* Turn old cursor off */ 793 if ((ri->ri_flg & RI_CURSOR) != 0) 794 #ifdef RASOPS_CLIPPING 795 if ((ri->ri_flg & RI_CURSORCLIP) == 0) 796 #endif 797 ri->ri_do_cursor(ri); 798 799 /* Select new cursor */ 800 #ifdef RASOPS_CLIPPING 801 ri->ri_flg &= ~RI_CURSORCLIP; 802 803 if (row < 0 || row >= ri->ri_rows) 804 ri->ri_flg |= RI_CURSORCLIP; 805 else if (col < 0 || col >= ri->ri_cols) 806 ri->ri_flg |= RI_CURSORCLIP; 807 #endif 808 ri->ri_crow = row; 809 ri->ri_ccol = col; 810 811 if (on) { 812 ri->ri_flg |= RI_CURSOR; 813 #ifdef RASOPS_CLIPPING 814 if ((ri->ri_flg & RI_CURSORCLIP) == 0) 815 #endif 816 ri->ri_do_cursor(ri); 817 } else 818 ri->ri_flg &= ~RI_CURSOR; 819 } 820 821 /* 822 * Make the device colormap 823 */ 824 static void 825 rasops_init_devcmap(struct rasops_info *ri) 826 { 827 int i; 828 uint32_t c; 829 const uint8_t *p; 830 831 switch (ri->ri_depth) { 832 case 1: 833 ri->ri_devcmap[0] = 0; 834 for (i = 1; i < 16; i++) 835 ri->ri_devcmap[i] = -1; 836 return; 837 838 case 2: 839 for (i = 1; i < 15; i++) 840 ri->ri_devcmap[i] = 0xaaaaaaaa; 841 842 ri->ri_devcmap[0] = 0; 843 ri->ri_devcmap[8] = 0x55555555; 844 ri->ri_devcmap[15] = -1; 845 return; 846 847 #ifdef RASOPS_APPLE_PALETTE 848 case 4: 849 for (i = 0; i < 16; i++) { 850 c = apple4_devcmap[i]; 851 ri->ri_devcmap[i] = 852 (c << 0) | (c << 4) | (c << 8) | (c << 12) | 853 (c << 16) | (c << 20) | (c << 24) | (c << 28); 854 } 855 return; 856 #else 857 /* XXXRO What should we do here? */ 858 #endif 859 860 case 8: 861 if ((ri->ri_flg & RI_8BIT_IS_RGB) == 0) { 862 for (i = 0; i < 16; i++) { 863 #ifdef RASOPS_APPLE_PALETTE 864 c = apple8_devcmap[i]; 865 #else 866 c = i; 867 #endif 868 ri->ri_devcmap[i] = 869 c | (c << 8) | (c << 16) | (c << 24); 870 } 871 return; 872 } 873 } 874 875 p = rasops_cmap; 876 877 for (i = 0; i < 16; i++) { 878 if (ri->ri_rnum <= 8) 879 c = (uint32_t)(*p >> (8 - ri->ri_rnum)) << ri->ri_rpos; 880 else 881 c = (uint32_t)(*p << (ri->ri_rnum - 8)) << ri->ri_rpos; 882 p++; 883 884 if (ri->ri_gnum <= 8) 885 c |= (uint32_t)(*p >> (8 - ri->ri_gnum)) << ri->ri_gpos; 886 else 887 c |= (uint32_t)(*p << (ri->ri_gnum - 8)) << ri->ri_gpos; 888 p++; 889 890 if (ri->ri_bnum <= 8) 891 c |= (uint32_t)(*p >> (8 - ri->ri_bnum)) << ri->ri_bpos; 892 else 893 c |= (uint32_t)(*p << (ri->ri_bnum - 8)) << ri->ri_bpos; 894 p++; 895 896 /* Fill the word for generic routines, which want this */ 897 if (ri->ri_depth == 8) { 898 c |= c << 8; 899 c |= c << 16; 900 } else if (ri->ri_depth == 15 || ri->ri_depth == 16) 901 c |= c << 16; 902 else if (ri->ri_depth == 24) { 903 #if BYTE_ORDER == LITTLE_ENDIAN 904 # ifndef RASOPS_SMALL 905 if (ri->ri_font->fontwidth != 12) 906 # endif 907 c = (c & 0x0000ff) << 16 | (c & 0x00ff00) | 908 (c & 0xff0000) >> 16; 909 # ifndef RASOPS_SMALL 910 else 911 c = (c & 0x0000ff) | (c & 0x00ff00) << 8 | 912 (c & 0xff0000) >> 8; 913 # endif 914 #else 915 /* XXXRO What should we do here? */ 916 #endif 917 c |= (c & 0xff) << 24; 918 } 919 920 /* 24bpp does bswap on the fly. {32,16,15}bpp do it here. */ 921 if ((ri->ri_flg & RI_BSWAP) == 0) 922 ri->ri_devcmap[i] = c; 923 else if (ri->ri_depth == 15 || ri->ri_depth == 16) 924 ri->ri_devcmap[i] = bswap16(c); 925 else if (ri->ri_depth == 32) 926 ri->ri_devcmap[i] = bswap32(c); 927 else /* 8, 24 */ 928 ri->ri_devcmap[i] = c; 929 } 930 } 931 932 /* 933 * Unpack a rasops attribute 934 */ 935 void 936 rasops_unpack_attr(long attr, int *fg, int *bg, int *underline) 937 { 938 939 *fg = ((uint32_t)attr >> 24) & 0xf; 940 *bg = ((uint32_t)attr >> 16) & 0xf; 941 if (underline != NULL) 942 *underline = (uint32_t)attr & WSATTR_UNDERLINE; 943 } 944 945 /* 946 * Erase rows. This isn't static, since 24-bpp uses it in special cases. 947 */ 948 void 949 rasops_eraserows(void *cookie, int row, int num, long attr) 950 { 951 struct rasops_info *ri = (struct rasops_info *)cookie; 952 uint32_t *dp, *hp, clr; 953 int n, cnt, delta; 954 955 hp = NULL; /* XXX GCC */ 956 957 #ifdef RASOPS_CLIPPING 958 if (row < 0) { 959 num += row; 960 row = 0; 961 } 962 963 if (row + num > ri->ri_rows) 964 num = ri->ri_rows - row; 965 966 if (num <= 0) 967 return; 968 #endif 969 970 clr = ri->ri_devcmap[((uint32_t)attr >> 16) & 0xf]; 971 972 /* 973 * XXX The wsdisplay_emulops interface seems a little deficient in 974 * that there is no way to clear the *entire* screen. We provide a 975 * workaround here: if the entire console area is being cleared, and 976 * the RI_FULLCLEAR flag is set, clear the entire display. 977 */ 978 if (num == ri->ri_rows && (ri->ri_flg & RI_FULLCLEAR) != 0) { 979 n = ri->ri_stride >> 2; 980 num = ri->ri_height; 981 dp = (uint32_t *)ri->ri_origbits; 982 if (ri->ri_hwbits) 983 hp = (uint32_t *)ri->ri_hworigbits; 984 delta = 0; 985 } else { 986 n = ri->ri_emustride >> 2; 987 num *= ri->ri_font->fontheight; 988 dp = (uint32_t *)(ri->ri_bits + row * ri->ri_yscale); 989 if (ri->ri_hwbits) 990 hp = (uint32_t *)(ri->ri_hwbits + row * 991 ri->ri_yscale); 992 delta = ri->ri_delta; 993 } 994 995 while (num--) { 996 for (cnt = n; cnt; cnt--) { 997 *dp++ = clr; 998 if (ri->ri_hwbits) 999 *hp++ = clr; 1000 } 1001 DELTA(dp, delta, uint32_t *); 1002 if (ri->ri_hwbits) 1003 DELTA(hp, delta, uint32_t *); 1004 } 1005 } 1006 1007 /* 1008 * Actually turn the cursor on or off. This does the dirty work for 1009 * rasops_cursor(). 1010 */ 1011 static void 1012 rasops_do_cursor(struct rasops_info *ri) 1013 { 1014 int full, height, cnt, slop1, slop2, row, col; 1015 uint32_t tmp32, msk1, msk2; 1016 uint8_t tmp8; 1017 uint8_t *dp, *rp, *hrp, *hp; 1018 1019 hrp = hp = NULL; /* XXX GCC */ 1020 1021 #if NRASOPS_ROTATION > 0 1022 if (ri->ri_flg & RI_ROTATE_MASK) { 1023 if (ri->ri_flg & RI_ROTATE_CW) { 1024 /* Rotate rows/columns */ 1025 row = ri->ri_ccol; 1026 col = ri->ri_rows - ri->ri_crow - 1; 1027 } else if (ri->ri_flg & RI_ROTATE_CCW) { 1028 /* Rotate rows/columns */ 1029 row = ri->ri_cols - ri->ri_ccol - 1; 1030 col = ri->ri_crow; 1031 } else { /* upside-down */ 1032 row = ri->ri_crow; 1033 col = ri->ri_ccol; 1034 } 1035 } else 1036 #endif 1037 { 1038 row = ri->ri_crow; 1039 col = ri->ri_ccol; 1040 } 1041 1042 rp = ri->ri_bits + row * ri->ri_yscale + col * ri->ri_xscale; 1043 if (ri->ri_hwbits) 1044 hrp = ri->ri_hwbits + row * ri->ri_yscale + col 1045 * ri->ri_xscale; 1046 height = ri->ri_font->fontheight; 1047 1048 /* 1049 * For ri_xscale = 1: 1050 * 1051 * Logic below does not work for ri_xscale = 1, e.g., 1052 * fontwidth = 8 and bpp = 1. So we take care of it. 1053 */ 1054 if (ri->ri_xscale == 1) { 1055 while (height--) { 1056 tmp8 = ~*rp; 1057 1058 *rp = tmp8; 1059 rp += ri->ri_stride; 1060 1061 if (ri->ri_hwbits) { 1062 *hrp = tmp8; 1063 hrp += ri->ri_stride; 1064 } 1065 } 1066 return; 1067 } 1068 1069 /* 1070 * For ri_xscale = 2, 3, 4, ...: 1071 * 1072 * Note that siop1 <= ri_xscale even for ri_xscale = 2, 1073 * since rp % 3 = 0 or 2 (ri_stride % 4 = 0). 1074 */ 1075 slop1 = (4 - ((uintptr_t)rp & 3)) & 3; 1076 slop2 = (ri->ri_xscale - slop1) & 3; 1077 full = (ri->ri_xscale - slop1 /* - slop2 */) >> 2; 1078 1079 rp = (uint8_t *)((uintptr_t)rp & ~3); 1080 hrp = (uint8_t *)((uintptr_t)hrp & ~3); 1081 1082 msk1 = !slop1 ? 0 : be32toh(0xffffffffU >> (32 - (8 * slop1))); 1083 msk2 = !slop2 ? 0 : be32toh(0xffffffffU << (32 - (8 * slop2))); 1084 1085 while (height--) { 1086 dp = rp; 1087 rp += ri->ri_stride; 1088 if (ri->ri_hwbits) { 1089 hp = hrp; 1090 hrp += ri->ri_stride; 1091 } 1092 1093 if (slop1) { 1094 tmp32 = *(uint32_t *)dp ^ msk1; 1095 *(uint32_t *)dp = tmp32; 1096 dp += 4; 1097 if (ri->ri_hwbits) { 1098 *(uint32_t *)hp = tmp32; 1099 hp += 4; 1100 } 1101 } 1102 1103 for (cnt = full; cnt; cnt--) { 1104 tmp32 = ~*(uint32_t *)dp; 1105 *(uint32_t *)dp = tmp32; 1106 dp += 4; 1107 if (ri->ri_hwbits) { 1108 *(uint32_t *)hp = tmp32; 1109 hp += 4; 1110 } 1111 } 1112 1113 if (slop2) { 1114 tmp32 = *(uint32_t *)dp ^ msk2; 1115 *(uint32_t *)dp = tmp32; 1116 if (ri->ri_hwbits) 1117 *(uint32_t *)hp = tmp32; 1118 } 1119 } 1120 } 1121 1122 /* 1123 * Erase columns. 1124 */ 1125 void 1126 rasops_erasecols(void *cookie, int row, int col, int num, long attr) 1127 { 1128 struct rasops_info *ri = (struct rasops_info *)cookie; 1129 int height, cnt, slop1, slop2, clr; 1130 uint32_t *rp, *dp, *hrp, *hp; 1131 1132 hrp = hp = NULL; /* XXX GCC */ 1133 1134 #ifdef RASOPS_CLIPPING 1135 if ((unsigned)row >= (unsigned)ri->ri_rows) 1136 return; 1137 1138 if (col < 0) { 1139 num += col; 1140 col = 0; 1141 } 1142 1143 if ((col + num) > ri->ri_cols) 1144 num = ri->ri_cols - col; 1145 1146 if (num <= 0) 1147 return; 1148 #endif 1149 1150 num *= ri->ri_xscale; 1151 rp = (uint32_t *)(ri->ri_bits + row*ri->ri_yscale + col*ri->ri_xscale); 1152 if (ri->ri_hwbits) 1153 hrp = (uint32_t *)(ri->ri_hwbits + row*ri->ri_yscale + 1154 col*ri->ri_xscale); 1155 height = ri->ri_font->fontheight; 1156 clr = ri->ri_devcmap[((uint32_t)attr >> 16) & 0xf]; 1157 1158 /* Don't bother using the full loop for <= 32 pels */ 1159 if (num <= 32) { 1160 if (((num | ri->ri_xscale) & 3) == 0) { 1161 /* Word aligned blt */ 1162 num >>= 2; 1163 1164 while (height--) { 1165 dp = rp; 1166 DELTA(rp, ri->ri_stride, uint32_t *); 1167 if (ri->ri_hwbits) { 1168 hp = hrp; 1169 DELTA(hrp, ri->ri_stride, uint32_t *); 1170 } 1171 1172 for (cnt = num; cnt; cnt--) { 1173 *dp++ = clr; 1174 if (ri->ri_hwbits) 1175 *hp++ = clr; 1176 } 1177 } 1178 } else if (((num | ri->ri_xscale) & 1) == 0) { 1179 /* 1180 * Halfword aligned blt. This is needed so the 1181 * 15/16 bit ops can use this function. 1182 */ 1183 num >>= 1; 1184 1185 while (height--) { 1186 dp = rp; 1187 DELTA(rp, ri->ri_stride, uint32_t *); 1188 if (ri->ri_hwbits) { 1189 hp = hrp; 1190 DELTA(hrp, ri->ri_stride, uint32_t *); 1191 } 1192 1193 for (cnt = num; cnt; cnt--) { 1194 *(uint16_t *)dp = clr; 1195 DELTA(dp, 2, uint32_t *); 1196 if (ri->ri_hwbits) { 1197 *(uint16_t *)hp = clr; 1198 DELTA(hp, 2, uint32_t *); 1199 } 1200 } 1201 } 1202 } else { 1203 while (height--) { 1204 dp = rp; 1205 DELTA(rp, ri->ri_stride, uint32_t *); 1206 if (ri->ri_hwbits) { 1207 hp = hrp; 1208 DELTA(hrp, ri->ri_stride, uint32_t *); 1209 } 1210 1211 for (cnt = num; cnt; cnt--) { 1212 *(uint8_t *)dp = clr; 1213 DELTA(dp, 1, uint32_t *); 1214 if (ri->ri_hwbits) { 1215 *(uint8_t *)hp = clr; 1216 DELTA(hp, 1, uint32_t *); 1217 } 1218 } 1219 } 1220 } 1221 1222 return; 1223 } 1224 1225 slop1 = (4 - ((uintptr_t)rp & 3)) & 3; 1226 slop2 = (num - slop1) & 3; 1227 num = (num - slop1 /* - slop2 */) >> 2; 1228 1229 while (height--) { 1230 dp = rp; 1231 DELTA(rp, ri->ri_stride, uint32_t *); 1232 if (ri->ri_hwbits) { 1233 hp = hrp; 1234 DELTA(hrp, ri->ri_stride, uint32_t *); 1235 } 1236 1237 /* Align span to 4 bytes */ 1238 if (slop1 & 1) { 1239 *(uint8_t *)dp = clr; 1240 DELTA(dp, 1, uint32_t *); 1241 if (ri->ri_hwbits) { 1242 *(uint8_t *)hp = clr; 1243 DELTA(hp, 1, uint32_t *); 1244 } 1245 } 1246 1247 if (slop1 & 2) { 1248 *(uint16_t *)dp = clr; 1249 DELTA(dp, 2, uint32_t *); 1250 if (ri->ri_hwbits) { 1251 *(uint16_t *)hp = clr; 1252 DELTA(hp, 2, uint32_t *); 1253 } 1254 } 1255 1256 /* Write 4 bytes per loop */ 1257 for (cnt = num; cnt; cnt--) { 1258 *dp++ = clr; 1259 if (ri->ri_hwbits) 1260 *hp++ = clr; 1261 } 1262 1263 /* Write unaligned trailing slop */ 1264 if (slop2 & 1) { 1265 *(uint8_t *)dp = clr; 1266 DELTA(dp, 1, uint32_t *); 1267 if (ri->ri_hwbits) { 1268 *(uint8_t *)hp = clr; 1269 DELTA(hp, 1, uint32_t *); 1270 } 1271 } 1272 1273 if (slop2 & 2) { 1274 *(uint16_t *)dp = clr; 1275 if (ri->ri_hwbits) 1276 *(uint16_t *)hp = clr; 1277 } 1278 } 1279 } 1280 1281 #if NRASOPS_ROTATION > 0 1282 /* 1283 * Quarter clockwise rotation routines (originally intended for the 1284 * built-in Zaurus C3x00 display in 16bpp). 1285 */ 1286 1287 static void 1288 rasops_rotate_font(int *cookie, int rotate) 1289 { 1290 struct rotatedfont *f; 1291 int ncookie; 1292 1293 SLIST_FOREACH(f, &rotatedfonts, rf_next) { 1294 if (f->rf_cookie == *cookie) { 1295 *cookie = f->rf_rotated; 1296 return; 1297 } 1298 } 1299 1300 /* 1301 * We did not find a rotated version of this font. Ask the wsfont 1302 * code to compute one for us. 1303 */ 1304 1305 f = kmem_alloc(sizeof(*f), KM_SLEEP); 1306 1307 if ((ncookie = wsfont_rotate(*cookie, rotate)) == -1) 1308 goto fail; 1309 1310 f->rf_cookie = *cookie; 1311 f->rf_rotated = ncookie; 1312 SLIST_INSERT_HEAD(&rotatedfonts, f, rf_next); 1313 1314 *cookie = ncookie; 1315 return; 1316 1317 fail: kmem_free(f, sizeof(*f)); 1318 return; 1319 } 1320 1321 static void 1322 rasops_copychar(void *cookie, int srcrow, int dstrow, int srccol, int dstcol) 1323 { 1324 struct rasops_info *ri = (struct rasops_info *)cookie; 1325 int height; 1326 int r_srcrow, r_dstrow, r_srccol, r_dstcol; 1327 uint8_t *sp, *dp; 1328 1329 r_srcrow = srccol; 1330 r_dstrow = dstcol; 1331 r_srccol = ri->ri_rows - srcrow - 1; 1332 r_dstcol = ri->ri_rows - dstrow - 1; 1333 1334 r_srcrow *= ri->ri_yscale; 1335 r_dstrow *= ri->ri_yscale; 1336 height = ri->ri_font->fontheight; 1337 1338 sp = ri->ri_bits + r_srcrow + r_srccol * ri->ri_xscale; 1339 dp = ri->ri_bits + r_dstrow + r_dstcol * ri->ri_xscale; 1340 1341 while (height--) { 1342 memmove(dp, sp, ri->ri_xscale); 1343 dp += ri->ri_stride; 1344 sp += ri->ri_stride; 1345 } 1346 } 1347 1348 static void 1349 rasops_putchar_rotated_cw(void *cookie, int row, int col, u_int uc, long attr) 1350 { 1351 struct rasops_info *ri = (struct rasops_info *)cookie; 1352 int height; 1353 uint8_t *rp; 1354 1355 if (__predict_false((unsigned int)row > ri->ri_rows || 1356 (unsigned int)col > ri->ri_cols)) 1357 return; 1358 1359 /* Avoid underflow */ 1360 if (ri->ri_rows - row - 1 < 0) 1361 return; 1362 1363 /* Do rotated char sans (side)underline */ 1364 ri->ri_real_ops.putchar(cookie, col, ri->ri_rows - row - 1, uc, 1365 attr & ~WSATTR_UNDERLINE); 1366 1367 /* Do rotated underline */ 1368 rp = ri->ri_bits + col * ri->ri_yscale + (ri->ri_rows - row - 1) * 1369 ri->ri_xscale; 1370 height = ri->ri_font->fontheight; 1371 1372 /* XXX this assumes 16-bit color depth */ 1373 if ((attr & WSATTR_UNDERLINE) != 0) { 1374 uint16_t c = 1375 (uint16_t)ri->ri_devcmap[((uint32_t)attr >> 24) & 0xf]; 1376 1377 while (height--) { 1378 *(uint16_t *)rp = c; 1379 rp += ri->ri_stride; 1380 } 1381 } 1382 } 1383 1384 static void 1385 rasops_erasecols_rotated_cw(void *cookie, int row, int col, int num, long attr) 1386 { 1387 struct rasops_info *ri = (struct rasops_info *)cookie; 1388 int i; 1389 1390 for (i = col; i < col + num; i++) 1391 ri->ri_ops.putchar(cookie, row, i, ' ', attr); 1392 } 1393 1394 /* XXX: these could likely be optimised somewhat. */ 1395 static void 1396 rasops_copyrows_rotated_cw(void *cookie, int src, int dst, int num) 1397 { 1398 struct rasops_info *ri = (struct rasops_info *)cookie; 1399 int col, roff; 1400 1401 if (src > dst) 1402 for (roff = 0; roff < num; roff++) 1403 for (col = 0; col < ri->ri_cols; col++) 1404 rasops_copychar(cookie, src + roff, dst + roff, 1405 col, col); 1406 else 1407 for (roff = num - 1; roff >= 0; roff--) 1408 for (col = 0; col < ri->ri_cols; col++) 1409 rasops_copychar(cookie, src + roff, dst + roff, 1410 col, col); 1411 } 1412 1413 static void 1414 rasops_copycols_rotated_cw(void *cookie, int row, int src, int dst, int num) 1415 { 1416 int coff; 1417 1418 if (src > dst) 1419 for (coff = 0; coff < num; coff++) 1420 rasops_copychar(cookie, row, row, src + coff, 1421 dst + coff); 1422 else 1423 for (coff = num - 1; coff >= 0; coff--) 1424 rasops_copychar(cookie, row, row, src + coff, 1425 dst + coff); 1426 } 1427 1428 static void 1429 rasops_eraserows_rotated_cw(void *cookie, int row, int num, long attr) 1430 { 1431 struct rasops_info *ri = (struct rasops_info *)cookie; 1432 int col, rn; 1433 1434 for (rn = row; rn < row + num; rn++) 1435 for (col = 0; col < ri->ri_cols; col++) 1436 ri->ri_ops.putchar(cookie, rn, col, ' ', attr); 1437 } 1438 1439 /* 1440 * Quarter counter-clockwise rotation routines (originally intended for the 1441 * built-in Sharp W-ZERO3 display in 16bpp). 1442 */ 1443 static void 1444 rasops_copychar_ccw(void *cookie, int srcrow, int dstrow, int srccol, 1445 int dstcol) 1446 { 1447 struct rasops_info *ri = (struct rasops_info *)cookie; 1448 int height, r_srcrow, r_dstrow, r_srccol, r_dstcol; 1449 uint8_t *sp, *dp; 1450 1451 r_srcrow = ri->ri_cols - srccol - 1; 1452 r_dstrow = ri->ri_cols - dstcol - 1; 1453 r_srccol = srcrow; 1454 r_dstcol = dstrow; 1455 1456 r_srcrow *= ri->ri_yscale; 1457 r_dstrow *= ri->ri_yscale; 1458 height = ri->ri_font->fontheight; 1459 1460 sp = ri->ri_bits + r_srcrow + r_srccol * ri->ri_xscale; 1461 dp = ri->ri_bits + r_dstrow + r_dstcol * ri->ri_xscale; 1462 1463 while (height--) { 1464 memmove(dp, sp, ri->ri_xscale); 1465 dp += ri->ri_stride; 1466 sp += ri->ri_stride; 1467 } 1468 } 1469 1470 static void 1471 rasops_putchar_rotated_ccw(void *cookie, int row, int col, u_int uc, long attr) 1472 { 1473 struct rasops_info *ri = (struct rasops_info *)cookie; 1474 int height; 1475 uint8_t *rp; 1476 1477 if (__predict_false((unsigned int)row > ri->ri_rows || 1478 (unsigned int)col > ri->ri_cols)) 1479 return; 1480 1481 /* Avoid underflow */ 1482 if (ri->ri_cols - col - 1 < 0) 1483 return; 1484 1485 /* Do rotated char sans (side)underline */ 1486 ri->ri_real_ops.putchar(cookie, ri->ri_cols - col - 1, row, uc, 1487 attr & ~WSATTR_UNDERLINE); 1488 1489 /* Do rotated underline */ 1490 rp = ri->ri_bits + (ri->ri_cols - col - 1) * ri->ri_yscale + 1491 row * ri->ri_xscale + 1492 (ri->ri_font->fontwidth - 1) * ri->ri_pelbytes; 1493 height = ri->ri_font->fontheight; 1494 1495 /* XXX this assumes 16-bit color depth */ 1496 if ((attr & WSATTR_UNDERLINE) != 0) { 1497 uint16_t c = 1498 (uint16_t)ri->ri_devcmap[((uint32_t)attr >> 24) & 0xf]; 1499 1500 while (height--) { 1501 *(uint16_t *)rp = c; 1502 rp += ri->ri_stride; 1503 } 1504 } 1505 } 1506 1507 /* XXX: these could likely be optimised somewhat. */ 1508 static void 1509 rasops_copyrows_rotated_ccw(void *cookie, int src, int dst, int num) 1510 { 1511 struct rasops_info *ri = (struct rasops_info *)cookie; 1512 int col, roff; 1513 1514 if (src > dst) 1515 for (roff = 0; roff < num; roff++) 1516 for (col = 0; col < ri->ri_cols; col++) 1517 rasops_copychar_ccw(cookie, 1518 src + roff, dst + roff, col, col); 1519 else 1520 for (roff = num - 1; roff >= 0; roff--) 1521 for (col = 0; col < ri->ri_cols; col++) 1522 rasops_copychar_ccw(cookie, 1523 src + roff, dst + roff, col, col); 1524 } 1525 1526 static void 1527 rasops_copycols_rotated_ccw(void *cookie, int row, int src, int dst, int num) 1528 { 1529 int coff; 1530 1531 if (src > dst) 1532 for (coff = 0; coff < num; coff++) 1533 rasops_copychar_ccw(cookie, row, row, 1534 src + coff, dst + coff); 1535 else 1536 for (coff = num - 1; coff >= 0; coff--) 1537 rasops_copychar_ccw(cookie, row, row, 1538 src + coff, dst + coff); 1539 } 1540 #endif /* NRASOPS_ROTATION */ 1541 1542 void 1543 rasops_make_box_chars_16(struct rasops_info *ri) 1544 { 1545 int c, i, mid; 1546 uint16_t vert_mask, hmask_left, hmask_right; 1547 uint16_t *data = (uint16_t *)ri->ri_optfont.data; 1548 1549 vert_mask = 0xc000U >> ((ri->ri_font->fontwidth >> 1) - 1); 1550 hmask_left = 0xff00U << (8 - (ri->ri_font->fontwidth >> 1)); 1551 hmask_right = hmask_left >> ((ri->ri_font->fontwidth + 1) >> 1); 1552 mid = (ri->ri_font->fontheight + 1) >> 1; 1553 1554 /* 0x00 would be empty anyway so don't bother */ 1555 for (c = 1; c < 16; c++) { 1556 data += ri->ri_font->fontheight; 1557 if (c & 1) { 1558 /* upper segment */ 1559 for (i = 0; i < mid; i++) 1560 data[i] = vert_mask; 1561 } 1562 if (c & 4) { 1563 /* lower segment */ 1564 for (i = mid; i < ri->ri_font->fontheight; i++) 1565 data[i] = vert_mask; 1566 } 1567 if (c & 2) { 1568 /* right segment */ 1569 i = ri->ri_font->fontheight >> 1; 1570 data[mid - 1] |= hmask_right; 1571 data[mid] |= hmask_right; 1572 } 1573 if (c & 8) { 1574 /* left segment */ 1575 data[mid - 1] |= hmask_left; 1576 data[mid] |= hmask_left; 1577 } 1578 } 1579 } 1580 1581 void 1582 rasops_make_box_chars_8(struct rasops_info *ri) 1583 { 1584 int c, i, mid; 1585 uint8_t vert_mask, hmask_left, hmask_right; 1586 uint8_t *data = (uint8_t *)ri->ri_optfont.data; 1587 1588 vert_mask = 0xc0U >> ((ri->ri_font->fontwidth >> 1) - 1); 1589 hmask_left = 0xf0U << (4 - (ri->ri_font->fontwidth >> 1)); 1590 hmask_right = hmask_left >> ((ri->ri_font->fontwidth + 1) >> 1); 1591 mid = (ri->ri_font->fontheight + 1) >> 1; 1592 1593 /* 0x00 would be empty anyway so don't bother */ 1594 for (c = 1; c < 16; c++) { 1595 data += ri->ri_font->fontheight; 1596 if (c & 1) { 1597 /* upper segment */ 1598 for (i = 0; i < mid; i++) 1599 data[i] = vert_mask; 1600 } 1601 if (c & 4) { 1602 /* lower segment */ 1603 for (i = mid; i < ri->ri_font->fontheight; i++) 1604 data[i] = vert_mask; 1605 } 1606 if (c & 2) { 1607 /* right segment */ 1608 i = ri->ri_font->fontheight >> 1; 1609 data[mid - 1] |= hmask_right; 1610 data[mid] |= hmask_right; 1611 } 1612 if (c & 8) { 1613 /* left segment */ 1614 data[mid - 1] |= hmask_left; 1615 data[mid] |= hmask_left; 1616 } 1617 } 1618 } 1619 1620 void 1621 rasops_make_box_chars_32(struct rasops_info *ri) 1622 { 1623 int c, i, mid; 1624 uint32_t vert_mask, hmask_left, hmask_right; 1625 uint32_t *data = (uint32_t *)ri->ri_optfont.data; 1626 1627 vert_mask = 0xc0000000U >> ((ri->ri_font->fontwidth >> 1) - 1); 1628 hmask_left = 0xffff0000U << (16 - (ri->ri_font->fontwidth >> 1)); 1629 hmask_right = hmask_left >> ((ri->ri_font->fontwidth + 1) >> 1); 1630 mid = (ri->ri_font->fontheight + 1) >> 1; 1631 1632 /* 0x00 would be empty anyway so don't bother */ 1633 for (c = 1; c < 16; c++) { 1634 data += ri->ri_font->fontheight; 1635 if (c & 1) { 1636 /* upper segment */ 1637 for (i = 0; i < mid; i++) 1638 data[i] = vert_mask; 1639 } 1640 if (c & 4) { 1641 /* lower segment */ 1642 for (i = mid; i < ri->ri_font->fontheight; i++) 1643 data[i] = vert_mask; 1644 } 1645 if (c & 2) { 1646 /* right segment */ 1647 i = ri->ri_font->fontheight >> 1; 1648 data[mid - 1] |= hmask_right; 1649 data[mid] |= hmask_right; 1650 } 1651 if (c & 8) { 1652 /* left segment */ 1653 data[mid - 1] |= hmask_left; 1654 data[mid] |= hmask_left; 1655 } 1656 } 1657 } 1658 1659 void 1660 rasops_make_box_chars_alpha(struct rasops_info *ri) 1661 { 1662 int c, i, hmid, vmid, wi, he; 1663 uint8_t *data = (uint8_t *)ri->ri_optfont.data; 1664 uint8_t *ddata; 1665 1666 he = ri->ri_font->fontheight; 1667 wi = ri->ri_font->fontwidth; 1668 1669 vmid = (he + 1) >> 1; 1670 hmid = (wi + 1) >> 1; 1671 1672 /* 0x00 would be empty anyway so don't bother */ 1673 for (c = 1; c < 16; c++) { 1674 data += ri->ri_fontscale; 1675 if (c & 1) { 1676 /* upper segment */ 1677 ddata = data + hmid; 1678 for (i = 0; i <= vmid; i++) { 1679 *ddata = 0xff; 1680 ddata += wi; 1681 } 1682 } 1683 if (c & 4) { 1684 /* lower segment */ 1685 ddata = data + wi * vmid + hmid; 1686 for (i = vmid; i < he; i++) { 1687 *ddata = 0xff; 1688 ddata += wi; 1689 } 1690 } 1691 if (c & 2) { 1692 /* right segment */ 1693 ddata = data + wi * vmid + hmid; 1694 for (i = hmid; i < wi; i++) { 1695 *ddata = 0xff; 1696 ddata++; 1697 } 1698 } 1699 if (c & 8) { 1700 /* left segment */ 1701 ddata = data + wi * vmid; 1702 for (i = 0; i <= hmid; i++) { 1703 *ddata = 0xff; 1704 ddata++; 1705 } 1706 } 1707 } 1708 } 1709 1710 /* 1711 * Return a colour map appropriate for the given struct rasops_info in the 1712 * same form used by rasops_cmap[] 1713 * For now this is either a copy of rasops_cmap[] or an R3G3B2 map, it should 1714 * probably be a linear ( or gamma corrected? ) ramp for higher depths. 1715 */ 1716 1717 int 1718 rasops_get_cmap(struct rasops_info *ri, uint8_t *palette, size_t bytes) 1719 { 1720 1721 if ((ri->ri_depth == 8) && ((ri->ri_flg & RI_8BIT_IS_RGB) != 0)) { 1722 /* generate an R3G3B2 palette */ 1723 int i, idx = 0; 1724 uint8_t tmp; 1725 1726 if (bytes < 768) 1727 return EINVAL; 1728 for (i = 0; i < 256; i++) { 1729 tmp = i & 0xe0; 1730 /* 1731 * replicate bits so 0xe0 maps to a red value of 0xff 1732 * in order to make white look actually white 1733 */ 1734 tmp |= (tmp >> 3) | (tmp >> 6); 1735 palette[idx] = tmp; 1736 idx++; 1737 1738 tmp = (i & 0x1c) << 3; 1739 tmp |= (tmp >> 3) | (tmp >> 6); 1740 palette[idx] = tmp; 1741 idx++; 1742 1743 tmp = (i & 0x03) << 6; 1744 tmp |= tmp >> 2; 1745 tmp |= tmp >> 4; 1746 palette[idx] = tmp; 1747 idx++; 1748 } 1749 } else 1750 memcpy(palette, rasops_cmap, uimin(bytes, sizeof(rasops_cmap))); 1751 return 0; 1752 } 1753
Indexes created Tue Sep 23 23:09:58 GMT 2025