1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Procedures for drawing on the screen early on in the boot process. 4 * 5 * Benjamin Herrenschmidt <benh@kernel.crashing.org> 6 */ 7 #include <linux/kernel.h> 8 #include <linux/string.h> 9 #include <linux/init.h> 10 #include <linux/export.h> 11 #include <linux/font.h> 12 #include <linux/memblock.h> 13 #include <linux/pgtable.h> 14 #include <linux/of.h> 15 16 #include <asm/sections.h> 17 #include <asm/btext.h> 18 #include <asm/page.h> 19 #include <asm/mmu.h> 20 #include <asm/io.h> 21 #include <asm/processor.h> 22 #include <asm/udbg.h> 23 24 #define NO_SCROLL 25 26 #ifndef NO_SCROLL 27 static void scrollscreen(void); 28 #endif 29 30 #define __force_data __section(".data") 31 32 static int g_loc_X __force_data; 33 static int g_loc_Y __force_data; 34 static int g_max_loc_X __force_data; 35 static int g_max_loc_Y __force_data; 36 37 static int dispDeviceRowBytes __force_data; 38 static int dispDeviceDepth __force_data; 39 static int dispDeviceRect[4] __force_data; 40 static unsigned char *dispDeviceBase __force_data; 41 static unsigned char *logicalDisplayBase __force_data; 42 43 unsigned long disp_BAT[2] __initdata = {0, 0}; 44 45 static int boot_text_mapped __force_data; 46 47 extern void rmci_on(void); 48 extern void rmci_off(void); 49 50 static inline void rmci_maybe_on(void) 51 { 52 #if defined(CONFIG_PPC_EARLY_DEBUG_BOOTX) && defined(CONFIG_PPC64) 53 if (!(mfmsr() & MSR_DR)) 54 rmci_on(); 55 #endif 56 } 57 58 static inline void rmci_maybe_off(void) 59 { 60 #if defined(CONFIG_PPC_EARLY_DEBUG_BOOTX) && defined(CONFIG_PPC64) 61 if (!(mfmsr() & MSR_DR)) 62 rmci_off(); 63 #endif 64 } 65 66 67 #ifdef CONFIG_PPC32 68 /* Calc BAT values for mapping the display and store them 69 * in disp_BAT. Those values are then used from head.S to map 70 * the display during identify_machine() and MMU_Init() 71 * 72 * The display is mapped to virtual address 0xD0000000, rather 73 * than 1:1, because some CHRP machines put the frame buffer 74 * in the region starting at 0xC0000000 (PAGE_OFFSET). 75 * This mapping is temporary and will disappear as soon as the 76 * setup done by MMU_Init() is applied. 77 * 78 * For now, we align the BAT and then map 8Mb on 601 and 16Mb 79 * on other PPCs. This may cause trouble if the framebuffer 80 * is really badly aligned, but I didn't encounter this case 81 * yet. 82 */ 83 void __init btext_prepare_BAT(void) 84 { 85 unsigned long vaddr = PAGE_OFFSET + 0x10000000; 86 unsigned long addr; 87 unsigned long lowbits; 88 89 addr = (unsigned long)dispDeviceBase; 90 if (!addr) { 91 boot_text_mapped = 0; 92 return; 93 } 94 lowbits = addr & ~0xFF000000UL; 95 addr &= 0xFF000000UL; 96 disp_BAT[0] = vaddr | (BL_16M<<2) | 2; 97 disp_BAT[1] = addr | (_PAGE_NO_CACHE | _PAGE_GUARDED | BPP_RW); 98 logicalDisplayBase = (void *) (vaddr + lowbits); 99 } 100 #endif 101 102 103 /* This function can be used to enable the early boot text when doing 104 * OF booting or within bootx init. It must be followed by a btext_unmap() 105 * call before the logical address becomes unusable 106 */ 107 void __init btext_setup_display(int width, int height, int depth, int pitch, 108 unsigned long address) 109 { 110 g_loc_X = 0; 111 g_loc_Y = 0; 112 g_max_loc_X = width / 8; 113 g_max_loc_Y = height / 16; 114 logicalDisplayBase = (unsigned char *)address; 115 dispDeviceBase = (unsigned char *)address; 116 dispDeviceRowBytes = pitch; 117 dispDeviceDepth = depth == 15 ? 16 : depth; 118 dispDeviceRect[0] = dispDeviceRect[1] = 0; 119 dispDeviceRect[2] = width; 120 dispDeviceRect[3] = height; 121 boot_text_mapped = 1; 122 } 123 124 void __init btext_unmap(void) 125 { 126 boot_text_mapped = 0; 127 } 128 129 /* Here's a small text engine to use during early boot 130 * or for debugging purposes 131 * 132 * todo: 133 * 134 * - build some kind of vgacon with it to enable early printk 135 * - move to a separate file 136 * - add a few video driver hooks to keep in sync with display 137 * changes. 138 */ 139 140 void btext_map(void) 141 { 142 unsigned long base, offset, size; 143 unsigned char *vbase; 144 145 /* By default, we are no longer mapped */ 146 boot_text_mapped = 0; 147 if (!dispDeviceBase) 148 return; 149 base = ((unsigned long) dispDeviceBase) & 0xFFFFF000UL; 150 offset = ((unsigned long) dispDeviceBase) - base; 151 size = dispDeviceRowBytes * dispDeviceRect[3] + offset 152 + dispDeviceRect[0]; 153 vbase = ioremap_wc(base, size); 154 if (!vbase) 155 return; 156 logicalDisplayBase = vbase + offset; 157 boot_text_mapped = 1; 158 } 159 160 static int __init btext_initialize(struct device_node *np) 161 { 162 unsigned int width, height, depth, pitch; 163 unsigned long address = 0; 164 const u32 *prop; 165 166 prop = of_get_property(np, "linux,bootx-width", NULL); 167 if (prop == NULL) 168 prop = of_get_property(np, "width", NULL); 169 if (prop == NULL) 170 return -EINVAL; 171 width = *prop; 172 prop = of_get_property(np, "linux,bootx-height", NULL); 173 if (prop == NULL) 174 prop = of_get_property(np, "height", NULL); 175 if (prop == NULL) 176 return -EINVAL; 177 height = *prop; 178 prop = of_get_property(np, "linux,bootx-depth", NULL); 179 if (prop == NULL) 180 prop = of_get_property(np, "depth", NULL); 181 if (prop == NULL) 182 return -EINVAL; 183 depth = *prop; 184 pitch = width * ((depth + 7) / 8); 185 prop = of_get_property(np, "linux,bootx-linebytes", NULL); 186 if (prop == NULL) 187 prop = of_get_property(np, "linebytes", NULL); 188 if (prop && *prop != 0xffffffffu) 189 pitch = *prop; 190 if (pitch == 1) 191 pitch = 0x1000; 192 prop = of_get_property(np, "linux,bootx-addr", NULL); 193 if (prop == NULL) 194 prop = of_get_property(np, "address", NULL); 195 if (prop) 196 address = *prop; 197 198 /* FIXME: Add support for PCI reg properties. Right now, only 199 * reliable on macs 200 */ 201 if (address == 0) 202 return -EINVAL; 203 204 g_loc_X = 0; 205 g_loc_Y = 0; 206 g_max_loc_X = width / 8; 207 g_max_loc_Y = height / 16; 208 dispDeviceBase = (unsigned char *)address; 209 dispDeviceRowBytes = pitch; 210 dispDeviceDepth = depth == 15 ? 16 : depth; 211 dispDeviceRect[0] = dispDeviceRect[1] = 0; 212 dispDeviceRect[2] = width; 213 dispDeviceRect[3] = height; 214 215 btext_map(); 216 217 return 0; 218 } 219 220 int __init btext_find_display(int allow_nonstdout) 221 { 222 struct device_node *np = of_stdout; 223 int rc = -ENODEV; 224 225 if (!of_node_is_type(np, "display")) { 226 printk("boot stdout isn't a display !\n"); 227 np = NULL; 228 } 229 if (np) 230 rc = btext_initialize(np); 231 if (rc == 0 || !allow_nonstdout) 232 return rc; 233 234 for_each_node_by_type(np, "display") { 235 if (of_property_read_bool(np, "linux,opened")) { 236 printk("trying %pOF ...\n", np); 237 rc = btext_initialize(np); 238 printk("result: %d\n", rc); 239 } 240 if (rc == 0) { 241 of_node_put(np); 242 break; 243 } 244 } 245 return rc; 246 } 247 248 /* Calc the base address of a given point (x,y) */ 249 static unsigned char * calc_base(int x, int y) 250 { 251 unsigned char *base; 252 253 base = logicalDisplayBase; 254 if (!base) 255 base = dispDeviceBase; 256 base += (x + dispDeviceRect[0]) * (dispDeviceDepth >> 3); 257 base += (y + dispDeviceRect[1]) * dispDeviceRowBytes; 258 return base; 259 } 260 261 /* Adjust the display to a new resolution */ 262 void btext_update_display(unsigned long phys, int width, int height, 263 int depth, int pitch) 264 { 265 if (!dispDeviceBase) 266 return; 267 268 /* check it's the same frame buffer (within 256MB) */ 269 if ((phys ^ (unsigned long)dispDeviceBase) & 0xf0000000) 270 return; 271 272 dispDeviceBase = (__u8 *) phys; 273 dispDeviceRect[0] = 0; 274 dispDeviceRect[1] = 0; 275 dispDeviceRect[2] = width; 276 dispDeviceRect[3] = height; 277 dispDeviceDepth = depth; 278 dispDeviceRowBytes = pitch; 279 if (boot_text_mapped) { 280 iounmap(logicalDisplayBase); 281 boot_text_mapped = 0; 282 } 283 btext_map(); 284 g_loc_X = 0; 285 g_loc_Y = 0; 286 g_max_loc_X = width / 8; 287 g_max_loc_Y = height / 16; 288 } 289 EXPORT_SYMBOL(btext_update_display); 290 291 void __init btext_clearscreen(void) 292 { 293 unsigned int *base = (unsigned int *)calc_base(0, 0); 294 unsigned long width = ((dispDeviceRect[2] - dispDeviceRect[0]) * 295 (dispDeviceDepth >> 3)) >> 2; 296 int i,j; 297 298 rmci_maybe_on(); 299 for (i=0; i<(dispDeviceRect[3] - dispDeviceRect[1]); i++) 300 { 301 unsigned int *ptr = base; 302 for(j=width; j; --j) 303 *(ptr++) = 0; 304 base += (dispDeviceRowBytes >> 2); 305 } 306 rmci_maybe_off(); 307 } 308 309 void __init btext_flushscreen(void) 310 { 311 unsigned int *base = (unsigned int *)calc_base(0, 0); 312 unsigned long width = ((dispDeviceRect[2] - dispDeviceRect[0]) * 313 (dispDeviceDepth >> 3)) >> 2; 314 int i,j; 315 316 for (i=0; i < (dispDeviceRect[3] - dispDeviceRect[1]); i++) 317 { 318 unsigned int *ptr = base; 319 for(j = width; j > 0; j -= 8) { 320 __asm__ __volatile__ ("dcbst 0,%0" :: "r" (ptr)); 321 ptr += 8; 322 } 323 base += (dispDeviceRowBytes >> 2); 324 } 325 __asm__ __volatile__ ("sync" ::: "memory"); 326 } 327 328 void __init btext_flushline(void) 329 { 330 unsigned int *base = (unsigned int *)calc_base(0, g_loc_Y << 4); 331 unsigned long width = ((dispDeviceRect[2] - dispDeviceRect[0]) * 332 (dispDeviceDepth >> 3)) >> 2; 333 int i,j; 334 335 for (i=0; i < 16; i++) 336 { 337 unsigned int *ptr = base; 338 for(j = width; j > 0; j -= 8) { 339 __asm__ __volatile__ ("dcbst 0,%0" :: "r" (ptr)); 340 ptr += 8; 341 } 342 base += (dispDeviceRowBytes >> 2); 343 } 344 __asm__ __volatile__ ("sync" ::: "memory"); 345 } 346 347 348 #ifndef NO_SCROLL 349 static void scrollscreen(void) 350 { 351 unsigned int *src = (unsigned int *)calc_base(0,16); 352 unsigned int *dst = (unsigned int *)calc_base(0,0); 353 unsigned long width = ((dispDeviceRect[2] - dispDeviceRect[0]) * 354 (dispDeviceDepth >> 3)) >> 2; 355 int i,j; 356 357 rmci_maybe_on(); 358 359 for (i=0; i<(dispDeviceRect[3] - dispDeviceRect[1] - 16); i++) 360 { 361 unsigned int *src_ptr = src; 362 unsigned int *dst_ptr = dst; 363 for(j=width; j; --j) 364 *(dst_ptr++) = *(src_ptr++); 365 src += (dispDeviceRowBytes >> 2); 366 dst += (dispDeviceRowBytes >> 2); 367 } 368 for (i=0; i<16; i++) 369 { 370 unsigned int *dst_ptr = dst; 371 for(j=width; j; --j) 372 *(dst_ptr++) = 0; 373 dst += (dispDeviceRowBytes >> 2); 374 } 375 376 rmci_maybe_off(); 377 } 378 #endif /* ndef NO_SCROLL */ 379 380 static unsigned int expand_bits_8[16] = { 381 0x00000000, 382 0x000000ff, 383 0x0000ff00, 384 0x0000ffff, 385 0x00ff0000, 386 0x00ff00ff, 387 0x00ffff00, 388 0x00ffffff, 389 0xff000000, 390 0xff0000ff, 391 0xff00ff00, 392 0xff00ffff, 393 0xffff0000, 394 0xffff00ff, 395 0xffffff00, 396 0xffffffff 397 }; 398 399 static unsigned int expand_bits_16[4] = { 400 0x00000000, 401 0x0000ffff, 402 0xffff0000, 403 0xffffffff 404 }; 405 406 407 static void draw_byte_32(const unsigned char *font, unsigned int *base, int rb) 408 { 409 int l, bits; 410 int fg = 0xFFFFFFFFUL; 411 int bg = 0x00000000UL; 412 413 for (l = 0; l < 16; ++l) 414 { 415 bits = *font++; 416 base[0] = (-(bits >> 7) & fg) ^ bg; 417 base[1] = (-((bits >> 6) & 1) & fg) ^ bg; 418 base[2] = (-((bits >> 5) & 1) & fg) ^ bg; 419 base[3] = (-((bits >> 4) & 1) & fg) ^ bg; 420 base[4] = (-((bits >> 3) & 1) & fg) ^ bg; 421 base[5] = (-((bits >> 2) & 1) & fg) ^ bg; 422 base[6] = (-((bits >> 1) & 1) & fg) ^ bg; 423 base[7] = (-(bits & 1) & fg) ^ bg; 424 base = (unsigned int *) ((char *)base + rb); 425 } 426 } 427 428 static inline void draw_byte_16(const unsigned char *font, unsigned int *base, int rb) 429 { 430 int l, bits; 431 int fg = 0xFFFFFFFFUL; 432 int bg = 0x00000000UL; 433 unsigned int *eb = (int *)expand_bits_16; 434 435 for (l = 0; l < 16; ++l) 436 { 437 bits = *font++; 438 base[0] = (eb[bits >> 6] & fg) ^ bg; 439 base[1] = (eb[(bits >> 4) & 3] & fg) ^ bg; 440 base[2] = (eb[(bits >> 2) & 3] & fg) ^ bg; 441 base[3] = (eb[bits & 3] & fg) ^ bg; 442 base = (unsigned int *) ((char *)base + rb); 443 } 444 } 445 446 static inline void draw_byte_8(const unsigned char *font, unsigned int *base, int rb) 447 { 448 int l, bits; 449 int fg = 0x0F0F0F0FUL; 450 int bg = 0x00000000UL; 451 unsigned int *eb = (int *)expand_bits_8; 452 453 for (l = 0; l < 16; ++l) 454 { 455 bits = *font++; 456 base[0] = (eb[bits >> 4] & fg) ^ bg; 457 base[1] = (eb[bits & 0xf] & fg) ^ bg; 458 base = (unsigned int *) ((char *)base + rb); 459 } 460 } 461 462 static noinline void draw_byte(unsigned char c, long locX, long locY) 463 { 464 unsigned char *base = calc_base(locX << 3, locY << 4); 465 unsigned int font_index = c * 16; 466 const unsigned char *font = font_sun_8x16.data + font_index; 467 int rb = dispDeviceRowBytes; 468 469 rmci_maybe_on(); 470 switch(dispDeviceDepth) { 471 case 24: 472 case 32: 473 draw_byte_32(font, (unsigned int *)base, rb); 474 break; 475 case 15: 476 case 16: 477 draw_byte_16(font, (unsigned int *)base, rb); 478 break; 479 case 8: 480 draw_byte_8(font, (unsigned int *)base, rb); 481 break; 482 } 483 rmci_maybe_off(); 484 } 485 486 void btext_drawchar(char c) 487 { 488 int cline = 0; 489 #ifdef NO_SCROLL 490 int x; 491 #endif 492 if (!boot_text_mapped) 493 return; 494 495 switch (c) { 496 case '\b': 497 if (g_loc_X > 0) 498 --g_loc_X; 499 break; 500 case '\t': 501 g_loc_X = (g_loc_X & -8) + 8; 502 break; 503 case '\r': 504 g_loc_X = 0; 505 break; 506 case '\n': 507 g_loc_X = 0; 508 g_loc_Y++; 509 cline = 1; 510 break; 511 default: 512 draw_byte(c, g_loc_X++, g_loc_Y); 513 } 514 if (g_loc_X >= g_max_loc_X) { 515 g_loc_X = 0; 516 g_loc_Y++; 517 cline = 1; 518 } 519 #ifndef NO_SCROLL 520 while (g_loc_Y >= g_max_loc_Y) { 521 scrollscreen(); 522 g_loc_Y--; 523 } 524 #else 525 /* wrap around from bottom to top of screen so we don't 526 waste time scrolling each line. -- paulus. */ 527 if (g_loc_Y >= g_max_loc_Y) 528 g_loc_Y = 0; 529 if (cline) { 530 for (x = 0; x < g_max_loc_X; ++x) 531 draw_byte(' ', x, g_loc_Y); 532 } 533 #endif 534 } 535 536 void btext_drawstring(const char *c) 537 { 538 if (!boot_text_mapped) 539 return; 540 while (*c) 541 btext_drawchar(*c++); 542 } 543 544 void __init btext_drawtext(const char *c, unsigned int len) 545 { 546 if (!boot_text_mapped) 547 return; 548 while (len--) 549 btext_drawchar(*c++); 550 } 551 552 void __init btext_drawhex(unsigned long v) 553 { 554 if (!boot_text_mapped) 555 return; 556 #ifdef CONFIG_PPC64 557 btext_drawchar(hex_asc_hi(v >> 56)); 558 btext_drawchar(hex_asc_lo(v >> 56)); 559 btext_drawchar(hex_asc_hi(v >> 48)); 560 btext_drawchar(hex_asc_lo(v >> 48)); 561 btext_drawchar(hex_asc_hi(v >> 40)); 562 btext_drawchar(hex_asc_lo(v >> 40)); 563 btext_drawchar(hex_asc_hi(v >> 32)); 564 btext_drawchar(hex_asc_lo(v >> 32)); 565 #endif 566 btext_drawchar(hex_asc_hi(v >> 24)); 567 btext_drawchar(hex_asc_lo(v >> 24)); 568 btext_drawchar(hex_asc_hi(v >> 16)); 569 btext_drawchar(hex_asc_lo(v >> 16)); 570 btext_drawchar(hex_asc_hi(v >> 8)); 571 btext_drawchar(hex_asc_lo(v >> 8)); 572 btext_drawchar(hex_asc_hi(v)); 573 btext_drawchar(hex_asc_lo(v)); 574 btext_drawchar(' '); 575 } 576 577 void __init udbg_init_btext(void) 578 { 579 /* If btext is enabled, we might have a BAT setup for early display, 580 * thus we do enable some very basic udbg output 581 */ 582 udbg_putc = btext_drawchar; 583 } 584