1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright 2020 Toomas Soome 5 * Copyright 2019 OmniOS Community Edition (OmniOSce) Association. 6 * Copyright 2020 RackTop Systems, Inc. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 /* 31 * The workhorse here is gfxfb_blt(). It is implemented to mimic UEFI 32 * GOP Blt, and allows us to fill the rectangle on screen, copy 33 * rectangle from video to buffer and buffer to video and video to video. 34 * Such implementation does allow us to have almost identical implementation 35 * for both BIOS VBE and UEFI. 36 * 37 * ALL pixel data is assumed to be 32-bit BGRA (byte order Blue, Green, Red, 38 * Alpha) format, this allows us to only handle RGB data and not to worry 39 * about mixing RGB with indexed colors. 40 * Data exchange between memory buffer and video will translate BGRA 41 * and native format as following: 42 * 43 * 32-bit to/from 32-bit is trivial case. 44 * 32-bit to/from 24-bit is also simple - we just drop the alpha channel. 45 * 32-bit to/from 16-bit is more complicated, because we nee to handle 46 * data loss from 32-bit to 16-bit. While reading/writing from/to video, we 47 * need to apply masks of 16-bit color components. This will preserve 48 * colors for terminal text. For 32-bit truecolor PMG images, we need to 49 * translate 32-bit colors to 15/16 bit colors and this means data loss. 50 * There are different algorithms how to perform such color space reduction, 51 * we are currently using bitwise right shift to reduce color space and so far 52 * this technique seems to be sufficient (see also gfx_fb_putimage(), the 53 * end of for loop). 54 * 32-bit to/from 8-bit is the most troublesome because 8-bit colors are 55 * indexed. From video, we do get color indexes, and we do translate 56 * color index values to RGB. To write to video, we again need to translate 57 * RGB to color index. Additionally, we need to translate between VGA and 58 * console colors. 59 * 60 * Our internal color data is represented using BGRA format. But the hardware 61 * used indexed colors for 8-bit colors (0-255) and for this mode we do 62 * need to perform translation to/from BGRA and index values. 63 * 64 * - paletteentry RGB <-> index - 65 * BGRA BUFFER <----/ \ - VIDEO 66 * \ / 67 * - RGB (16/24/32) - 68 * 69 * To perform index to RGB translation, we use palette table generated 70 * from when we set up 8-bit mode video. We cannot read palette data from 71 * the hardware, because not all hardware supports reading it. 72 * 73 * BGRA to index is implemented in rgb_to_color_index() by searching 74 * palette array for closest match of RBG values. 75 * 76 * Note: In 8-bit mode, We do store first 16 colors to palette registers 77 * in VGA color order, this serves two purposes; firstly, 78 * if palette update is not supported, we still have correct 16 colors. 79 * Secondly, the kernel does get correct 16 colors when some other boot 80 * loader is used. However, the palette map for 8-bit colors is using 81 * console color ordering - this does allow us to skip translation 82 * from VGA colors to console colors, while we are reading RGB data. 83 */ 84 85 #include <sys/param.h> 86 #include <stand.h> 87 #include <teken.h> 88 #include <gfx_fb.h> 89 #include <sys/font.h> 90 #include <sys/linker.h> 91 #include <sys/module.h> 92 #include <sys/stdint.h> 93 #include <sys/endian.h> 94 #include <pnglite.h> 95 #include <bootstrap.h> 96 #include <lz4.h> 97 #if defined(EFI) 98 #include <efi.h> 99 #include <efilib.h> 100 #else 101 #include <vbe.h> 102 #endif 103 104 /* VGA text mode does use bold font. */ 105 #if !defined(VGA_8X16_FONT) 106 #define VGA_8X16_FONT "/boot/fonts/8x16b.fnt" 107 #endif 108 #if !defined(DEFAULT_8X16_FONT) 109 #define DEFAULT_8X16_FONT "/boot/fonts/8x16.fnt" 110 #endif 111 112 /* 113 * Must be sorted by font size in descending order 114 */ 115 font_list_t fonts = STAILQ_HEAD_INITIALIZER(fonts); 116 117 #define DEFAULT_FONT_DATA font_data_8x16 118 extern vt_font_bitmap_data_t font_data_8x16; 119 teken_gfx_t gfx_state = { 0 }; 120 121 static struct { 122 unsigned char r; /* Red percentage value. */ 123 unsigned char g; /* Green percentage value. */ 124 unsigned char b; /* Blue percentage value. */ 125 } color_def[NCOLORS] = { 126 {0, 0, 0}, /* black */ 127 {50, 0, 0}, /* dark red */ 128 {0, 50, 0}, /* dark green */ 129 {77, 63, 0}, /* dark yellow */ 130 {20, 40, 64}, /* dark blue */ 131 {50, 0, 50}, /* dark magenta */ 132 {0, 50, 50}, /* dark cyan */ 133 {75, 75, 75}, /* light gray */ 134 135 {18, 20, 21}, /* dark gray */ 136 {100, 0, 0}, /* light red */ 137 {0, 100, 0}, /* light green */ 138 {100, 100, 0}, /* light yellow */ 139 {45, 62, 81}, /* light blue */ 140 {100, 0, 100}, /* light magenta */ 141 {0, 100, 100}, /* light cyan */ 142 {100, 100, 100}, /* white */ 143 }; 144 uint32_t cmap[NCMAP]; 145 146 /* 147 * Between console's palette and VGA's one: 148 * - blue and red are swapped (1 <-> 4) 149 * - yellow and cyan are swapped (3 <-> 6) 150 */ 151 const int cons_to_vga_colors[NCOLORS] = { 152 0, 4, 2, 6, 1, 5, 3, 7, 153 8, 12, 10, 14, 9, 13, 11, 15 154 }; 155 156 static const int vga_to_cons_colors[NCOLORS] = { 157 0, 1, 2, 3, 4, 5, 6, 7, 158 8, 9, 10, 11, 12, 13, 14, 15 159 }; 160 161 struct text_pixel *screen_buffer; 162 #if defined(EFI) 163 static EFI_GRAPHICS_OUTPUT_BLT_PIXEL *GlyphBuffer; 164 #else 165 static struct paletteentry *GlyphBuffer; 166 #endif 167 static size_t GlyphBufferSize; 168 169 static bool insert_font(char *, FONT_FLAGS); 170 static int font_set(struct env_var *, int, const void *); 171 static void * allocate_glyphbuffer(uint32_t, uint32_t); 172 static void gfx_fb_cursor_draw(teken_gfx_t *, const teken_pos_t *, bool); 173 174 /* 175 * Initialize gfx framework. 176 */ 177 void 178 gfx_framework_init(void) 179 { 180 /* 181 * Setup font list to have builtin font. 182 */ 183 (void) insert_font(NULL, FONT_BUILTIN); 184 gfx_interp_ref(); /* Draw in the gfx interpreter for this thing */ 185 } 186 187 static uint8_t * 188 gfx_get_fb_address(void) 189 { 190 return (ptov((uint32_t)gfx_state.tg_fb.fb_addr)); 191 } 192 193 /* 194 * Utility function to parse gfx mode line strings. 195 */ 196 bool 197 gfx_parse_mode_str(char *str, int *x, int *y, int *depth) 198 { 199 char *p, *end; 200 201 errno = 0; 202 p = str; 203 *x = strtoul(p, &end, 0); 204 if (*x == 0 || errno != 0) 205 return (false); 206 if (*end != 'x') 207 return (false); 208 p = end + 1; 209 *y = strtoul(p, &end, 0); 210 if (*y == 0 || errno != 0) 211 return (false); 212 if (*end != 'x') { 213 *depth = -1; /* auto select */ 214 } else { 215 p = end + 1; 216 *depth = strtoul(p, &end, 0); 217 if (*depth == 0 || errno != 0 || *end != '\0') 218 return (false); 219 } 220 221 return (true); 222 } 223 224 static uint32_t 225 rgb_color_map(uint8_t index, uint32_t rmax, int roffset, 226 uint32_t gmax, int goffset, uint32_t bmax, int boffset) 227 { 228 uint32_t color, code, gray, level; 229 230 if (index < NCOLORS) { 231 #define CF(_f, _i) ((_f ## max * color_def[(_i)]._f / 100) << _f ## offset) 232 return (CF(r, index) | CF(g, index) | CF(b, index)); 233 #undef CF 234 } 235 236 #define CF(_f, _c) ((_f ## max & _c) << _f ## offset) 237 /* 6x6x6 color cube */ 238 if (index > 15 && index < 232) { 239 uint32_t red, green, blue; 240 241 for (red = 0; red < 6; red++) { 242 for (green = 0; green < 6; green++) { 243 for (blue = 0; blue < 6; blue++) { 244 code = 16 + (red * 36) + 245 (green * 6) + blue; 246 if (code != index) 247 continue; 248 red = red ? (red * 40 + 55) : 0; 249 green = green ? (green * 40 + 55) : 0; 250 blue = blue ? (blue * 40 + 55) : 0; 251 color = CF(r, red); 252 color |= CF(g, green); 253 color |= CF(b, blue); 254 return (color); 255 } 256 } 257 } 258 } 259 260 /* colors 232-255 are a grayscale ramp */ 261 for (gray = 0; gray < 24; gray++) { 262 level = (gray * 10) + 8; 263 code = 232 + gray; 264 if (code == index) 265 break; 266 } 267 return (CF(r, level) | CF(g, level) | CF(b, level)); 268 #undef CF 269 } 270 271 /* 272 * Support for color mapping. 273 * For 8, 24 and 32 bit depth, use mask size 8. 274 * 15/16 bit depth needs to use mask size from mode, 275 * or we will lose color information from 32-bit to 15/16 bit translation. 276 */ 277 uint32_t 278 gfx_fb_color_map(uint8_t index) 279 { 280 int rmask, gmask, bmask; 281 int roff, goff, boff, bpp; 282 283 roff = ffs(gfx_state.tg_fb.fb_mask_red) - 1; 284 goff = ffs(gfx_state.tg_fb.fb_mask_green) - 1; 285 boff = ffs(gfx_state.tg_fb.fb_mask_blue) - 1; 286 bpp = roundup2(gfx_state.tg_fb.fb_bpp, 8) >> 3; 287 288 if (bpp == 2) 289 rmask = gfx_state.tg_fb.fb_mask_red >> roff; 290 else 291 rmask = 0xff; 292 293 if (bpp == 2) 294 gmask = gfx_state.tg_fb.fb_mask_green >> goff; 295 else 296 gmask = 0xff; 297 298 if (bpp == 2) 299 bmask = gfx_state.tg_fb.fb_mask_blue >> boff; 300 else 301 bmask = 0xff; 302 303 return (rgb_color_map(index, rmask, 16, gmask, 8, bmask, 0)); 304 } 305 306 /* 307 * Get indexed color from RGB. This function is used to write data to video 308 * memory when the adapter is set to use indexed colors. 309 * Since UEFI does only support 32-bit colors, we do not implement it for 310 * UEFI because there is no need for it and we do not have palette array 311 * for UEFI. 312 */ 313 static uint8_t 314 rgb_to_color_index(uint8_t r, uint8_t g, uint8_t b) 315 { 316 #if !defined(EFI) 317 uint32_t color, best, dist, k; 318 int diff; 319 320 color = 0; 321 best = 255 * 255 * 255; 322 for (k = 0; k < NCMAP; k++) { 323 diff = r - pe8[k].Red; 324 dist = diff * diff; 325 diff = g - pe8[k].Green; 326 dist += diff * diff; 327 diff = b - pe8[k].Blue; 328 dist += diff * diff; 329 330 /* Exact match, exit the loop */ 331 if (dist == 0) 332 break; 333 334 if (dist < best) { 335 color = k; 336 best = dist; 337 } 338 } 339 if (k == NCMAP) 340 k = color; 341 return (k); 342 #else 343 (void) r; 344 (void) g; 345 (void) b; 346 return (0); 347 #endif 348 } 349 350 int 351 generate_cons_palette(uint32_t *palette, int format, 352 uint32_t rmax, int roffset, uint32_t gmax, int goffset, 353 uint32_t bmax, int boffset) 354 { 355 int i; 356 357 switch (format) { 358 case COLOR_FORMAT_VGA: 359 for (i = 0; i < NCOLORS; i++) 360 palette[i] = cons_to_vga_colors[i]; 361 for (; i < NCMAP; i++) 362 palette[i] = i; 363 break; 364 case COLOR_FORMAT_RGB: 365 for (i = 0; i < NCMAP; i++) 366 palette[i] = rgb_color_map(i, rmax, roffset, 367 gmax, goffset, bmax, boffset); 368 break; 369 default: 370 return (ENODEV); 371 } 372 373 return (0); 374 } 375 376 static void 377 gfx_mem_wr1(uint8_t *base, size_t size, uint32_t o, uint8_t v) 378 { 379 380 if (o >= size) 381 return; 382 *(uint8_t *)(base + o) = v; 383 } 384 385 static void 386 gfx_mem_wr2(uint8_t *base, size_t size, uint32_t o, uint16_t v) 387 { 388 389 if (o >= size) 390 return; 391 *(uint16_t *)(base + o) = v; 392 } 393 394 static void 395 gfx_mem_wr4(uint8_t *base, size_t size, uint32_t o, uint32_t v) 396 { 397 398 if (o >= size) 399 return; 400 *(uint32_t *)(base + o) = v; 401 } 402 403 static int gfxfb_blt_fill(void *BltBuffer, 404 uint32_t DestinationX, uint32_t DestinationY, 405 uint32_t Width, uint32_t Height) 406 { 407 #if defined(EFI) 408 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *p; 409 #else 410 struct paletteentry *p; 411 #endif 412 uint32_t data, bpp, pitch, y, x; 413 int roff, goff, boff; 414 size_t size; 415 off_t off; 416 uint8_t *destination; 417 418 if (BltBuffer == NULL) 419 return (EINVAL); 420 421 if (DestinationY + Height > gfx_state.tg_fb.fb_height) 422 return (EINVAL); 423 424 if (DestinationX + Width > gfx_state.tg_fb.fb_width) 425 return (EINVAL); 426 427 if (Width == 0 || Height == 0) 428 return (EINVAL); 429 430 p = BltBuffer; 431 roff = ffs(gfx_state.tg_fb.fb_mask_red) - 1; 432 goff = ffs(gfx_state.tg_fb.fb_mask_green) - 1; 433 boff = ffs(gfx_state.tg_fb.fb_mask_blue) - 1; 434 435 if (gfx_state.tg_fb.fb_bpp == 8) { 436 data = rgb_to_color_index(p->Red, p->Green, p->Blue); 437 } else { 438 data = (p->Red & 439 (gfx_state.tg_fb.fb_mask_red >> roff)) << roff; 440 data |= (p->Green & 441 (gfx_state.tg_fb.fb_mask_green >> goff)) << goff; 442 data |= (p->Blue & 443 (gfx_state.tg_fb.fb_mask_blue >> boff)) << boff; 444 } 445 446 bpp = roundup2(gfx_state.tg_fb.fb_bpp, 8) >> 3; 447 pitch = gfx_state.tg_fb.fb_stride * bpp; 448 destination = gfx_get_fb_address(); 449 size = gfx_state.tg_fb.fb_size; 450 451 for (y = DestinationY; y < Height + DestinationY; y++) { 452 off = y * pitch + DestinationX * bpp; 453 for (x = 0; x < Width; x++) { 454 switch (bpp) { 455 case 1: 456 gfx_mem_wr1(destination, size, off, 457 (data < NCOLORS) ? 458 cons_to_vga_colors[data] : data); 459 break; 460 case 2: 461 gfx_mem_wr2(destination, size, off, data); 462 break; 463 case 3: 464 gfx_mem_wr1(destination, size, off, 465 (data >> 16) & 0xff); 466 gfx_mem_wr1(destination, size, off + 1, 467 (data >> 8) & 0xff); 468 gfx_mem_wr1(destination, size, off + 2, 469 data & 0xff); 470 break; 471 case 4: 472 gfx_mem_wr4(destination, size, off, data); 473 break; 474 default: 475 return (EINVAL); 476 } 477 off += bpp; 478 } 479 } 480 481 return (0); 482 } 483 484 static int 485 gfxfb_blt_video_to_buffer(void *BltBuffer, uint32_t SourceX, uint32_t SourceY, 486 uint32_t DestinationX, uint32_t DestinationY, 487 uint32_t Width, uint32_t Height, uint32_t Delta) 488 { 489 #if defined(EFI) 490 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *p; 491 #else 492 struct paletteentry *p; 493 #endif 494 uint32_t x, sy, dy; 495 uint32_t bpp, pitch, copybytes; 496 off_t off; 497 uint8_t *source, *destination, *sb; 498 uint8_t rm, rp, gm, gp, bm, bp; 499 bool bgra; 500 501 if (BltBuffer == NULL) 502 return (EINVAL); 503 504 if (SourceY + Height > 505 gfx_state.tg_fb.fb_height) 506 return (EINVAL); 507 508 if (SourceX + Width > gfx_state.tg_fb.fb_width) 509 return (EINVAL); 510 511 if (Width == 0 || Height == 0) 512 return (EINVAL); 513 514 if (Delta == 0) 515 Delta = Width * sizeof (*p); 516 517 bpp = roundup2(gfx_state.tg_fb.fb_bpp, 8) >> 3; 518 pitch = gfx_state.tg_fb.fb_stride * bpp; 519 520 copybytes = Width * bpp; 521 522 rp = ffs(gfx_state.tg_fb.fb_mask_red) - 1; 523 gp = ffs(gfx_state.tg_fb.fb_mask_green) - 1; 524 bp = ffs(gfx_state.tg_fb.fb_mask_blue) - 1; 525 rm = gfx_state.tg_fb.fb_mask_red >> rp; 526 gm = gfx_state.tg_fb.fb_mask_green >> gp; 527 bm = gfx_state.tg_fb.fb_mask_blue >> bp; 528 529 /* If FB pixel format is BGRA, we can use direct copy. */ 530 bgra = bpp == 4 && 531 ffs(rm) - 1 == 8 && rp == 16 && 532 ffs(gm) - 1 == 8 && gp == 8 && 533 ffs(bm) - 1 == 8 && bp == 0; 534 535 for (sy = SourceY, dy = DestinationY; dy < Height + DestinationY; 536 sy++, dy++) { 537 off = sy * pitch + SourceX * bpp; 538 source = gfx_get_fb_address() + off; 539 destination = (uint8_t *)BltBuffer + dy * Delta + 540 DestinationX * sizeof (*p); 541 542 if (bgra) { 543 bcopy(source, destination, copybytes); 544 } else { 545 for (x = 0; x < Width; x++) { 546 uint32_t c = 0; 547 548 p = (void *)(destination + x * sizeof (*p)); 549 sb = source + x * bpp; 550 switch (bpp) { 551 case 1: 552 c = *sb; 553 break; 554 case 2: 555 c = *(uint16_t *)sb; 556 break; 557 case 3: 558 c = sb[0] << 16 | sb[1] << 8 | sb[2]; 559 break; 560 case 4: 561 c = *(uint32_t *)sb; 562 break; 563 default: 564 return (EINVAL); 565 } 566 567 if (bpp == 1) { 568 *(uint32_t *)p = gfx_fb_color_map( 569 (c < 16) ? 570 vga_to_cons_colors[c] : c); 571 } else { 572 p->Red = (c >> rp) & rm; 573 p->Green = (c >> gp) & gm; 574 p->Blue = (c >> bp) & bm; 575 p->Reserved = 0; 576 } 577 } 578 } 579 } 580 581 return (0); 582 } 583 584 static int 585 gfxfb_blt_buffer_to_video(void *BltBuffer, uint32_t SourceX, uint32_t SourceY, 586 uint32_t DestinationX, uint32_t DestinationY, 587 uint32_t Width, uint32_t Height, uint32_t Delta) 588 { 589 #if defined(EFI) 590 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *p; 591 #else 592 struct paletteentry *p; 593 #endif 594 uint32_t x, sy, dy; 595 uint32_t bpp, pitch, copybytes; 596 off_t off; 597 uint8_t *source, *destination; 598 uint8_t rm, rp, gm, gp, bm, bp; 599 bool bgra; 600 601 if (BltBuffer == NULL) 602 return (EINVAL); 603 604 if (DestinationY + Height > 605 gfx_state.tg_fb.fb_height) 606 return (EINVAL); 607 608 if (DestinationX + Width > gfx_state.tg_fb.fb_width) 609 return (EINVAL); 610 611 if (Width == 0 || Height == 0) 612 return (EINVAL); 613 614 if (Delta == 0) 615 Delta = Width * sizeof (*p); 616 617 bpp = roundup2(gfx_state.tg_fb.fb_bpp, 8) >> 3; 618 pitch = gfx_state.tg_fb.fb_stride * bpp; 619 620 copybytes = Width * bpp; 621 622 rp = ffs(gfx_state.tg_fb.fb_mask_red) - 1; 623 gp = ffs(gfx_state.tg_fb.fb_mask_green) - 1; 624 bp = ffs(gfx_state.tg_fb.fb_mask_blue) - 1; 625 rm = gfx_state.tg_fb.fb_mask_red >> rp; 626 gm = gfx_state.tg_fb.fb_mask_green >> gp; 627 bm = gfx_state.tg_fb.fb_mask_blue >> bp; 628 629 /* If FB pixel format is BGRA, we can use direct copy. */ 630 bgra = bpp == 4 && 631 ffs(rm) - 1 == 8 && rp == 16 && 632 ffs(gm) - 1 == 8 && gp == 8 && 633 ffs(bm) - 1 == 8 && bp == 0; 634 635 for (sy = SourceY, dy = DestinationY; sy < Height + SourceY; 636 sy++, dy++) { 637 off = dy * pitch + DestinationX * bpp; 638 destination = gfx_get_fb_address() + off; 639 640 if (bgra) { 641 source = (uint8_t *)BltBuffer + sy * Delta + 642 SourceX * sizeof (*p); 643 bcopy(source, destination, copybytes); 644 } else { 645 for (x = 0; x < Width; x++) { 646 uint32_t c; 647 648 p = (void *)((uint8_t *)BltBuffer + 649 sy * Delta + 650 (SourceX + x) * sizeof (*p)); 651 if (bpp == 1) { 652 c = rgb_to_color_index(p->Red, 653 p->Green, p->Blue); 654 } else { 655 c = (p->Red & rm) << rp | 656 (p->Green & gm) << gp | 657 (p->Blue & bm) << bp; 658 } 659 off = x * bpp; 660 switch (bpp) { 661 case 1: 662 gfx_mem_wr1(destination, copybytes, 663 off, (c < 16) ? 664 cons_to_vga_colors[c] : c); 665 break; 666 case 2: 667 gfx_mem_wr2(destination, copybytes, 668 off, c); 669 break; 670 case 3: 671 gfx_mem_wr1(destination, copybytes, 672 off, (c >> 16) & 0xff); 673 gfx_mem_wr1(destination, copybytes, 674 off + 1, (c >> 8) & 0xff); 675 gfx_mem_wr1(destination, copybytes, 676 off + 2, c & 0xff); 677 break; 678 case 4: 679 gfx_mem_wr4(destination, copybytes, 680 x * bpp, c); 681 break; 682 default: 683 return (EINVAL); 684 } 685 } 686 } 687 } 688 689 return (0); 690 } 691 692 static int 693 gfxfb_blt_video_to_video(uint32_t SourceX, uint32_t SourceY, 694 uint32_t DestinationX, uint32_t DestinationY, 695 uint32_t Width, uint32_t Height) 696 { 697 uint32_t bpp, copybytes; 698 int pitch; 699 uint8_t *source, *destination; 700 off_t off; 701 702 if (SourceY + Height > 703 gfx_state.tg_fb.fb_height) 704 return (EINVAL); 705 706 if (SourceX + Width > gfx_state.tg_fb.fb_width) 707 return (EINVAL); 708 709 if (DestinationY + Height > 710 gfx_state.tg_fb.fb_height) 711 return (EINVAL); 712 713 if (DestinationX + Width > gfx_state.tg_fb.fb_width) 714 return (EINVAL); 715 716 if (Width == 0 || Height == 0) 717 return (EINVAL); 718 719 bpp = roundup2(gfx_state.tg_fb.fb_bpp, 8) >> 3; 720 pitch = gfx_state.tg_fb.fb_stride * bpp; 721 722 copybytes = Width * bpp; 723 724 off = SourceY * pitch + SourceX * bpp; 725 source = gfx_get_fb_address() + off; 726 off = DestinationY * pitch + DestinationX * bpp; 727 destination = gfx_get_fb_address() + off; 728 729 if ((uintptr_t)destination > (uintptr_t)source) { 730 source += Height * pitch; 731 destination += Height * pitch; 732 pitch = -pitch; 733 } 734 735 while (Height-- > 0) { 736 bcopy(source, destination, copybytes); 737 source += pitch; 738 destination += pitch; 739 } 740 741 return (0); 742 } 743 744 static void 745 gfxfb_shadow_fill(uint32_t *BltBuffer, 746 uint32_t DestinationX, uint32_t DestinationY, 747 uint32_t Width, uint32_t Height) 748 { 749 uint32_t fbX, fbY; 750 751 if (gfx_state.tg_shadow_fb == NULL) 752 return; 753 754 fbX = gfx_state.tg_fb.fb_width; 755 fbY = gfx_state.tg_fb.fb_height; 756 757 if (BltBuffer == NULL) 758 return; 759 760 if (DestinationX + Width > fbX) 761 Width = fbX - DestinationX; 762 763 if (DestinationY + Height > fbY) 764 Height = fbY - DestinationY; 765 766 uint32_t y2 = Height + DestinationY; 767 for (uint32_t y1 = DestinationY; y1 < y2; y1++) { 768 uint32_t off = y1 * fbX + DestinationX; 769 770 for (uint32_t x = 0; x < Width; x++) { 771 gfx_state.tg_shadow_fb[off + x] = *BltBuffer; 772 } 773 } 774 } 775 776 int 777 gfxfb_blt(void *BltBuffer, GFXFB_BLT_OPERATION BltOperation, 778 uint32_t SourceX, uint32_t SourceY, 779 uint32_t DestinationX, uint32_t DestinationY, 780 uint32_t Width, uint32_t Height, uint32_t Delta) 781 { 782 int rv; 783 #if defined(EFI) 784 EFI_STATUS status; 785 EFI_GRAPHICS_OUTPUT *gop = gfx_state.tg_private; 786 EFI_TPL tpl; 787 788 /* 789 * We assume Blt() does work, if not, we will need to build exception 790 * list case by case. We only have boot services during part of our 791 * exectution. Once terminate boot services, these operations cannot be 792 * done as they are provided by protocols that disappear when exit 793 * boot services. 794 */ 795 if (gop != NULL && boot_services_active) { 796 tpl = BS->RaiseTPL(TPL_NOTIFY); 797 switch (BltOperation) { 798 case GfxFbBltVideoFill: 799 gfxfb_shadow_fill(BltBuffer, DestinationX, 800 DestinationY, Width, Height); 801 status = gop->Blt(gop, BltBuffer, EfiBltVideoFill, 802 SourceX, SourceY, DestinationX, DestinationY, 803 Width, Height, Delta); 804 break; 805 806 case GfxFbBltVideoToBltBuffer: 807 status = gop->Blt(gop, BltBuffer, 808 EfiBltVideoToBltBuffer, 809 SourceX, SourceY, DestinationX, DestinationY, 810 Width, Height, Delta); 811 break; 812 813 case GfxFbBltBufferToVideo: 814 status = gop->Blt(gop, BltBuffer, EfiBltBufferToVideo, 815 SourceX, SourceY, DestinationX, DestinationY, 816 Width, Height, Delta); 817 break; 818 819 case GfxFbBltVideoToVideo: 820 status = gop->Blt(gop, BltBuffer, EfiBltVideoToVideo, 821 SourceX, SourceY, DestinationX, DestinationY, 822 Width, Height, Delta); 823 break; 824 825 default: 826 status = EFI_INVALID_PARAMETER; 827 break; 828 } 829 830 switch (status) { 831 case EFI_SUCCESS: 832 rv = 0; 833 break; 834 835 case EFI_INVALID_PARAMETER: 836 rv = EINVAL; 837 break; 838 839 case EFI_DEVICE_ERROR: 840 default: 841 rv = EIO; 842 break; 843 } 844 845 BS->RestoreTPL(tpl); 846 return (rv); 847 } 848 #endif 849 850 switch (BltOperation) { 851 case GfxFbBltVideoFill: 852 gfxfb_shadow_fill(BltBuffer, DestinationX, DestinationY, 853 Width, Height); 854 rv = gfxfb_blt_fill(BltBuffer, DestinationX, DestinationY, 855 Width, Height); 856 break; 857 858 case GfxFbBltVideoToBltBuffer: 859 rv = gfxfb_blt_video_to_buffer(BltBuffer, SourceX, SourceY, 860 DestinationX, DestinationY, Width, Height, Delta); 861 break; 862 863 case GfxFbBltBufferToVideo: 864 rv = gfxfb_blt_buffer_to_video(BltBuffer, SourceX, SourceY, 865 DestinationX, DestinationY, Width, Height, Delta); 866 break; 867 868 case GfxFbBltVideoToVideo: 869 rv = gfxfb_blt_video_to_video(SourceX, SourceY, 870 DestinationX, DestinationY, Width, Height); 871 break; 872 873 default: 874 rv = EINVAL; 875 break; 876 } 877 return (rv); 878 } 879 880 void 881 gfx_bitblt_bitmap(teken_gfx_t *state, const uint8_t *glyph, 882 const teken_attr_t *a, uint32_t alpha, bool cursor) 883 { 884 uint32_t width, height; 885 uint32_t fgc, bgc, bpl, cc, o; 886 int bpp, bit, byte; 887 bool invert = false; 888 889 bpp = 4; /* We only generate BGRA */ 890 width = state->tg_font.vf_width; 891 height = state->tg_font.vf_height; 892 bpl = (width + 7) / 8; /* Bytes per source line. */ 893 894 fgc = a->ta_fgcolor; 895 bgc = a->ta_bgcolor; 896 if (a->ta_format & TF_BOLD) 897 fgc |= TC_LIGHT; 898 if (a->ta_format & TF_BLINK) 899 bgc |= TC_LIGHT; 900 901 fgc = gfx_fb_color_map(fgc); 902 bgc = gfx_fb_color_map(bgc); 903 904 if (a->ta_format & TF_REVERSE) 905 invert = !invert; 906 if (cursor) 907 invert = !invert; 908 if (invert) { 909 uint32_t tmp; 910 911 tmp = fgc; 912 fgc = bgc; 913 bgc = tmp; 914 } 915 916 alpha = alpha << 24; 917 fgc |= alpha; 918 bgc |= alpha; 919 920 for (uint32_t y = 0; y < height; y++) { 921 for (uint32_t x = 0; x < width; x++) { 922 byte = y * bpl + x / 8; 923 bit = 0x80 >> (x % 8); 924 o = y * width * bpp + x * bpp; 925 cc = glyph[byte] & bit ? fgc : bgc; 926 927 gfx_mem_wr4(state->tg_glyph, 928 state->tg_glyph_size, o, cc); 929 } 930 } 931 } 932 933 /* 934 * Draw prepared glyph on terminal point p. 935 */ 936 static void 937 gfx_fb_printchar(teken_gfx_t *state, const teken_pos_t *p) 938 { 939 unsigned x, y, width, height; 940 941 width = state->tg_font.vf_width; 942 height = state->tg_font.vf_height; 943 x = state->tg_origin.tp_col + p->tp_col * width; 944 y = state->tg_origin.tp_row + p->tp_row * height; 945 946 gfx_fb_cons_display(x, y, width, height, state->tg_glyph); 947 } 948 949 /* 950 * Store char with its attribute to buffer and put it on screen. 951 */ 952 void 953 gfx_fb_putchar(void *arg, const teken_pos_t *p, teken_char_t c, 954 const teken_attr_t *a) 955 { 956 teken_gfx_t *state = arg; 957 const uint8_t *glyph; 958 int idx; 959 960 idx = p->tp_col + p->tp_row * state->tg_tp.tp_col; 961 if (idx >= state->tg_tp.tp_col * state->tg_tp.tp_row) 962 return; 963 964 /* remove the cursor */ 965 if (state->tg_cursor_visible) 966 gfx_fb_cursor_draw(state, &state->tg_cursor, false); 967 968 screen_buffer[idx].c = c; 969 screen_buffer[idx].a = *a; 970 971 glyph = font_lookup(&state->tg_font, c, a); 972 gfx_bitblt_bitmap(state, glyph, a, 0xff, false); 973 gfx_fb_printchar(state, p); 974 975 /* display the cursor */ 976 if (state->tg_cursor_visible) { 977 const teken_pos_t *c; 978 979 c = teken_get_cursor(&state->tg_teken); 980 gfx_fb_cursor_draw(state, c, true); 981 } 982 } 983 984 void 985 gfx_fb_fill(void *arg, const teken_rect_t *r, teken_char_t c, 986 const teken_attr_t *a) 987 { 988 teken_gfx_t *state = arg; 989 const uint8_t *glyph; 990 teken_pos_t p; 991 struct text_pixel *row; 992 993 /* remove the cursor */ 994 if (state->tg_cursor_visible) 995 gfx_fb_cursor_draw(state, &state->tg_cursor, false); 996 997 glyph = font_lookup(&state->tg_font, c, a); 998 gfx_bitblt_bitmap(state, glyph, a, 0xff, false); 999 1000 for (p.tp_row = r->tr_begin.tp_row; p.tp_row < r->tr_end.tp_row; 1001 p.tp_row++) { 1002 row = &screen_buffer[p.tp_row * state->tg_tp.tp_col]; 1003 for (p.tp_col = r->tr_begin.tp_col; 1004 p.tp_col < r->tr_end.tp_col; p.tp_col++) { 1005 row[p.tp_col].c = c; 1006 row[p.tp_col].a = *a; 1007 gfx_fb_printchar(state, &p); 1008 } 1009 } 1010 1011 /* display the cursor */ 1012 if (state->tg_cursor_visible) { 1013 const teken_pos_t *c; 1014 1015 c = teken_get_cursor(&state->tg_teken); 1016 gfx_fb_cursor_draw(state, c, true); 1017 } 1018 } 1019 1020 static void 1021 gfx_fb_cursor_draw(teken_gfx_t *state, const teken_pos_t *pos, bool on) 1022 { 1023 const uint8_t *glyph; 1024 teken_pos_t p; 1025 int idx; 1026 1027 p = *pos; 1028 if (p.tp_col >= state->tg_tp.tp_col) 1029 p.tp_col = state->tg_tp.tp_col - 1; 1030 if (p.tp_row >= state->tg_tp.tp_row) 1031 p.tp_row = state->tg_tp.tp_row - 1; 1032 idx = p.tp_col + p.tp_row * state->tg_tp.tp_col; 1033 if (idx >= state->tg_tp.tp_col * state->tg_tp.tp_row) 1034 return; 1035 1036 glyph = font_lookup(&state->tg_font, screen_buffer[idx].c, 1037 &screen_buffer[idx].a); 1038 gfx_bitblt_bitmap(state, glyph, &screen_buffer[idx].a, 0xff, on); 1039 gfx_fb_printchar(state, &p); 1040 1041 state->tg_cursor = p; 1042 } 1043 1044 void 1045 gfx_fb_cursor(void *arg, const teken_pos_t *p) 1046 { 1047 teken_gfx_t *state = arg; 1048 1049 /* Switch cursor off in old location and back on in new. */ 1050 if (state->tg_cursor_visible) { 1051 gfx_fb_cursor_draw(state, &state->tg_cursor, false); 1052 gfx_fb_cursor_draw(state, p, true); 1053 } 1054 } 1055 1056 void 1057 gfx_fb_param(void *arg, int cmd, unsigned int value) 1058 { 1059 teken_gfx_t *state = arg; 1060 const teken_pos_t *c; 1061 1062 switch (cmd) { 1063 case TP_SETLOCALCURSOR: 1064 /* 1065 * 0 means normal (usually block), 1 means hidden, and 1066 * 2 means blinking (always block) for compatibility with 1067 * syscons. We don't support any changes except hiding, 1068 * so must map 2 to 0. 1069 */ 1070 value = (value == 1) ? 0 : 1; 1071 /* FALLTHROUGH */ 1072 case TP_SHOWCURSOR: 1073 c = teken_get_cursor(&state->tg_teken); 1074 gfx_fb_cursor_draw(state, c, true); 1075 if (value != 0) 1076 state->tg_cursor_visible = true; 1077 else 1078 state->tg_cursor_visible = false; 1079 break; 1080 default: 1081 /* Not yet implemented */ 1082 break; 1083 } 1084 } 1085 1086 bool 1087 is_same_pixel(struct text_pixel *px1, struct text_pixel *px2) 1088 { 1089 if (px1->c != px2->c) 1090 return (false); 1091 1092 /* Is there image stored? */ 1093 if ((px1->a.ta_format & TF_IMAGE) || 1094 (px2->a.ta_format & TF_IMAGE)) 1095 return (false); 1096 1097 if (px1->a.ta_format != px2->a.ta_format) 1098 return (false); 1099 if (px1->a.ta_fgcolor != px2->a.ta_fgcolor) 1100 return (false); 1101 if (px1->a.ta_bgcolor != px2->a.ta_bgcolor) 1102 return (false); 1103 1104 return (true); 1105 } 1106 1107 static void 1108 gfx_fb_copy_area(teken_gfx_t *state, const teken_rect_t *s, 1109 const teken_pos_t *d) 1110 { 1111 uint32_t sx, sy, dx, dy, width, height; 1112 uint32_t pitch, bytes; 1113 int step; 1114 1115 width = state->tg_font.vf_width; 1116 height = state->tg_font.vf_height; 1117 1118 sx = s->tr_begin.tp_col * width; 1119 sy = s->tr_begin.tp_row * height; 1120 dx = d->tp_col * width; 1121 dy = d->tp_row * height; 1122 1123 width *= (s->tr_end.tp_col - s->tr_begin.tp_col + 1); 1124 1125 /* 1126 * With no shadow fb, use video to video copy. 1127 */ 1128 if (state->tg_shadow_fb == NULL) { 1129 (void) gfxfb_blt(NULL, GfxFbBltVideoToVideo, 1130 sx + state->tg_origin.tp_col, 1131 sy + state->tg_origin.tp_row, 1132 dx + state->tg_origin.tp_col, 1133 dy + state->tg_origin.tp_row, 1134 width, height, 0); 1135 return; 1136 } 1137 1138 /* 1139 * With shadow fb, we need to copy data on both shadow and video, 1140 * to preserve the consistency. We only read data from shadow fb. 1141 */ 1142 1143 step = 1; 1144 pitch = state->tg_fb.fb_width; 1145 bytes = width * sizeof (*state->tg_shadow_fb); 1146 1147 /* 1148 * To handle overlapping areas, set up reverse copy here. 1149 */ 1150 if (dy * pitch + dx > sy * pitch + sx) { 1151 sy += height; 1152 dy += height; 1153 step = -step; 1154 } 1155 1156 while (height-- > 0) { 1157 uint32_t *source = &state->tg_shadow_fb[sy * pitch + sx]; 1158 uint32_t *destination = &state->tg_shadow_fb[dy * pitch + dx]; 1159 1160 bcopy(source, destination, bytes); 1161 (void) gfxfb_blt(destination, GfxFbBltBufferToVideo, 1162 0, 0, dx + state->tg_origin.tp_col, 1163 dy + state->tg_origin.tp_row, width, 1, 0); 1164 1165 sy += step; 1166 dy += step; 1167 } 1168 } 1169 1170 static void 1171 gfx_fb_copy_line(teken_gfx_t *state, int ncol, teken_pos_t *s, teken_pos_t *d) 1172 { 1173 teken_rect_t sr; 1174 teken_pos_t dp; 1175 unsigned soffset, doffset; 1176 bool mark = false; 1177 int x; 1178 1179 soffset = s->tp_col + s->tp_row * state->tg_tp.tp_col; 1180 doffset = d->tp_col + d->tp_row * state->tg_tp.tp_col; 1181 1182 for (x = 0; x < ncol; x++) { 1183 if (is_same_pixel(&screen_buffer[soffset + x], 1184 &screen_buffer[doffset + x])) { 1185 if (mark) { 1186 gfx_fb_copy_area(state, &sr, &dp); 1187 mark = false; 1188 } 1189 } else { 1190 screen_buffer[doffset + x] = screen_buffer[soffset + x]; 1191 if (mark) { 1192 /* update end point */ 1193 sr.tr_end.tp_col = s->tp_col + x; 1194 } else { 1195 /* set up new rectangle */ 1196 mark = true; 1197 sr.tr_begin.tp_col = s->tp_col + x; 1198 sr.tr_begin.tp_row = s->tp_row; 1199 sr.tr_end.tp_col = s->tp_col + x; 1200 sr.tr_end.tp_row = s->tp_row; 1201 dp.tp_col = d->tp_col + x; 1202 dp.tp_row = d->tp_row; 1203 } 1204 } 1205 } 1206 if (mark) { 1207 gfx_fb_copy_area(state, &sr, &dp); 1208 } 1209 } 1210 1211 void 1212 gfx_fb_copy(void *arg, const teken_rect_t *r, const teken_pos_t *p) 1213 { 1214 teken_gfx_t *state = arg; 1215 unsigned doffset, soffset; 1216 teken_pos_t d, s; 1217 int nrow, ncol, y; /* Has to be signed - >= 0 comparison */ 1218 1219 /* 1220 * Copying is a little tricky. We must make sure we do it in 1221 * correct order, to make sure we don't overwrite our own data. 1222 */ 1223 1224 nrow = r->tr_end.tp_row - r->tr_begin.tp_row; 1225 ncol = r->tr_end.tp_col - r->tr_begin.tp_col; 1226 1227 if (p->tp_row + nrow > state->tg_tp.tp_row || 1228 p->tp_col + ncol > state->tg_tp.tp_col) 1229 return; 1230 1231 soffset = r->tr_begin.tp_col + r->tr_begin.tp_row * state->tg_tp.tp_col; 1232 doffset = p->tp_col + p->tp_row * state->tg_tp.tp_col; 1233 1234 /* remove the cursor */ 1235 if (state->tg_cursor_visible) 1236 gfx_fb_cursor_draw(state, &state->tg_cursor, false); 1237 1238 /* 1239 * Copy line by line. 1240 */ 1241 if (doffset <= soffset) { 1242 s = r->tr_begin; 1243 d = *p; 1244 for (y = 0; y < nrow; y++) { 1245 s.tp_row = r->tr_begin.tp_row + y; 1246 d.tp_row = p->tp_row + y; 1247 1248 gfx_fb_copy_line(state, ncol, &s, &d); 1249 } 1250 } else { 1251 for (y = nrow - 1; y >= 0; y--) { 1252 s.tp_row = r->tr_begin.tp_row + y; 1253 d.tp_row = p->tp_row + y; 1254 1255 gfx_fb_copy_line(state, ncol, &s, &d); 1256 } 1257 } 1258 1259 /* display the cursor */ 1260 if (state->tg_cursor_visible) { 1261 const teken_pos_t *c; 1262 1263 c = teken_get_cursor(&state->tg_teken); 1264 gfx_fb_cursor_draw(state, c, true); 1265 } 1266 } 1267 1268 /* 1269 * Implements alpha blending for RGBA data, could use pixels for arguments, 1270 * but byte stream seems more generic. 1271 * The generic alpha blending is: 1272 * blend = alpha * fg + (1.0 - alpha) * bg. 1273 * Since our alpha is not from range [0..1], we scale appropriately. 1274 */ 1275 static uint8_t 1276 alpha_blend(uint8_t fg, uint8_t bg, uint8_t alpha) 1277 { 1278 uint16_t blend, h, l; 1279 1280 /* trivial corner cases */ 1281 if (alpha == 0) 1282 return (bg); 1283 if (alpha == 0xFF) 1284 return (fg); 1285 blend = (alpha * fg + (0xFF - alpha) * bg); 1286 /* Division by 0xFF */ 1287 h = blend >> 8; 1288 l = blend & 0xFF; 1289 if (h + l >= 0xFF) 1290 h++; 1291 return (h); 1292 } 1293 1294 /* 1295 * Implements alpha blending for RGBA data, could use pixels for arguments, 1296 * but byte stream seems more generic. 1297 * The generic alpha blending is: 1298 * blend = alpha * fg + (1.0 - alpha) * bg. 1299 * Since our alpha is not from range [0..1], we scale appropriately. 1300 */ 1301 static void 1302 bitmap_cpy(void *dst, void *src, uint32_t size) 1303 { 1304 #if defined(EFI) 1305 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *ps, *pd; 1306 #else 1307 struct paletteentry *ps, *pd; 1308 #endif 1309 uint32_t i; 1310 uint8_t a; 1311 1312 ps = src; 1313 pd = dst; 1314 1315 /* 1316 * we only implement alpha blending for depth 32. 1317 */ 1318 for (i = 0; i < size; i ++) { 1319 a = ps[i].Reserved; 1320 pd[i].Red = alpha_blend(ps[i].Red, pd[i].Red, a); 1321 pd[i].Green = alpha_blend(ps[i].Green, pd[i].Green, a); 1322 pd[i].Blue = alpha_blend(ps[i].Blue, pd[i].Blue, a); 1323 pd[i].Reserved = a; 1324 } 1325 } 1326 1327 static void * 1328 allocate_glyphbuffer(uint32_t width, uint32_t height) 1329 { 1330 size_t size; 1331 1332 size = sizeof (*GlyphBuffer) * width * height; 1333 if (size != GlyphBufferSize) { 1334 free(GlyphBuffer); 1335 GlyphBuffer = malloc(size); 1336 if (GlyphBuffer == NULL) 1337 return (NULL); 1338 GlyphBufferSize = size; 1339 } 1340 return (GlyphBuffer); 1341 } 1342 1343 void 1344 gfx_fb_cons_display(uint32_t x, uint32_t y, uint32_t width, uint32_t height, 1345 void *data) 1346 { 1347 #if defined(EFI) 1348 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *buf, *p; 1349 #else 1350 struct paletteentry *buf, *p; 1351 #endif 1352 size_t size; 1353 1354 /* 1355 * If we do have shadow fb, we will use shadow to render data, 1356 * and copy shadow to video. 1357 */ 1358 if (gfx_state.tg_shadow_fb != NULL) { 1359 uint32_t pitch = gfx_state.tg_fb.fb_width; 1360 1361 /* Copy rectangle line by line. */ 1362 p = data; 1363 for (uint32_t sy = 0; sy < height; sy++) { 1364 buf = (void *)(gfx_state.tg_shadow_fb + 1365 (y - gfx_state.tg_origin.tp_row) * pitch + 1366 x - gfx_state.tg_origin.tp_col); 1367 bitmap_cpy(buf, &p[sy * width], width); 1368 (void) gfxfb_blt(buf, GfxFbBltBufferToVideo, 1369 0, 0, x, y, width, 1, 0); 1370 y++; 1371 } 1372 return; 1373 } 1374 1375 /* 1376 * Common data to display is glyph, use preallocated 1377 * glyph buffer. 1378 */ 1379 if (gfx_state.tg_glyph_size != GlyphBufferSize) 1380 (void) allocate_glyphbuffer(width, height); 1381 1382 size = width * height * sizeof(*buf); 1383 if (size == GlyphBufferSize) 1384 buf = GlyphBuffer; 1385 else 1386 buf = malloc(size); 1387 if (buf == NULL) 1388 return; 1389 1390 if (gfxfb_blt(buf, GfxFbBltVideoToBltBuffer, x, y, 0, 0, 1391 width, height, 0) == 0) { 1392 bitmap_cpy(buf, data, width * height); 1393 (void) gfxfb_blt(buf, GfxFbBltBufferToVideo, 0, 0, x, y, 1394 width, height, 0); 1395 } 1396 if (buf != GlyphBuffer) 1397 free(buf); 1398 } 1399 1400 /* 1401 * Public graphics primitives. 1402 */ 1403 1404 static int 1405 isqrt(int num) 1406 { 1407 int res = 0; 1408 int bit = 1 << 30; 1409 1410 /* "bit" starts at the highest power of four <= the argument. */ 1411 while (bit > num) 1412 bit >>= 2; 1413 1414 while (bit != 0) { 1415 if (num >= res + bit) { 1416 num -= res + bit; 1417 res = (res >> 1) + bit; 1418 } else { 1419 res >>= 1; 1420 } 1421 bit >>= 2; 1422 } 1423 return (res); 1424 } 1425 1426 static uint32_t 1427 gfx_fb_getcolor(void) 1428 { 1429 uint32_t c; 1430 const teken_attr_t *ap; 1431 1432 ap = teken_get_curattr(&gfx_state.tg_teken); 1433 if (ap->ta_format & TF_REVERSE) { 1434 c = ap->ta_bgcolor; 1435 if (ap->ta_format & TF_BLINK) 1436 c |= TC_LIGHT; 1437 } else { 1438 c = ap->ta_fgcolor; 1439 if (ap->ta_format & TF_BOLD) 1440 c |= TC_LIGHT; 1441 } 1442 1443 return (gfx_fb_color_map(c)); 1444 } 1445 1446 /* set pixel in framebuffer using gfx coordinates */ 1447 void 1448 gfx_fb_setpixel(uint32_t x, uint32_t y) 1449 { 1450 uint32_t c; 1451 1452 if (gfx_state.tg_fb_type == FB_TEXT) 1453 return; 1454 1455 c = gfx_fb_getcolor(); 1456 1457 if (x >= gfx_state.tg_fb.fb_width || 1458 y >= gfx_state.tg_fb.fb_height) 1459 return; 1460 1461 gfxfb_blt(&c, GfxFbBltVideoFill, 0, 0, x, y, 1, 1, 0); 1462 } 1463 1464 /* 1465 * draw rectangle in framebuffer using gfx coordinates. 1466 */ 1467 void 1468 gfx_fb_drawrect(uint32_t x1, uint32_t y1, uint32_t x2, uint32_t y2, 1469 uint32_t fill) 1470 { 1471 uint32_t c; 1472 1473 if (gfx_state.tg_fb_type == FB_TEXT) 1474 return; 1475 1476 c = gfx_fb_getcolor(); 1477 1478 if (fill != 0) { 1479 gfxfb_blt(&c, GfxFbBltVideoFill, 0, 0, x1, y1, x2 - x1, 1480 y2 - y1, 0); 1481 } else { 1482 gfxfb_blt(&c, GfxFbBltVideoFill, 0, 0, x1, y1, x2 - x1, 1, 0); 1483 gfxfb_blt(&c, GfxFbBltVideoFill, 0, 0, x1, y2, x2 - x1, 1, 0); 1484 gfxfb_blt(&c, GfxFbBltVideoFill, 0, 0, x1, y1, 1, y2 - y1, 0); 1485 gfxfb_blt(&c, GfxFbBltVideoFill, 0, 0, x2, y1, 1, y2 - y1, 0); 1486 } 1487 } 1488 1489 void 1490 gfx_fb_line(uint32_t x0, uint32_t y0, uint32_t x1, uint32_t y1, uint32_t wd) 1491 { 1492 int dx, sx, dy, sy; 1493 int err, e2, x2, y2, ed, width; 1494 1495 if (gfx_state.tg_fb_type == FB_TEXT) 1496 return; 1497 1498 width = wd; 1499 sx = x0 < x1? 1 : -1; 1500 sy = y0 < y1? 1 : -1; 1501 dx = x1 > x0? x1 - x0 : x0 - x1; 1502 dy = y1 > y0? y1 - y0 : y0 - y1; 1503 err = dx + dy; 1504 ed = dx + dy == 0 ? 1: isqrt(dx * dx + dy * dy); 1505 1506 for (;;) { 1507 gfx_fb_setpixel(x0, y0); 1508 e2 = err; 1509 x2 = x0; 1510 if ((e2 << 1) >= -dx) { /* x step */ 1511 e2 += dy; 1512 y2 = y0; 1513 while (e2 < ed * width && 1514 (y1 != (uint32_t)y2 || dx > dy)) { 1515 y2 += sy; 1516 gfx_fb_setpixel(x0, y2); 1517 e2 += dx; 1518 } 1519 if (x0 == x1) 1520 break; 1521 e2 = err; 1522 err -= dy; 1523 x0 += sx; 1524 } 1525 if ((e2 << 1) <= dy) { /* y step */ 1526 e2 = dx-e2; 1527 while (e2 < ed * width && 1528 (x1 != (uint32_t)x2 || dx < dy)) { 1529 x2 += sx; 1530 gfx_fb_setpixel(x2, y0); 1531 e2 += dy; 1532 } 1533 if (y0 == y1) 1534 break; 1535 err += dx; 1536 y0 += sy; 1537 } 1538 } 1539 } 1540 1541 /* 1542 * quadratic Bézier curve limited to gradients without sign change. 1543 */ 1544 void 1545 gfx_fb_bezier(uint32_t x0, uint32_t y0, uint32_t x1, uint32_t y1, uint32_t x2, 1546 uint32_t y2, uint32_t wd) 1547 { 1548 int sx, sy, xx, yy, xy, width; 1549 int dx, dy, err, curvature; 1550 int i; 1551 1552 if (gfx_state.tg_fb_type == FB_TEXT) 1553 return; 1554 1555 width = wd; 1556 sx = x2 - x1; 1557 sy = y2 - y1; 1558 xx = x0 - x1; 1559 yy = y0 - y1; 1560 curvature = xx*sy - yy*sx; 1561 1562 if (sx*sx + sy*sy > xx*xx+yy*yy) { 1563 x2 = x0; 1564 x0 = sx + x1; 1565 y2 = y0; 1566 y0 = sy + y1; 1567 curvature = -curvature; 1568 } 1569 if (curvature != 0) { 1570 xx += sx; 1571 sx = x0 < x2? 1 : -1; 1572 xx *= sx; 1573 yy += sy; 1574 sy = y0 < y2? 1 : -1; 1575 yy *= sy; 1576 xy = (xx*yy) << 1; 1577 xx *= xx; 1578 yy *= yy; 1579 if (curvature * sx * sy < 0) { 1580 xx = -xx; 1581 yy = -yy; 1582 xy = -xy; 1583 curvature = -curvature; 1584 } 1585 dx = 4 * sy * curvature * (x1 - x0) + xx - xy; 1586 dy = 4 * sx * curvature * (y0 - y1) + yy - xy; 1587 xx += xx; 1588 yy += yy; 1589 err = dx + dy + xy; 1590 do { 1591 for (i = 0; i <= width; i++) 1592 gfx_fb_setpixel(x0 + i, y0); 1593 if (x0 == x2 && y0 == y2) 1594 return; /* last pixel -> curve finished */ 1595 y1 = 2 * err < dx; 1596 if (2 * err > dy) { 1597 x0 += sx; 1598 dx -= xy; 1599 dy += yy; 1600 err += dy; 1601 } 1602 if (y1 != 0) { 1603 y0 += sy; 1604 dy -= xy; 1605 dx += xx; 1606 err += dx; 1607 } 1608 } while (dy < dx); /* gradient negates -> algorithm fails */ 1609 } 1610 gfx_fb_line(x0, y0, x2, y2, width); 1611 } 1612 1613 /* 1614 * draw rectangle using terminal coordinates and current foreground color. 1615 */ 1616 void 1617 gfx_term_drawrect(uint32_t ux1, uint32_t uy1, uint32_t ux2, uint32_t uy2) 1618 { 1619 int x1, y1, x2, y2; 1620 int xshift, yshift; 1621 int width, i; 1622 uint32_t vf_width, vf_height; 1623 teken_rect_t r; 1624 1625 if (gfx_state.tg_fb_type == FB_TEXT) 1626 return; 1627 1628 vf_width = gfx_state.tg_font.vf_width; 1629 vf_height = gfx_state.tg_font.vf_height; 1630 width = vf_width / 4; /* line width */ 1631 xshift = (vf_width - width) / 2; 1632 yshift = (vf_height - width) / 2; 1633 1634 /* Shift coordinates */ 1635 if (ux1 != 0) 1636 ux1--; 1637 if (uy1 != 0) 1638 uy1--; 1639 ux2--; 1640 uy2--; 1641 1642 /* mark area used in terminal */ 1643 r.tr_begin.tp_col = ux1; 1644 r.tr_begin.tp_row = uy1; 1645 r.tr_end.tp_col = ux2 + 1; 1646 r.tr_end.tp_row = uy2 + 1; 1647 1648 term_image_display(&gfx_state, &r); 1649 1650 /* 1651 * Draw horizontal lines width points thick, shifted from outer edge. 1652 */ 1653 x1 = (ux1 + 1) * vf_width + gfx_state.tg_origin.tp_col; 1654 y1 = uy1 * vf_height + gfx_state.tg_origin.tp_row + yshift; 1655 x2 = ux2 * vf_width + gfx_state.tg_origin.tp_col; 1656 gfx_fb_drawrect(x1, y1, x2, y1 + width, 1); 1657 y2 = uy2 * vf_height + gfx_state.tg_origin.tp_row; 1658 y2 += vf_height - yshift - width; 1659 gfx_fb_drawrect(x1, y2, x2, y2 + width, 1); 1660 1661 /* 1662 * Draw vertical lines width points thick, shifted from outer edge. 1663 */ 1664 x1 = ux1 * vf_width + gfx_state.tg_origin.tp_col + xshift; 1665 y1 = uy1 * vf_height + gfx_state.tg_origin.tp_row; 1666 y1 += vf_height; 1667 y2 = uy2 * vf_height + gfx_state.tg_origin.tp_row; 1668 gfx_fb_drawrect(x1, y1, x1 + width, y2, 1); 1669 x1 = ux2 * vf_width + gfx_state.tg_origin.tp_col; 1670 x1 += vf_width - xshift - width; 1671 gfx_fb_drawrect(x1, y1, x1 + width, y2, 1); 1672 1673 /* Draw upper left corner. */ 1674 x1 = ux1 * vf_width + gfx_state.tg_origin.tp_col + xshift; 1675 y1 = uy1 * vf_height + gfx_state.tg_origin.tp_row; 1676 y1 += vf_height; 1677 1678 x2 = ux1 * vf_width + gfx_state.tg_origin.tp_col; 1679 x2 += vf_width; 1680 y2 = uy1 * vf_height + gfx_state.tg_origin.tp_row + yshift; 1681 for (i = 0; i <= width; i++) 1682 gfx_fb_bezier(x1 + i, y1, x1 + i, y2 + i, x2, y2 + i, width-i); 1683 1684 /* Draw lower left corner. */ 1685 x1 = ux1 * vf_width + gfx_state.tg_origin.tp_col; 1686 x1 += vf_width; 1687 y1 = uy2 * vf_height + gfx_state.tg_origin.tp_row; 1688 y1 += vf_height - yshift; 1689 x2 = ux1 * vf_width + gfx_state.tg_origin.tp_col + xshift; 1690 y2 = uy2 * vf_height + gfx_state.tg_origin.tp_row; 1691 for (i = 0; i <= width; i++) 1692 gfx_fb_bezier(x1, y1 - i, x2 + i, y1 - i, x2 + i, y2, width-i); 1693 1694 /* Draw upper right corner. */ 1695 x1 = ux2 * vf_width + gfx_state.tg_origin.tp_col; 1696 y1 = uy1 * vf_height + gfx_state.tg_origin.tp_row + yshift; 1697 x2 = ux2 * vf_width + gfx_state.tg_origin.tp_col; 1698 x2 += vf_width - xshift - width; 1699 y2 = uy1 * vf_height + gfx_state.tg_origin.tp_row; 1700 y2 += vf_height; 1701 for (i = 0; i <= width; i++) 1702 gfx_fb_bezier(x1, y1 + i, x2 + i, y1 + i, x2 + i, y2, width-i); 1703 1704 /* Draw lower right corner. */ 1705 x1 = ux2 * vf_width + gfx_state.tg_origin.tp_col; 1706 y1 = uy2 * vf_height + gfx_state.tg_origin.tp_row; 1707 y1 += vf_height - yshift; 1708 x2 = ux2 * vf_width + gfx_state.tg_origin.tp_col; 1709 x2 += vf_width - xshift - width; 1710 y2 = uy2 * vf_height + gfx_state.tg_origin.tp_row; 1711 for (i = 0; i <= width; i++) 1712 gfx_fb_bezier(x1, y1 - i, x2 + i, y1 - i, x2 + i, y2, width-i); 1713 } 1714 1715 int 1716 gfx_fb_putimage(png_t *png, uint32_t ux1, uint32_t uy1, uint32_t ux2, 1717 uint32_t uy2, uint32_t flags) 1718 { 1719 #if defined(EFI) 1720 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *p; 1721 #else 1722 struct paletteentry *p; 1723 #endif 1724 uint8_t *data; 1725 uint32_t i, j, x, y, fheight, fwidth; 1726 int rs, gs, bs; 1727 uint8_t r, g, b, a; 1728 bool scale = false; 1729 bool trace = false; 1730 teken_rect_t rect; 1731 1732 trace = (flags & FL_PUTIMAGE_DEBUG) != 0; 1733 1734 if (gfx_state.tg_fb_type == FB_TEXT) { 1735 if (trace) 1736 printf("Framebuffer not active.\n"); 1737 return (1); 1738 } 1739 1740 if (png->color_type != PNG_TRUECOLOR_ALPHA) { 1741 if (trace) 1742 printf("Not truecolor image.\n"); 1743 return (1); 1744 } 1745 1746 if (ux1 > gfx_state.tg_fb.fb_width || 1747 uy1 > gfx_state.tg_fb.fb_height) { 1748 if (trace) 1749 printf("Top left coordinate off screen.\n"); 1750 return (1); 1751 } 1752 1753 if (png->width > UINT16_MAX || png->height > UINT16_MAX) { 1754 if (trace) 1755 printf("Image too large.\n"); 1756 return (1); 1757 } 1758 1759 if (png->width < 1 || png->height < 1) { 1760 if (trace) 1761 printf("Image too small.\n"); 1762 return (1); 1763 } 1764 1765 /* 1766 * If 0 was passed for either ux2 or uy2, then calculate the missing 1767 * part of the bottom right coordinate. 1768 */ 1769 scale = true; 1770 if (ux2 == 0 && uy2 == 0) { 1771 /* Both 0, use the native resolution of the image */ 1772 ux2 = ux1 + png->width; 1773 uy2 = uy1 + png->height; 1774 scale = false; 1775 } else if (ux2 == 0) { 1776 /* Set ux2 from uy2/uy1 to maintain aspect ratio */ 1777 ux2 = ux1 + (png->width * (uy2 - uy1)) / png->height; 1778 } else if (uy2 == 0) { 1779 /* Set uy2 from ux2/ux1 to maintain aspect ratio */ 1780 uy2 = uy1 + (png->height * (ux2 - ux1)) / png->width; 1781 } 1782 1783 if (ux2 > gfx_state.tg_fb.fb_width || 1784 uy2 > gfx_state.tg_fb.fb_height) { 1785 if (trace) 1786 printf("Bottom right coordinate off screen.\n"); 1787 return (1); 1788 } 1789 1790 fwidth = ux2 - ux1; 1791 fheight = uy2 - uy1; 1792 1793 /* 1794 * If the original image dimensions have been passed explicitly, 1795 * disable scaling. 1796 */ 1797 if (fwidth == png->width && fheight == png->height) 1798 scale = false; 1799 1800 if (ux1 == 0) { 1801 /* 1802 * No top left X co-ordinate (real coordinates start at 1), 1803 * place as far right as it will fit. 1804 */ 1805 ux2 = gfx_state.tg_fb.fb_width - gfx_state.tg_origin.tp_col; 1806 ux1 = ux2 - fwidth; 1807 } 1808 1809 if (uy1 == 0) { 1810 /* 1811 * No top left Y co-ordinate (real coordinates start at 1), 1812 * place as far down as it will fit. 1813 */ 1814 uy2 = gfx_state.tg_fb.fb_height - gfx_state.tg_origin.tp_row; 1815 uy1 = uy2 - fheight; 1816 } 1817 1818 if (ux1 >= ux2 || uy1 >= uy2) { 1819 if (trace) 1820 printf("Image dimensions reversed.\n"); 1821 return (1); 1822 } 1823 1824 if (fwidth < 2 || fheight < 2) { 1825 if (trace) 1826 printf("Target area too small\n"); 1827 return (1); 1828 } 1829 1830 if (trace) 1831 printf("Image %ux%u -> %ux%u @%ux%u\n", 1832 png->width, png->height, fwidth, fheight, ux1, uy1); 1833 1834 rect.tr_begin.tp_col = ux1 / gfx_state.tg_font.vf_width; 1835 rect.tr_begin.tp_row = uy1 / gfx_state.tg_font.vf_height; 1836 rect.tr_end.tp_col = (ux1 + fwidth) / gfx_state.tg_font.vf_width; 1837 rect.tr_end.tp_row = (uy1 + fheight) / gfx_state.tg_font.vf_height; 1838 1839 /* 1840 * mark area used in terminal 1841 */ 1842 if (!(flags & FL_PUTIMAGE_NOSCROLL)) 1843 term_image_display(&gfx_state, &rect); 1844 1845 if ((flags & FL_PUTIMAGE_BORDER)) 1846 gfx_fb_drawrect(ux1, uy1, ux2, uy2, 0); 1847 1848 data = malloc(fwidth * fheight * sizeof(*p)); 1849 p = (void *)data; 1850 if (data == NULL) { 1851 if (trace) 1852 printf("Out of memory.\n"); 1853 return (1); 1854 } 1855 1856 /* 1857 * Build image for our framebuffer. 1858 */ 1859 1860 /* Helper to calculate the pixel index from the source png */ 1861 #define GETPIXEL(xx, yy) (((yy) * png->width + (xx)) * png->bpp) 1862 1863 /* 1864 * For each of the x and y directions, calculate the number of pixels 1865 * in the source image that correspond to a single pixel in the target. 1866 * Use fixed-point arithmetic with 16-bits for each of the integer and 1867 * fractional parts. 1868 */ 1869 const uint32_t wcstep = ((png->width - 1) << 16) / (fwidth - 1); 1870 const uint32_t hcstep = ((png->height - 1) << 16) / (fheight - 1); 1871 1872 rs = 8 - (fls(gfx_state.tg_fb.fb_mask_red) - 1873 ffs(gfx_state.tg_fb.fb_mask_red) + 1); 1874 gs = 8 - (fls(gfx_state.tg_fb.fb_mask_green) - 1875 ffs(gfx_state.tg_fb.fb_mask_green) + 1); 1876 bs = 8 - (fls(gfx_state.tg_fb.fb_mask_blue) - 1877 ffs(gfx_state.tg_fb.fb_mask_blue) + 1); 1878 1879 uint32_t hc = 0; 1880 for (y = 0; y < fheight; y++) { 1881 uint32_t hc2 = (hc >> 9) & 0x7f; 1882 uint32_t hc1 = 0x80 - hc2; 1883 1884 uint32_t offset_y = hc >> 16; 1885 uint32_t offset_y1 = offset_y + 1; 1886 1887 uint32_t wc = 0; 1888 for (x = 0; x < fwidth; x++) { 1889 uint32_t wc2 = (wc >> 9) & 0x7f; 1890 uint32_t wc1 = 0x80 - wc2; 1891 1892 uint32_t offset_x = wc >> 16; 1893 uint32_t offset_x1 = offset_x + 1; 1894 1895 /* Target pixel index */ 1896 j = y * fwidth + x; 1897 1898 if (!scale) { 1899 i = GETPIXEL(x, y); 1900 r = png->image[i]; 1901 g = png->image[i + 1]; 1902 b = png->image[i + 2]; 1903 a = png->image[i + 3]; 1904 } else { 1905 uint8_t pixel[4]; 1906 1907 uint32_t p00 = GETPIXEL(offset_x, offset_y); 1908 uint32_t p01 = GETPIXEL(offset_x, offset_y1); 1909 uint32_t p10 = GETPIXEL(offset_x1, offset_y); 1910 uint32_t p11 = GETPIXEL(offset_x1, offset_y1); 1911 1912 /* 1913 * Given a 2x2 array of pixels in the source 1914 * image, combine them to produce a single 1915 * value for the pixel in the target image. 1916 * Each column of pixels is combined using 1917 * a weighted average where the top and bottom 1918 * pixels contribute hc1 and hc2 respectively. 1919 * The calculation for bottom pixel pB and 1920 * top pixel pT is: 1921 * (pT * hc1 + pB * hc2) / (hc1 + hc2) 1922 * Once the values are determined for the two 1923 * columns of pixels, then the columns are 1924 * averaged together in the same way but using 1925 * wc1 and wc2 for the weightings. 1926 * 1927 * Since hc1 and hc2 are chosen so that 1928 * hc1 + hc2 == 128 (and same for wc1 + wc2), 1929 * the >> 14 below is a quick way to divide by 1930 * (hc1 + hc2) * (wc1 + wc2) 1931 */ 1932 for (i = 0; i < 4; i++) 1933 pixel[i] = ( 1934 (png->image[p00 + i] * hc1 + 1935 png->image[p01 + i] * hc2) * wc1 + 1936 (png->image[p10 + i] * hc1 + 1937 png->image[p11 + i] * hc2) * wc2) 1938 >> 14; 1939 1940 r = pixel[0]; 1941 g = pixel[1]; 1942 b = pixel[2]; 1943 a = pixel[3]; 1944 } 1945 1946 if (trace) 1947 printf("r/g/b: %x/%x/%x\n", r, g, b); 1948 /* 1949 * Rough colorspace reduction for 15/16 bit colors. 1950 */ 1951 p[j].Red = r >> rs; 1952 p[j].Green = g >> gs; 1953 p[j].Blue = b >> bs; 1954 p[j].Reserved = a; 1955 1956 wc += wcstep; 1957 } 1958 hc += hcstep; 1959 } 1960 1961 gfx_fb_cons_display(ux1, uy1, fwidth, fheight, data); 1962 free(data); 1963 return (0); 1964 } 1965 1966 /* 1967 * Reset font flags to FONT_AUTO. 1968 */ 1969 void 1970 reset_font_flags(void) 1971 { 1972 struct fontlist *fl; 1973 1974 STAILQ_FOREACH(fl, &fonts, font_next) { 1975 fl->font_flags = FONT_AUTO; 1976 } 1977 } 1978 1979 /* Return w^2 + h^2 or 0, if the dimensions are unknown */ 1980 static unsigned 1981 edid_diagonal_squared(void) 1982 { 1983 unsigned w, h; 1984 1985 if (edid_info == NULL) 1986 return (0); 1987 1988 w = edid_info->display.max_horizontal_image_size; 1989 h = edid_info->display.max_vertical_image_size; 1990 1991 /* If either one is 0, we have aspect ratio, not size */ 1992 if (w == 0 || h == 0) 1993 return (0); 1994 1995 /* 1996 * some monitors encode the aspect ratio instead of the physical size. 1997 */ 1998 if ((w == 16 && h == 9) || (w == 16 && h == 10) || 1999 (w == 4 && h == 3) || (w == 5 && h == 4)) 2000 return (0); 2001 2002 /* 2003 * translate cm to inch, note we scale by 100 here. 2004 */ 2005 w = w * 100 / 254; 2006 h = h * 100 / 254; 2007 2008 /* Return w^2 + h^2 */ 2009 return (w * w + h * h); 2010 } 2011 2012 /* 2013 * calculate pixels per inch. 2014 */ 2015 static unsigned 2016 gfx_get_ppi(void) 2017 { 2018 unsigned dp, di; 2019 2020 di = edid_diagonal_squared(); 2021 if (di == 0) 2022 return (0); 2023 2024 dp = gfx_state.tg_fb.fb_width * 2025 gfx_state.tg_fb.fb_width + 2026 gfx_state.tg_fb.fb_height * 2027 gfx_state.tg_fb.fb_height; 2028 2029 return (isqrt(dp / di)); 2030 } 2031 2032 /* 2033 * Calculate font size from density independent pixels (dp): 2034 * ((16dp * ppi) / 160) * display_factor. 2035 * Here we are using fixed constants: 1dp == 160 ppi and 2036 * display_factor 2. 2037 * 2038 * We are rounding font size up and are searching for font which is 2039 * not smaller than calculated size value. 2040 */ 2041 static vt_font_bitmap_data_t * 2042 gfx_get_font(void) 2043 { 2044 unsigned ppi, size; 2045 vt_font_bitmap_data_t *font = NULL; 2046 struct fontlist *fl, *next; 2047 2048 /* Text mode is not supported here. */ 2049 if (gfx_state.tg_fb_type == FB_TEXT) 2050 return (NULL); 2051 2052 ppi = gfx_get_ppi(); 2053 if (ppi == 0) 2054 return (NULL); 2055 2056 /* 2057 * We will search for 16dp font. 2058 * We are using scale up by 10 for roundup. 2059 */ 2060 size = (16 * ppi * 10) / 160; 2061 /* Apply display factor 2. */ 2062 size = roundup(size * 2, 10) / 10; 2063 2064 STAILQ_FOREACH(fl, &fonts, font_next) { 2065 next = STAILQ_NEXT(fl, font_next); 2066 2067 /* 2068 * If this is last font or, if next font is smaller, 2069 * we have our font. Make sure, it actually is loaded. 2070 */ 2071 if (next == NULL || next->font_data->vfbd_height < size) { 2072 font = fl->font_data; 2073 if (font->vfbd_font == NULL || 2074 fl->font_flags == FONT_RELOAD) { 2075 if (fl->font_load != NULL && 2076 fl->font_name != NULL) 2077 font = fl->font_load(fl->font_name); 2078 } 2079 break; 2080 } 2081 } 2082 2083 return (font); 2084 } 2085 2086 static vt_font_bitmap_data_t * 2087 set_font(teken_unit_t *rows, teken_unit_t *cols, teken_unit_t h, teken_unit_t w) 2088 { 2089 vt_font_bitmap_data_t *font = NULL; 2090 struct fontlist *fl; 2091 unsigned height = h; 2092 unsigned width = w; 2093 2094 /* 2095 * First check for manually loaded font. 2096 */ 2097 STAILQ_FOREACH(fl, &fonts, font_next) { 2098 if (fl->font_flags == FONT_MANUAL) { 2099 font = fl->font_data; 2100 if (font->vfbd_font == NULL && fl->font_load != NULL && 2101 fl->font_name != NULL) { 2102 font = fl->font_load(fl->font_name); 2103 } 2104 if (font == NULL || font->vfbd_font == NULL) 2105 font = NULL; 2106 break; 2107 } 2108 } 2109 2110 if (font == NULL) 2111 font = gfx_get_font(); 2112 2113 if (font != NULL) { 2114 *rows = height / font->vfbd_height; 2115 *cols = width / font->vfbd_width; 2116 return (font); 2117 } 2118 2119 /* 2120 * Find best font for these dimensions, or use default. 2121 * If height >= VT_FB_MAX_HEIGHT and width >= VT_FB_MAX_WIDTH, 2122 * do not use smaller font than our DEFAULT_FONT_DATA. 2123 */ 2124 STAILQ_FOREACH(fl, &fonts, font_next) { 2125 font = fl->font_data; 2126 if ((*rows * font->vfbd_height <= height && 2127 *cols * font->vfbd_width <= width) || 2128 (height >= VT_FB_MAX_HEIGHT && 2129 width >= VT_FB_MAX_WIDTH && 2130 font->vfbd_height == DEFAULT_FONT_DATA.vfbd_height && 2131 font->vfbd_width == DEFAULT_FONT_DATA.vfbd_width)) { 2132 if (font->vfbd_font == NULL || 2133 fl->font_flags == FONT_RELOAD) { 2134 if (fl->font_load != NULL && 2135 fl->font_name != NULL) { 2136 font = fl->font_load(fl->font_name); 2137 } 2138 if (font == NULL) 2139 continue; 2140 } 2141 *rows = height / font->vfbd_height; 2142 *cols = width / font->vfbd_width; 2143 break; 2144 } 2145 font = NULL; 2146 } 2147 2148 if (font == NULL) { 2149 /* 2150 * We have fonts sorted smallest last, try it before 2151 * falling back to builtin. 2152 */ 2153 fl = STAILQ_LAST(&fonts, fontlist, font_next); 2154 if (fl != NULL && fl->font_load != NULL && 2155 fl->font_name != NULL) { 2156 font = fl->font_load(fl->font_name); 2157 } 2158 if (font == NULL) 2159 font = &DEFAULT_FONT_DATA; 2160 2161 *rows = height / font->vfbd_height; 2162 *cols = width / font->vfbd_width; 2163 } 2164 2165 return (font); 2166 } 2167 2168 static void 2169 cons_clear(void) 2170 { 2171 char clear[] = { '\033', 'c' }; 2172 2173 /* Reset terminal */ 2174 teken_input(&gfx_state.tg_teken, clear, sizeof(clear)); 2175 gfx_state.tg_functions->tf_param(&gfx_state, TP_SHOWCURSOR, 0); 2176 } 2177 2178 void 2179 setup_font(teken_gfx_t *state, teken_unit_t height, teken_unit_t width) 2180 { 2181 vt_font_bitmap_data_t *font_data; 2182 teken_pos_t *tp = &state->tg_tp; 2183 char env[8]; 2184 int i; 2185 2186 /* 2187 * set_font() will select a appropriate sized font for 2188 * the number of rows and columns selected. If we don't 2189 * have a font that will fit, then it will use the 2190 * default builtin font and adjust the rows and columns 2191 * to fit on the screen. 2192 */ 2193 font_data = set_font(&tp->tp_row, &tp->tp_col, height, width); 2194 2195 if (font_data == NULL) 2196 panic("out of memory"); 2197 2198 for (i = 0; i < VFNT_MAPS; i++) { 2199 state->tg_font.vf_map[i] = 2200 font_data->vfbd_font->vf_map[i]; 2201 state->tg_font.vf_map_count[i] = 2202 font_data->vfbd_font->vf_map_count[i]; 2203 } 2204 2205 state->tg_font.vf_bytes = font_data->vfbd_font->vf_bytes; 2206 state->tg_font.vf_height = font_data->vfbd_font->vf_height; 2207 state->tg_font.vf_width = font_data->vfbd_font->vf_width; 2208 2209 snprintf(env, sizeof (env), "%ux%u", 2210 state->tg_font.vf_width, state->tg_font.vf_height); 2211 env_setenv("screen.font", EV_VOLATILE | EV_NOHOOK, 2212 env, font_set, env_nounset); 2213 } 2214 2215 /* Binary search for the glyph. Return 0 if not found. */ 2216 static uint16_t 2217 font_bisearch(const vfnt_map_t *map, uint32_t len, teken_char_t src) 2218 { 2219 unsigned min, mid, max; 2220 2221 min = 0; 2222 max = len - 1; 2223 2224 /* Empty font map. */ 2225 if (len == 0) 2226 return (0); 2227 /* Character below minimal entry. */ 2228 if (src < map[0].vfm_src) 2229 return (0); 2230 /* Optimization: ASCII characters occur very often. */ 2231 if (src <= map[0].vfm_src + map[0].vfm_len) 2232 return (src - map[0].vfm_src + map[0].vfm_dst); 2233 /* Character above maximum entry. */ 2234 if (src > map[max].vfm_src + map[max].vfm_len) 2235 return (0); 2236 2237 /* Binary search. */ 2238 while (max >= min) { 2239 mid = (min + max) / 2; 2240 if (src < map[mid].vfm_src) 2241 max = mid - 1; 2242 else if (src > map[mid].vfm_src + map[mid].vfm_len) 2243 min = mid + 1; 2244 else 2245 return (src - map[mid].vfm_src + map[mid].vfm_dst); 2246 } 2247 2248 return (0); 2249 } 2250 2251 /* 2252 * Return glyph bitmap. If glyph is not found, we will return bitmap 2253 * for the first (offset 0) glyph. 2254 */ 2255 uint8_t * 2256 font_lookup(const struct vt_font *vf, teken_char_t c, const teken_attr_t *a) 2257 { 2258 uint16_t dst; 2259 size_t stride; 2260 2261 /* Substitute bold with normal if not found. */ 2262 if (a->ta_format & TF_BOLD) { 2263 dst = font_bisearch(vf->vf_map[VFNT_MAP_BOLD], 2264 vf->vf_map_count[VFNT_MAP_BOLD], c); 2265 if (dst != 0) 2266 goto found; 2267 } 2268 dst = font_bisearch(vf->vf_map[VFNT_MAP_NORMAL], 2269 vf->vf_map_count[VFNT_MAP_NORMAL], c); 2270 2271 found: 2272 stride = howmany(vf->vf_width, 8) * vf->vf_height; 2273 return (&vf->vf_bytes[dst * stride]); 2274 } 2275 2276 static int 2277 load_mapping(int fd, struct vt_font *fp, int n) 2278 { 2279 size_t i, size; 2280 ssize_t rv; 2281 vfnt_map_t *mp; 2282 2283 if (fp->vf_map_count[n] == 0) 2284 return (0); 2285 2286 size = fp->vf_map_count[n] * sizeof(*mp); 2287 mp = malloc(size); 2288 if (mp == NULL) 2289 return (ENOMEM); 2290 fp->vf_map[n] = mp; 2291 2292 rv = read(fd, mp, size); 2293 if (rv < 0 || (size_t)rv != size) { 2294 free(fp->vf_map[n]); 2295 fp->vf_map[n] = NULL; 2296 return (EIO); 2297 } 2298 2299 for (i = 0; i < fp->vf_map_count[n]; i++) { 2300 mp[i].vfm_src = be32toh(mp[i].vfm_src); 2301 mp[i].vfm_dst = be16toh(mp[i].vfm_dst); 2302 mp[i].vfm_len = be16toh(mp[i].vfm_len); 2303 } 2304 return (0); 2305 } 2306 2307 static int 2308 builtin_mapping(struct vt_font *fp, int n) 2309 { 2310 size_t size; 2311 struct vfnt_map *mp; 2312 2313 if (n >= VFNT_MAPS) 2314 return (EINVAL); 2315 2316 if (fp->vf_map_count[n] == 0) 2317 return (0); 2318 2319 size = fp->vf_map_count[n] * sizeof(*mp); 2320 mp = malloc(size); 2321 if (mp == NULL) 2322 return (ENOMEM); 2323 fp->vf_map[n] = mp; 2324 2325 memcpy(mp, DEFAULT_FONT_DATA.vfbd_font->vf_map[n], size); 2326 return (0); 2327 } 2328 2329 /* 2330 * Load font from builtin or from file. 2331 * We do need special case for builtin because the builtin font glyphs 2332 * are compressed and we do need to uncompress them. 2333 * Having single load_font() for both cases will help us to simplify 2334 * font switch handling. 2335 */ 2336 static vt_font_bitmap_data_t * 2337 load_font(char *path) 2338 { 2339 int fd, i; 2340 uint32_t glyphs; 2341 struct font_header fh; 2342 struct fontlist *fl; 2343 vt_font_bitmap_data_t *bp; 2344 struct vt_font *fp; 2345 size_t size; 2346 ssize_t rv; 2347 2348 /* Get our entry from the font list. */ 2349 STAILQ_FOREACH(fl, &fonts, font_next) { 2350 if (strcmp(fl->font_name, path) == 0) 2351 break; 2352 } 2353 if (fl == NULL) 2354 return (NULL); /* Should not happen. */ 2355 2356 bp = fl->font_data; 2357 if (bp->vfbd_font != NULL && fl->font_flags != FONT_RELOAD) 2358 return (bp); 2359 2360 fd = -1; 2361 /* 2362 * Special case for builtin font. 2363 * Builtin font is the very first font we load, we do not have 2364 * previous loads to be released. 2365 */ 2366 if (fl->font_flags == FONT_BUILTIN) { 2367 if ((fp = calloc(1, sizeof(struct vt_font))) == NULL) 2368 return (NULL); 2369 2370 fp->vf_width = DEFAULT_FONT_DATA.vfbd_width; 2371 fp->vf_height = DEFAULT_FONT_DATA.vfbd_height; 2372 2373 fp->vf_bytes = malloc(DEFAULT_FONT_DATA.vfbd_uncompressed_size); 2374 if (fp->vf_bytes == NULL) { 2375 free(fp); 2376 return (NULL); 2377 } 2378 2379 bp->vfbd_uncompressed_size = 2380 DEFAULT_FONT_DATA.vfbd_uncompressed_size; 2381 bp->vfbd_compressed_size = 2382 DEFAULT_FONT_DATA.vfbd_compressed_size; 2383 2384 if (lz4_decompress(DEFAULT_FONT_DATA.vfbd_compressed_data, 2385 fp->vf_bytes, 2386 DEFAULT_FONT_DATA.vfbd_compressed_size, 2387 DEFAULT_FONT_DATA.vfbd_uncompressed_size, 0) != 0) { 2388 free(fp->vf_bytes); 2389 free(fp); 2390 return (NULL); 2391 } 2392 2393 for (i = 0; i < VFNT_MAPS; i++) { 2394 fp->vf_map_count[i] = 2395 DEFAULT_FONT_DATA.vfbd_font->vf_map_count[i]; 2396 if (builtin_mapping(fp, i) != 0) 2397 goto free_done; 2398 } 2399 2400 bp->vfbd_font = fp; 2401 return (bp); 2402 } 2403 2404 fd = open(path, O_RDONLY); 2405 if (fd < 0) 2406 return (NULL); 2407 2408 size = sizeof(fh); 2409 rv = read(fd, &fh, size); 2410 if (rv < 0 || (size_t)rv != size) { 2411 bp = NULL; 2412 goto done; 2413 } 2414 if (memcmp(fh.fh_magic, FONT_HEADER_MAGIC, sizeof(fh.fh_magic)) != 0) { 2415 bp = NULL; 2416 goto done; 2417 } 2418 if ((fp = calloc(1, sizeof(struct vt_font))) == NULL) { 2419 bp = NULL; 2420 goto done; 2421 } 2422 for (i = 0; i < VFNT_MAPS; i++) 2423 fp->vf_map_count[i] = be32toh(fh.fh_map_count[i]); 2424 2425 glyphs = be32toh(fh.fh_glyph_count); 2426 fp->vf_width = fh.fh_width; 2427 fp->vf_height = fh.fh_height; 2428 2429 size = howmany(fp->vf_width, 8) * fp->vf_height * glyphs; 2430 bp->vfbd_uncompressed_size = size; 2431 if ((fp->vf_bytes = malloc(size)) == NULL) 2432 goto free_done; 2433 2434 rv = read(fd, fp->vf_bytes, size); 2435 if (rv < 0 || (size_t)rv != size) 2436 goto free_done; 2437 for (i = 0; i < VFNT_MAPS; i++) { 2438 if (load_mapping(fd, fp, i) != 0) 2439 goto free_done; 2440 } 2441 2442 /* 2443 * Reset builtin flag now as we have full font loaded. 2444 */ 2445 if (fl->font_flags == FONT_BUILTIN) 2446 fl->font_flags = FONT_AUTO; 2447 2448 /* 2449 * Release previously loaded entries. We can do this now, as 2450 * the new font is loaded. Note, there can be no console 2451 * output till the new font is in place and teken is notified. 2452 * We do need to keep fl->font_data for glyph dimensions. 2453 */ 2454 STAILQ_FOREACH(fl, &fonts, font_next) { 2455 if (fl->font_data->vfbd_font == NULL) 2456 continue; 2457 2458 for (i = 0; i < VFNT_MAPS; i++) 2459 free(fl->font_data->vfbd_font->vf_map[i]); 2460 free(fl->font_data->vfbd_font->vf_bytes); 2461 free(fl->font_data->vfbd_font); 2462 fl->font_data->vfbd_font = NULL; 2463 } 2464 2465 bp->vfbd_font = fp; 2466 bp->vfbd_compressed_size = 0; 2467 2468 done: 2469 if (fd != -1) 2470 close(fd); 2471 return (bp); 2472 2473 free_done: 2474 for (i = 0; i < VFNT_MAPS; i++) 2475 free(fp->vf_map[i]); 2476 free(fp->vf_bytes); 2477 free(fp); 2478 bp = NULL; 2479 goto done; 2480 } 2481 2482 struct name_entry { 2483 char *n_name; 2484 SLIST_ENTRY(name_entry) n_entry; 2485 }; 2486 2487 SLIST_HEAD(name_list, name_entry); 2488 2489 /* Read font names from index file. */ 2490 static struct name_list * 2491 read_list(char *fonts) 2492 { 2493 struct name_list *nl; 2494 struct name_entry *np; 2495 char *dir, *ptr; 2496 char buf[PATH_MAX]; 2497 int fd, len; 2498 2499 TSENTER(); 2500 2501 dir = strdup(fonts); 2502 if (dir == NULL) 2503 return (NULL); 2504 2505 ptr = strrchr(dir, '/'); 2506 *ptr = '\0'; 2507 2508 fd = open(fonts, O_RDONLY); 2509 if (fd < 0) 2510 return (NULL); 2511 2512 nl = malloc(sizeof(*nl)); 2513 if (nl == NULL) { 2514 close(fd); 2515 return (nl); 2516 } 2517 2518 SLIST_INIT(nl); 2519 while ((len = fgetstr(buf, sizeof (buf), fd)) >= 0) { 2520 if (*buf == '#' || *buf == '\0') 2521 continue; 2522 2523 if (bcmp(buf, "MENU", 4) == 0) 2524 continue; 2525 2526 if (bcmp(buf, "FONT", 4) == 0) 2527 continue; 2528 2529 ptr = strchr(buf, ':'); 2530 if (ptr == NULL) 2531 continue; 2532 else 2533 *ptr = '\0'; 2534 2535 np = malloc(sizeof(*np)); 2536 if (np == NULL) { 2537 close(fd); 2538 return (nl); /* return what we have */ 2539 } 2540 if (asprintf(&np->n_name, "%s/%s", dir, buf) < 0) { 2541 free(np); 2542 close(fd); 2543 return (nl); /* return what we have */ 2544 } 2545 SLIST_INSERT_HEAD(nl, np, n_entry); 2546 } 2547 close(fd); 2548 TSEXIT(); 2549 return (nl); 2550 } 2551 2552 /* 2553 * Read the font properties and insert new entry into the list. 2554 * The font list is built in descending order. 2555 */ 2556 static bool 2557 insert_font(char *name, FONT_FLAGS flags) 2558 { 2559 struct font_header fh; 2560 struct fontlist *fp, *previous, *entry, *next; 2561 size_t size; 2562 ssize_t rv; 2563 int fd; 2564 char *font_name; 2565 2566 TSENTER(); 2567 2568 font_name = NULL; 2569 if (flags == FONT_BUILTIN) { 2570 /* 2571 * We only install builtin font once, while setting up 2572 * initial console. Since this will happen very early, 2573 * we assume asprintf will not fail. Once we have access to 2574 * files, the builtin font will be replaced by font loaded 2575 * from file. 2576 */ 2577 if (!STAILQ_EMPTY(&fonts)) 2578 return (false); 2579 2580 fh.fh_width = DEFAULT_FONT_DATA.vfbd_width; 2581 fh.fh_height = DEFAULT_FONT_DATA.vfbd_height; 2582 2583 (void) asprintf(&font_name, "%dx%d", 2584 DEFAULT_FONT_DATA.vfbd_width, 2585 DEFAULT_FONT_DATA.vfbd_height); 2586 } else { 2587 fd = open(name, O_RDONLY); 2588 if (fd < 0) 2589 return (false); 2590 rv = read(fd, &fh, sizeof(fh)); 2591 close(fd); 2592 if (rv < 0 || (size_t)rv != sizeof(fh)) 2593 return (false); 2594 2595 if (memcmp(fh.fh_magic, FONT_HEADER_MAGIC, 2596 sizeof(fh.fh_magic)) != 0) 2597 return (false); 2598 font_name = strdup(name); 2599 } 2600 2601 if (font_name == NULL) 2602 return (false); 2603 2604 /* 2605 * If we have an entry with the same glyph dimensions, replace 2606 * the file name and mark us. We only support unique dimensions. 2607 */ 2608 STAILQ_FOREACH(entry, &fonts, font_next) { 2609 if (fh.fh_width == entry->font_data->vfbd_width && 2610 fh.fh_height == entry->font_data->vfbd_height) { 2611 free(entry->font_name); 2612 entry->font_name = font_name; 2613 entry->font_flags = FONT_RELOAD; 2614 TSEXIT(); 2615 return (true); 2616 } 2617 } 2618 2619 fp = calloc(sizeof(*fp), 1); 2620 if (fp == NULL) { 2621 free(font_name); 2622 return (false); 2623 } 2624 fp->font_data = calloc(sizeof(*fp->font_data), 1); 2625 if (fp->font_data == NULL) { 2626 free(font_name); 2627 free(fp); 2628 return (false); 2629 } 2630 fp->font_name = font_name; 2631 fp->font_flags = flags; 2632 fp->font_load = load_font; 2633 fp->font_data->vfbd_width = fh.fh_width; 2634 fp->font_data->vfbd_height = fh.fh_height; 2635 2636 if (STAILQ_EMPTY(&fonts)) { 2637 STAILQ_INSERT_HEAD(&fonts, fp, font_next); 2638 TSEXIT(); 2639 return (true); 2640 } 2641 2642 previous = NULL; 2643 size = fp->font_data->vfbd_width * fp->font_data->vfbd_height; 2644 2645 STAILQ_FOREACH(entry, &fonts, font_next) { 2646 vt_font_bitmap_data_t *bd; 2647 2648 bd = entry->font_data; 2649 /* Should fp be inserted before the entry? */ 2650 if (size > bd->vfbd_width * bd->vfbd_height) { 2651 if (previous == NULL) { 2652 STAILQ_INSERT_HEAD(&fonts, fp, font_next); 2653 } else { 2654 STAILQ_INSERT_AFTER(&fonts, previous, fp, 2655 font_next); 2656 } 2657 TSEXIT(); 2658 return (true); 2659 } 2660 next = STAILQ_NEXT(entry, font_next); 2661 if (next == NULL || 2662 size > next->font_data->vfbd_width * 2663 next->font_data->vfbd_height) { 2664 STAILQ_INSERT_AFTER(&fonts, entry, fp, font_next); 2665 TSEXIT(); 2666 return (true); 2667 } 2668 previous = entry; 2669 } 2670 TSEXIT(); 2671 return (true); 2672 } 2673 2674 static int 2675 font_set(struct env_var *ev __unused, int flags __unused, const void *value) 2676 { 2677 struct fontlist *fl; 2678 char *eptr; 2679 unsigned long x = 0, y = 0; 2680 2681 /* 2682 * Attempt to extract values from "XxY" string. In case of error, 2683 * we have unmaching glyph dimensions and will just output the 2684 * available values. 2685 */ 2686 if (value != NULL) { 2687 x = strtoul(value, &eptr, 10); 2688 if (*eptr == 'x') 2689 y = strtoul(eptr + 1, &eptr, 10); 2690 } 2691 STAILQ_FOREACH(fl, &fonts, font_next) { 2692 if (fl->font_data->vfbd_width == x && 2693 fl->font_data->vfbd_height == y) 2694 break; 2695 } 2696 if (fl != NULL) { 2697 /* Reset any FONT_MANUAL flag. */ 2698 reset_font_flags(); 2699 2700 /* Mark this font manually loaded */ 2701 fl->font_flags = FONT_MANUAL; 2702 cons_update_mode(gfx_state.tg_fb_type != FB_TEXT); 2703 return (CMD_OK); 2704 } 2705 2706 printf("Available fonts:\n"); 2707 STAILQ_FOREACH(fl, &fonts, font_next) { 2708 printf(" %dx%d\n", fl->font_data->vfbd_width, 2709 fl->font_data->vfbd_height); 2710 } 2711 return (CMD_OK); 2712 } 2713 2714 void 2715 bios_text_font(bool use_vga_font) 2716 { 2717 if (use_vga_font) 2718 (void) insert_font(VGA_8X16_FONT, FONT_MANUAL); 2719 else 2720 (void) insert_font(DEFAULT_8X16_FONT, FONT_MANUAL); 2721 } 2722 2723 void 2724 autoload_font(bool bios) 2725 { 2726 struct name_list *nl; 2727 struct name_entry *np; 2728 2729 TSENTER(); 2730 2731 nl = read_list("/boot/fonts/INDEX.fonts"); 2732 if (nl == NULL) 2733 return; 2734 2735 while (!SLIST_EMPTY(nl)) { 2736 np = SLIST_FIRST(nl); 2737 SLIST_REMOVE_HEAD(nl, n_entry); 2738 if (insert_font(np->n_name, FONT_AUTO) == false) 2739 printf("failed to add font: %s\n", np->n_name); 2740 free(np->n_name); 2741 free(np); 2742 } 2743 2744 /* 2745 * If vga text mode was requested, load vga.font (8x16 bold) font. 2746 */ 2747 if (bios) { 2748 bios_text_font(true); 2749 } 2750 2751 (void) cons_update_mode(gfx_state.tg_fb_type != FB_TEXT); 2752 2753 TSEXIT(); 2754 } 2755 2756 COMMAND_SET(load_font, "loadfont", "load console font from file", command_font); 2757 2758 static int 2759 command_font(int argc, char *argv[]) 2760 { 2761 int i, c, rc; 2762 struct fontlist *fl; 2763 vt_font_bitmap_data_t *bd; 2764 bool list; 2765 2766 list = false; 2767 optind = 1; 2768 optreset = 1; 2769 rc = CMD_OK; 2770 2771 while ((c = getopt(argc, argv, "l")) != -1) { 2772 switch (c) { 2773 case 'l': 2774 list = true; 2775 break; 2776 case '?': 2777 default: 2778 return (CMD_ERROR); 2779 } 2780 } 2781 2782 argc -= optind; 2783 argv += optind; 2784 2785 if (argc > 1 || (list && argc != 0)) { 2786 printf("Usage: loadfont [-l] | [file.fnt]\n"); 2787 return (CMD_ERROR); 2788 } 2789 2790 if (list) { 2791 STAILQ_FOREACH(fl, &fonts, font_next) { 2792 printf("font %s: %dx%d%s\n", fl->font_name, 2793 fl->font_data->vfbd_width, 2794 fl->font_data->vfbd_height, 2795 fl->font_data->vfbd_font == NULL? "" : " loaded"); 2796 } 2797 return (CMD_OK); 2798 } 2799 2800 /* Clear scren */ 2801 cons_clear(); 2802 2803 if (argc == 1) { 2804 char *name = argv[0]; 2805 2806 if (insert_font(name, FONT_MANUAL) == false) { 2807 printf("loadfont error: failed to load: %s\n", name); 2808 return (CMD_ERROR); 2809 } 2810 2811 (void) cons_update_mode(gfx_state.tg_fb_type != FB_TEXT); 2812 return (CMD_OK); 2813 } 2814 2815 if (argc == 0) { 2816 /* 2817 * Walk entire font list, release any loaded font, and set 2818 * autoload flag. The font list does have at least the builtin 2819 * default font. 2820 */ 2821 STAILQ_FOREACH(fl, &fonts, font_next) { 2822 if (fl->font_data->vfbd_font != NULL) { 2823 2824 bd = fl->font_data; 2825 /* 2826 * Note the setup_font() is releasing 2827 * font bytes. 2828 */ 2829 for (i = 0; i < VFNT_MAPS; i++) 2830 free(bd->vfbd_font->vf_map[i]); 2831 free(fl->font_data->vfbd_font); 2832 fl->font_data->vfbd_font = NULL; 2833 fl->font_data->vfbd_uncompressed_size = 0; 2834 fl->font_flags = FONT_AUTO; 2835 } 2836 } 2837 (void) cons_update_mode(gfx_state.tg_fb_type != FB_TEXT); 2838 } 2839 return (rc); 2840 } 2841 2842 bool 2843 gfx_get_edid_resolution(struct vesa_edid_info *edid, edid_res_list_t *res) 2844 { 2845 struct resolution *rp, *p; 2846 2847 /* 2848 * Walk detailed timings tables (4). 2849 */ 2850 if ((edid->display.supported_features 2851 & EDID_FEATURE_PREFERRED_TIMING_MODE) != 0) { 2852 /* Walk detailed timing descriptors (4) */ 2853 for (int i = 0; i < DET_TIMINGS; i++) { 2854 /* 2855 * Reserved value 0 is not used for display descriptor. 2856 */ 2857 if (edid->detailed_timings[i].pixel_clock == 0) 2858 continue; 2859 if ((rp = malloc(sizeof(*rp))) == NULL) 2860 continue; 2861 rp->width = GET_EDID_INFO_WIDTH(edid, i); 2862 rp->height = GET_EDID_INFO_HEIGHT(edid, i); 2863 if (rp->width > 0 && rp->width <= EDID_MAX_PIXELS && 2864 rp->height > 0 && rp->height <= EDID_MAX_LINES) 2865 TAILQ_INSERT_TAIL(res, rp, next); 2866 else 2867 free(rp); 2868 } 2869 } 2870 2871 /* 2872 * Walk standard timings list (8). 2873 */ 2874 for (int i = 0; i < STD_TIMINGS; i++) { 2875 /* Is this field unused? */ 2876 if (edid->standard_timings[i] == 0x0101) 2877 continue; 2878 2879 if ((rp = malloc(sizeof(*rp))) == NULL) 2880 continue; 2881 2882 rp->width = HSIZE(edid->standard_timings[i]); 2883 switch (RATIO(edid->standard_timings[i])) { 2884 case RATIO1_1: 2885 rp->height = HSIZE(edid->standard_timings[i]); 2886 if (edid->header.version > 1 || 2887 edid->header.revision > 2) { 2888 rp->height = rp->height * 10 / 16; 2889 } 2890 break; 2891 case RATIO4_3: 2892 rp->height = HSIZE(edid->standard_timings[i]) * 3 / 4; 2893 break; 2894 case RATIO5_4: 2895 rp->height = HSIZE(edid->standard_timings[i]) * 4 / 5; 2896 break; 2897 case RATIO16_9: 2898 rp->height = HSIZE(edid->standard_timings[i]) * 9 / 16; 2899 break; 2900 } 2901 2902 /* 2903 * Create resolution list in decreasing order, except keep 2904 * first entry (preferred timing mode). 2905 */ 2906 TAILQ_FOREACH(p, res, next) { 2907 if (p->width * p->height < rp->width * rp->height) { 2908 /* Keep preferred mode first */ 2909 if (TAILQ_FIRST(res) == p) 2910 TAILQ_INSERT_AFTER(res, p, rp, next); 2911 else 2912 TAILQ_INSERT_BEFORE(p, rp, next); 2913 break; 2914 } 2915 if (TAILQ_NEXT(p, next) == NULL) { 2916 TAILQ_INSERT_TAIL(res, rp, next); 2917 break; 2918 } 2919 } 2920 } 2921 return (!TAILQ_EMPTY(res)); 2922 } 2923 2924 vm_offset_t 2925 build_font_module(vm_offset_t addr) 2926 { 2927 vt_font_bitmap_data_t *bd; 2928 struct vt_font *fd; 2929 struct preloaded_file *fp; 2930 size_t size; 2931 uint32_t checksum; 2932 int i; 2933 struct font_info fi; 2934 struct fontlist *fl; 2935 uint64_t fontp; 2936 2937 if (STAILQ_EMPTY(&fonts)) 2938 return (addr); 2939 2940 /* We can't load first */ 2941 if ((file_findfile(NULL, NULL)) == NULL) { 2942 printf("Can not load font module: %s\n", 2943 "the kernel is not loaded"); 2944 return (addr); 2945 } 2946 2947 /* helper pointers */ 2948 bd = NULL; 2949 STAILQ_FOREACH(fl, &fonts, font_next) { 2950 if (gfx_state.tg_font.vf_width == fl->font_data->vfbd_width && 2951 gfx_state.tg_font.vf_height == fl->font_data->vfbd_height) { 2952 /* 2953 * Kernel does have better built in font. 2954 */ 2955 if (fl->font_flags == FONT_BUILTIN) 2956 return (addr); 2957 2958 bd = fl->font_data; 2959 break; 2960 } 2961 } 2962 if (bd == NULL) 2963 return (addr); 2964 fd = bd->vfbd_font; 2965 2966 fi.fi_width = fd->vf_width; 2967 checksum = fi.fi_width; 2968 fi.fi_height = fd->vf_height; 2969 checksum += fi.fi_height; 2970 fi.fi_bitmap_size = bd->vfbd_uncompressed_size; 2971 checksum += fi.fi_bitmap_size; 2972 2973 size = roundup2(sizeof (struct font_info), 8); 2974 for (i = 0; i < VFNT_MAPS; i++) { 2975 fi.fi_map_count[i] = fd->vf_map_count[i]; 2976 checksum += fi.fi_map_count[i]; 2977 size += fd->vf_map_count[i] * sizeof (struct vfnt_map); 2978 size += roundup2(size, 8); 2979 } 2980 size += bd->vfbd_uncompressed_size; 2981 2982 fi.fi_checksum = -checksum; 2983 2984 fp = file_findfile(NULL, "elf kernel"); 2985 if (fp == NULL) 2986 fp = file_findfile(NULL, "elf64 kernel"); 2987 if (fp == NULL) 2988 panic("can't find kernel file"); 2989 2990 fontp = addr; 2991 addr += archsw.arch_copyin(&fi, addr, sizeof (struct font_info)); 2992 addr = roundup2(addr, 8); 2993 2994 /* Copy maps. */ 2995 for (i = 0; i < VFNT_MAPS; i++) { 2996 if (fd->vf_map_count[i] != 0) { 2997 addr += archsw.arch_copyin(fd->vf_map[i], addr, 2998 fd->vf_map_count[i] * sizeof (struct vfnt_map)); 2999 addr = roundup2(addr, 8); 3000 } 3001 } 3002 3003 /* Copy the bitmap. */ 3004 addr += archsw.arch_copyin(fd->vf_bytes, addr, fi.fi_bitmap_size); 3005 3006 /* Looks OK so far; populate control structure */ 3007 file_addmetadata(fp, MODINFOMD_FONT, sizeof(fontp), &fontp); 3008 return (addr); 3009 } 3010