1 /* 2 * (C) Copyright 2002 ELTEC Elektronik AG 3 * Frank Gottschling <fgottschling@eltec.de> 4 * 5 * See file CREDITS for list of people who contributed to this 6 * project. 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License as 10 * published by the Free Software Foundation; either version 2 of 11 * the License, or (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, 21 * MA 02111-1307 USA 22 */ 23 24 /* 25 * cfb_console.c 26 * 27 * Color Framebuffer Console driver for 8/15/16/24/32 bits per pixel. 28 * 29 * At the moment only the 8x16 font is tested and the font fore- and 30 * background color is limited to black/white/gray colors. The Linux 31 * logo can be placed in the upper left corner and additional board 32 * information strings (that normally goes to serial port) can be drawn. 33 * 34 * The console driver can use the standard PC keyboard interface (i8042) 35 * for character input. Character output goes to a memory mapped video 36 * framebuffer with little or big-endian organisation. 37 * With environment setting 'console=serial' the console i/o can be 38 * forced to serial port. 39 * 40 * The driver uses graphic specific defines/parameters/functions: 41 * 42 * (for SMI LynxE graphic chip) 43 * 44 * CONFIG_VIDEO_SMI_LYNXEM - use graphic driver for SMI 710,712,810 45 * VIDEO_FB_LITTLE_ENDIAN - framebuffer organisation default: big endian 46 * VIDEO_HW_RECTFILL - graphic driver supports hardware rectangle fill 47 * VIDEO_HW_BITBLT - graphic driver supports hardware bit blt 48 * 49 * Console Parameters are set by graphic drivers global struct: 50 * 51 * VIDEO_VISIBLE_COLS - x resolution 52 * VIDEO_VISIBLE_ROWS - y resolution 53 * VIDEO_PIXEL_SIZE - storage size in byte per pixel 54 * VIDEO_DATA_FORMAT - graphical data format GDF 55 * VIDEO_FB_ADRS - start of video memory 56 * 57 * CONFIG_I8042_KBD - AT Keyboard driver for i8042 58 * VIDEO_KBD_INIT_FCT - init function for keyboard 59 * VIDEO_TSTC_FCT - keyboard_tstc function 60 * VIDEO_GETC_FCT - keyboard_getc function 61 * 62 * CONFIG_CONSOLE_CURSOR - on/off drawing cursor is done with 63 * delay loop in VIDEO_TSTC_FCT (i8042) 64 * 65 * CONFIG_SYS_CONSOLE_BLINK_COUNT - value for delay loop - blink rate 66 * CONFIG_CONSOLE_TIME - display time/date in upper right 67 * corner, needs CONFIG_CMD_DATE and 68 * CONFIG_CONSOLE_CURSOR 69 * CONFIG_VIDEO_LOGO - display Linux Logo in upper left corner. 70 * Use CONFIG_SPLASH_SCREEN_ALIGN with 71 * environment variable "splashpos" to place 72 * the logo on other position. In this case 73 * no CONSOLE_EXTRA_INFO is possible. 74 * CONFIG_VIDEO_BMP_LOGO - use bmp_logo instead of linux_logo 75 * CONFIG_CONSOLE_EXTRA_INFO - display additional board information 76 * strings that normaly goes to serial 77 * port. This define requires a board 78 * specific function: 79 * video_drawstring (VIDEO_INFO_X, 80 * VIDEO_INFO_Y + i*VIDEO_FONT_HEIGHT, 81 * info); 82 * that fills a info buffer at i=row. 83 * s.a: board/eltec/bab7xx. 84 * CONFIG_VGA_AS_SINGLE_DEVICE - If set the framebuffer device will be 85 * initialized as an output only device. 86 * The Keyboard driver will not be 87 * set-up. This may be used, if you have 88 * no or more than one Keyboard devices 89 * (USB Keyboard, AT Keyboard). 90 * 91 * CONFIG_VIDEO_SW_CURSOR: - Draws a cursor after the last 92 * character. No blinking is provided. 93 * Uses the macros CURSOR_SET and 94 * CURSOR_OFF. 95 * 96 * CONFIG_VIDEO_HW_CURSOR: - Uses the hardware cursor capability 97 * of the graphic chip. Uses the macro 98 * CURSOR_SET. ATTENTION: If booting an 99 * OS, the display driver must disable 100 * the hardware register of the graphic 101 * chip. Otherwise a blinking field is 102 * displayed. 103 */ 104 105 #include <common.h> 106 #include <version.h> 107 #include <malloc.h> 108 #include <linux/compiler.h> 109 110 /* 111 * Console device defines with SMI graphic 112 * Any other graphic must change this section 113 */ 114 115 #ifdef CONFIG_VIDEO_SMI_LYNXEM 116 117 #define VIDEO_FB_LITTLE_ENDIAN 118 #define VIDEO_HW_RECTFILL 119 #define VIDEO_HW_BITBLT 120 #endif 121 122 /* 123 * Defines for the CT69000 driver 124 */ 125 #ifdef CONFIG_VIDEO_CT69000 126 127 #define VIDEO_FB_LITTLE_ENDIAN 128 #define VIDEO_HW_RECTFILL 129 #define VIDEO_HW_BITBLT 130 #endif 131 132 /* 133 * Defines for the SED13806 driver 134 */ 135 #ifdef CONFIG_VIDEO_SED13806 136 137 #ifndef CONFIG_TOTAL5200 138 #define VIDEO_FB_LITTLE_ENDIAN 139 #endif 140 #define VIDEO_HW_RECTFILL 141 #define VIDEO_HW_BITBLT 142 #endif 143 144 /* 145 * Defines for the SED13806 driver 146 */ 147 #ifdef CONFIG_VIDEO_SM501 148 149 #ifdef CONFIG_HH405 150 #define VIDEO_FB_LITTLE_ENDIAN 151 #endif 152 #endif 153 154 #ifdef CONFIG_VIDEO_MXS 155 #define VIDEO_FB_16BPP_WORD_SWAP 156 #endif 157 158 /* 159 * Defines for the MB862xx driver 160 */ 161 #ifdef CONFIG_VIDEO_MB862xx 162 163 #ifdef CONFIG_VIDEO_CORALP 164 #define VIDEO_FB_LITTLE_ENDIAN 165 #endif 166 #ifdef CONFIG_VIDEO_MB862xx_ACCEL 167 #define VIDEO_HW_RECTFILL 168 #define VIDEO_HW_BITBLT 169 #endif 170 #endif 171 172 /* 173 * Defines for the i.MX31 driver (mx3fb.c) 174 */ 175 #if defined(CONFIG_VIDEO_MX3) || defined(CONFIG_VIDEO_IPUV3) 176 #define VIDEO_FB_16BPP_WORD_SWAP 177 #endif 178 179 /* 180 * Include video_fb.h after definitions of VIDEO_HW_RECTFILL etc. 181 */ 182 #include <video_fb.h> 183 184 /* 185 * some Macros 186 */ 187 #define VIDEO_VISIBLE_COLS (pGD->winSizeX) 188 #define VIDEO_VISIBLE_ROWS (pGD->winSizeY) 189 #define VIDEO_PIXEL_SIZE (pGD->gdfBytesPP) 190 #define VIDEO_DATA_FORMAT (pGD->gdfIndex) 191 #define VIDEO_FB_ADRS (pGD->frameAdrs) 192 193 /* 194 * Console device defines with i8042 keyboard controller 195 * Any other keyboard controller must change this section 196 */ 197 198 #ifdef CONFIG_I8042_KBD 199 #include <i8042.h> 200 201 #define VIDEO_KBD_INIT_FCT i8042_kbd_init() 202 #define VIDEO_TSTC_FCT i8042_tstc 203 #define VIDEO_GETC_FCT i8042_getc 204 #endif 205 206 /* 207 * Console device 208 */ 209 210 #include <version.h> 211 #include <linux/types.h> 212 #include <stdio_dev.h> 213 #include <video_font.h> 214 #include <video_font_data.h> 215 216 #if defined(CONFIG_CMD_DATE) 217 #include <rtc.h> 218 #endif 219 220 #if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN) 221 #include <watchdog.h> 222 #include <bmp_layout.h> 223 224 #ifdef CONFIG_SPLASH_SCREEN_ALIGN 225 #define BMP_ALIGN_CENTER 0x7FFF 226 #endif 227 228 #endif 229 230 /* 231 * Cursor definition: 232 * CONFIG_CONSOLE_CURSOR: Uses a timer function (see drivers/input/i8042.c) 233 * to let the cursor blink. Uses the macros 234 * CURSOR_OFF and CURSOR_ON. 235 * CONFIG_VIDEO_SW_CURSOR: Draws a cursor after the last character. No 236 * blinking is provided. Uses the macros CURSOR_SET 237 * and CURSOR_OFF. 238 * CONFIG_VIDEO_HW_CURSOR: Uses the hardware cursor capability of the 239 * graphic chip. Uses the macro CURSOR_SET. 240 * ATTENTION: If booting an OS, the display driver 241 * must disable the hardware register of the graphic 242 * chip. Otherwise a blinking field is displayed 243 */ 244 #if !defined(CONFIG_CONSOLE_CURSOR) && \ 245 !defined(CONFIG_VIDEO_SW_CURSOR) && \ 246 !defined(CONFIG_VIDEO_HW_CURSOR) 247 /* no Cursor defined */ 248 #define CURSOR_ON 249 #define CURSOR_OFF 250 #define CURSOR_SET 251 #endif 252 253 #if defined(CONFIG_CONSOLE_CURSOR) || defined(CONFIG_VIDEO_SW_CURSOR) 254 #if defined(CURSOR_ON) || \ 255 (defined(CONFIG_CONSOLE_CURSOR) && defined(CONFIG_VIDEO_SW_CURSOR)) 256 #error only one of CONFIG_CONSOLE_CURSOR, CONFIG_VIDEO_SW_CURSOR, \ 257 or CONFIG_VIDEO_HW_CURSOR can be defined 258 #endif 259 void console_cursor(int state); 260 261 #define CURSOR_ON console_cursor(1) 262 #define CURSOR_OFF console_cursor(0) 263 #define CURSOR_SET video_set_cursor() 264 #endif /* CONFIG_CONSOLE_CURSOR || CONFIG_VIDEO_SW_CURSOR */ 265 266 #ifdef CONFIG_CONSOLE_CURSOR 267 #ifndef CONFIG_CONSOLE_TIME 268 #error CONFIG_CONSOLE_CURSOR must be defined for CONFIG_CONSOLE_TIME 269 #endif 270 #ifndef CONFIG_I8042_KBD 271 #warning Cursor drawing on/off needs timer function s.a. drivers/input/i8042.c 272 #endif 273 #endif /* CONFIG_CONSOLE_CURSOR */ 274 275 276 #ifdef CONFIG_VIDEO_HW_CURSOR 277 #ifdef CURSOR_ON 278 #error only one of CONFIG_CONSOLE_CURSOR, CONFIG_VIDEO_SW_CURSOR, \ 279 or CONFIG_VIDEO_HW_CURSOR can be defined 280 #endif 281 #define CURSOR_ON 282 #define CURSOR_OFF 283 #define CURSOR_SET video_set_hw_cursor(console_col * VIDEO_FONT_WIDTH, \ 284 (console_row * VIDEO_FONT_HEIGHT) + video_logo_height) 285 #endif /* CONFIG_VIDEO_HW_CURSOR */ 286 287 #ifdef CONFIG_VIDEO_LOGO 288 #ifdef CONFIG_VIDEO_BMP_LOGO 289 #include <bmp_logo.h> 290 #include <bmp_logo_data.h> 291 #define VIDEO_LOGO_WIDTH BMP_LOGO_WIDTH 292 #define VIDEO_LOGO_HEIGHT BMP_LOGO_HEIGHT 293 #define VIDEO_LOGO_LUT_OFFSET BMP_LOGO_OFFSET 294 #define VIDEO_LOGO_COLORS BMP_LOGO_COLORS 295 296 #else /* CONFIG_VIDEO_BMP_LOGO */ 297 #define LINUX_LOGO_WIDTH 80 298 #define LINUX_LOGO_HEIGHT 80 299 #define LINUX_LOGO_COLORS 214 300 #define LINUX_LOGO_LUT_OFFSET 0x20 301 #define __initdata 302 #include <linux_logo.h> 303 #define VIDEO_LOGO_WIDTH LINUX_LOGO_WIDTH 304 #define VIDEO_LOGO_HEIGHT LINUX_LOGO_HEIGHT 305 #define VIDEO_LOGO_LUT_OFFSET LINUX_LOGO_LUT_OFFSET 306 #define VIDEO_LOGO_COLORS LINUX_LOGO_COLORS 307 #endif /* CONFIG_VIDEO_BMP_LOGO */ 308 #define VIDEO_INFO_X (VIDEO_LOGO_WIDTH) 309 #define VIDEO_INFO_Y (VIDEO_FONT_HEIGHT/2) 310 #else /* CONFIG_VIDEO_LOGO */ 311 #define VIDEO_LOGO_WIDTH 0 312 #define VIDEO_LOGO_HEIGHT 0 313 #endif /* CONFIG_VIDEO_LOGO */ 314 315 #define VIDEO_COLS VIDEO_VISIBLE_COLS 316 #define VIDEO_ROWS VIDEO_VISIBLE_ROWS 317 #define VIDEO_SIZE (VIDEO_ROWS*VIDEO_COLS*VIDEO_PIXEL_SIZE) 318 #define VIDEO_PIX_BLOCKS (VIDEO_SIZE >> 2) 319 #define VIDEO_LINE_LEN (VIDEO_COLS*VIDEO_PIXEL_SIZE) 320 #define VIDEO_BURST_LEN (VIDEO_COLS/8) 321 322 #ifdef CONFIG_VIDEO_LOGO 323 #define CONSOLE_ROWS ((VIDEO_ROWS - video_logo_height) / VIDEO_FONT_HEIGHT) 324 #else 325 #define CONSOLE_ROWS (VIDEO_ROWS / VIDEO_FONT_HEIGHT) 326 #endif 327 328 #define CONSOLE_COLS (VIDEO_COLS / VIDEO_FONT_WIDTH) 329 #define CONSOLE_ROW_SIZE (VIDEO_FONT_HEIGHT * VIDEO_LINE_LEN) 330 #define CONSOLE_ROW_FIRST (video_console_address) 331 #define CONSOLE_ROW_SECOND (video_console_address + CONSOLE_ROW_SIZE) 332 #define CONSOLE_ROW_LAST (video_console_address + CONSOLE_SIZE - CONSOLE_ROW_SIZE) 333 #define CONSOLE_SIZE (CONSOLE_ROW_SIZE * CONSOLE_ROWS) 334 #define CONSOLE_SCROLL_SIZE (CONSOLE_SIZE - CONSOLE_ROW_SIZE) 335 336 /* Macros */ 337 #ifdef VIDEO_FB_LITTLE_ENDIAN 338 #define SWAP16(x) ((((x) & 0x00ff) << 8) | \ 339 ((x) >> 8) \ 340 ) 341 #define SWAP32(x) ((((x) & 0x000000ff) << 24) | \ 342 (((x) & 0x0000ff00) << 8) | \ 343 (((x) & 0x00ff0000) >> 8) | \ 344 (((x) & 0xff000000) >> 24) \ 345 ) 346 #define SHORTSWAP32(x) ((((x) & 0x000000ff) << 8) | \ 347 (((x) & 0x0000ff00) >> 8) | \ 348 (((x) & 0x00ff0000) << 8) | \ 349 (((x) & 0xff000000) >> 8) \ 350 ) 351 #else 352 #define SWAP16(x) (x) 353 #define SWAP32(x) (x) 354 #if defined(VIDEO_FB_16BPP_WORD_SWAP) 355 #define SHORTSWAP32(x) (((x) >> 16) | ((x) << 16)) 356 #else 357 #define SHORTSWAP32(x) (x) 358 #endif 359 #endif 360 361 #ifdef CONFIG_CONSOLE_EXTRA_INFO 362 /* 363 * setup a board string: type, speed, etc. 364 * 365 * line_number: location to place info string beside logo 366 * info: buffer for info string 367 */ 368 extern void video_get_info_str(int line_number, char *info); 369 #endif 370 371 DECLARE_GLOBAL_DATA_PTR; 372 373 /* Locals */ 374 static GraphicDevice *pGD; /* Pointer to Graphic array */ 375 376 static void *video_fb_address; /* frame buffer address */ 377 static void *video_console_address; /* console buffer start address */ 378 379 static int video_logo_height = VIDEO_LOGO_HEIGHT; 380 381 static int __maybe_unused cursor_state; 382 static int __maybe_unused old_col; 383 static int __maybe_unused old_row; 384 385 static int console_col; /* cursor col */ 386 static int console_row; /* cursor row */ 387 388 static u32 eorx, fgx, bgx; /* color pats */ 389 390 static int cfb_do_flush_cache; 391 392 #ifdef CONFIG_CFB_CONSOLE_ANSI 393 static char ansi_buf[10]; 394 static int ansi_buf_size; 395 static int ansi_colors_need_revert; 396 static int ansi_cursor_hidden; 397 #endif 398 399 static const int video_font_draw_table8[] = { 400 0x00000000, 0x000000ff, 0x0000ff00, 0x0000ffff, 401 0x00ff0000, 0x00ff00ff, 0x00ffff00, 0x00ffffff, 402 0xff000000, 0xff0000ff, 0xff00ff00, 0xff00ffff, 403 0xffff0000, 0xffff00ff, 0xffffff00, 0xffffffff 404 }; 405 406 static const int video_font_draw_table15[] = { 407 0x00000000, 0x00007fff, 0x7fff0000, 0x7fff7fff 408 }; 409 410 static const int video_font_draw_table16[] = { 411 0x00000000, 0x0000ffff, 0xffff0000, 0xffffffff 412 }; 413 414 static const int video_font_draw_table24[16][3] = { 415 {0x00000000, 0x00000000, 0x00000000}, 416 {0x00000000, 0x00000000, 0x00ffffff}, 417 {0x00000000, 0x0000ffff, 0xff000000}, 418 {0x00000000, 0x0000ffff, 0xffffffff}, 419 {0x000000ff, 0xffff0000, 0x00000000}, 420 {0x000000ff, 0xffff0000, 0x00ffffff}, 421 {0x000000ff, 0xffffffff, 0xff000000}, 422 {0x000000ff, 0xffffffff, 0xffffffff}, 423 {0xffffff00, 0x00000000, 0x00000000}, 424 {0xffffff00, 0x00000000, 0x00ffffff}, 425 {0xffffff00, 0x0000ffff, 0xff000000}, 426 {0xffffff00, 0x0000ffff, 0xffffffff}, 427 {0xffffffff, 0xffff0000, 0x00000000}, 428 {0xffffffff, 0xffff0000, 0x00ffffff}, 429 {0xffffffff, 0xffffffff, 0xff000000}, 430 {0xffffffff, 0xffffffff, 0xffffffff} 431 }; 432 433 static const int video_font_draw_table32[16][4] = { 434 {0x00000000, 0x00000000, 0x00000000, 0x00000000}, 435 {0x00000000, 0x00000000, 0x00000000, 0x00ffffff}, 436 {0x00000000, 0x00000000, 0x00ffffff, 0x00000000}, 437 {0x00000000, 0x00000000, 0x00ffffff, 0x00ffffff}, 438 {0x00000000, 0x00ffffff, 0x00000000, 0x00000000}, 439 {0x00000000, 0x00ffffff, 0x00000000, 0x00ffffff}, 440 {0x00000000, 0x00ffffff, 0x00ffffff, 0x00000000}, 441 {0x00000000, 0x00ffffff, 0x00ffffff, 0x00ffffff}, 442 {0x00ffffff, 0x00000000, 0x00000000, 0x00000000}, 443 {0x00ffffff, 0x00000000, 0x00000000, 0x00ffffff}, 444 {0x00ffffff, 0x00000000, 0x00ffffff, 0x00000000}, 445 {0x00ffffff, 0x00000000, 0x00ffffff, 0x00ffffff}, 446 {0x00ffffff, 0x00ffffff, 0x00000000, 0x00000000}, 447 {0x00ffffff, 0x00ffffff, 0x00000000, 0x00ffffff}, 448 {0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00000000}, 449 {0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00ffffff} 450 }; 451 452 static void video_drawchars(int xx, int yy, unsigned char *s, int count) 453 { 454 u8 *cdat, *dest, *dest0; 455 int rows, offset, c; 456 457 offset = yy * VIDEO_LINE_LEN + xx * VIDEO_PIXEL_SIZE; 458 dest0 = video_fb_address + offset; 459 460 switch (VIDEO_DATA_FORMAT) { 461 case GDF__8BIT_INDEX: 462 case GDF__8BIT_332RGB: 463 while (count--) { 464 c = *s; 465 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT; 466 for (rows = VIDEO_FONT_HEIGHT, dest = dest0; 467 rows--; dest += VIDEO_LINE_LEN) { 468 u8 bits = *cdat++; 469 470 ((u32 *) dest)[0] = 471 (video_font_draw_table8[bits >> 4] & 472 eorx) ^ bgx; 473 ((u32 *) dest)[1] = 474 (video_font_draw_table8[bits & 15] & 475 eorx) ^ bgx; 476 } 477 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE; 478 s++; 479 } 480 break; 481 482 case GDF_15BIT_555RGB: 483 while (count--) { 484 c = *s; 485 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT; 486 for (rows = VIDEO_FONT_HEIGHT, dest = dest0; 487 rows--; dest += VIDEO_LINE_LEN) { 488 u8 bits = *cdat++; 489 490 ((u32 *) dest)[0] = 491 SHORTSWAP32((video_font_draw_table15 492 [bits >> 6] & eorx) ^ 493 bgx); 494 ((u32 *) dest)[1] = 495 SHORTSWAP32((video_font_draw_table15 496 [bits >> 4 & 3] & eorx) ^ 497 bgx); 498 ((u32 *) dest)[2] = 499 SHORTSWAP32((video_font_draw_table15 500 [bits >> 2 & 3] & eorx) ^ 501 bgx); 502 ((u32 *) dest)[3] = 503 SHORTSWAP32((video_font_draw_table15 504 [bits & 3] & eorx) ^ 505 bgx); 506 } 507 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE; 508 s++; 509 } 510 break; 511 512 case GDF_16BIT_565RGB: 513 while (count--) { 514 c = *s; 515 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT; 516 for (rows = VIDEO_FONT_HEIGHT, dest = dest0; 517 rows--; dest += VIDEO_LINE_LEN) { 518 u8 bits = *cdat++; 519 520 ((u32 *) dest)[0] = 521 SHORTSWAP32((video_font_draw_table16 522 [bits >> 6] & eorx) ^ 523 bgx); 524 ((u32 *) dest)[1] = 525 SHORTSWAP32((video_font_draw_table16 526 [bits >> 4 & 3] & eorx) ^ 527 bgx); 528 ((u32 *) dest)[2] = 529 SHORTSWAP32((video_font_draw_table16 530 [bits >> 2 & 3] & eorx) ^ 531 bgx); 532 ((u32 *) dest)[3] = 533 SHORTSWAP32((video_font_draw_table16 534 [bits & 3] & eorx) ^ 535 bgx); 536 } 537 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE; 538 s++; 539 } 540 break; 541 542 case GDF_32BIT_X888RGB: 543 while (count--) { 544 c = *s; 545 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT; 546 for (rows = VIDEO_FONT_HEIGHT, dest = dest0; 547 rows--; dest += VIDEO_LINE_LEN) { 548 u8 bits = *cdat++; 549 550 ((u32 *) dest)[0] = 551 SWAP32((video_font_draw_table32 552 [bits >> 4][0] & eorx) ^ bgx); 553 ((u32 *) dest)[1] = 554 SWAP32((video_font_draw_table32 555 [bits >> 4][1] & eorx) ^ bgx); 556 ((u32 *) dest)[2] = 557 SWAP32((video_font_draw_table32 558 [bits >> 4][2] & eorx) ^ bgx); 559 ((u32 *) dest)[3] = 560 SWAP32((video_font_draw_table32 561 [bits >> 4][3] & eorx) ^ bgx); 562 ((u32 *) dest)[4] = 563 SWAP32((video_font_draw_table32 564 [bits & 15][0] & eorx) ^ bgx); 565 ((u32 *) dest)[5] = 566 SWAP32((video_font_draw_table32 567 [bits & 15][1] & eorx) ^ bgx); 568 ((u32 *) dest)[6] = 569 SWAP32((video_font_draw_table32 570 [bits & 15][2] & eorx) ^ bgx); 571 ((u32 *) dest)[7] = 572 SWAP32((video_font_draw_table32 573 [bits & 15][3] & eorx) ^ bgx); 574 } 575 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE; 576 s++; 577 } 578 break; 579 580 case GDF_24BIT_888RGB: 581 while (count--) { 582 c = *s; 583 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT; 584 for (rows = VIDEO_FONT_HEIGHT, dest = dest0; 585 rows--; dest += VIDEO_LINE_LEN) { 586 u8 bits = *cdat++; 587 588 ((u32 *) dest)[0] = 589 (video_font_draw_table24[bits >> 4][0] 590 & eorx) ^ bgx; 591 ((u32 *) dest)[1] = 592 (video_font_draw_table24[bits >> 4][1] 593 & eorx) ^ bgx; 594 ((u32 *) dest)[2] = 595 (video_font_draw_table24[bits >> 4][2] 596 & eorx) ^ bgx; 597 ((u32 *) dest)[3] = 598 (video_font_draw_table24[bits & 15][0] 599 & eorx) ^ bgx; 600 ((u32 *) dest)[4] = 601 (video_font_draw_table24[bits & 15][1] 602 & eorx) ^ bgx; 603 ((u32 *) dest)[5] = 604 (video_font_draw_table24[bits & 15][2] 605 & eorx) ^ bgx; 606 } 607 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE; 608 s++; 609 } 610 break; 611 } 612 } 613 614 static inline void video_drawstring(int xx, int yy, unsigned char *s) 615 { 616 video_drawchars(xx, yy, s, strlen((char *) s)); 617 } 618 619 static void video_putchar(int xx, int yy, unsigned char c) 620 { 621 video_drawchars(xx, yy + video_logo_height, &c, 1); 622 } 623 624 #if defined(CONFIG_CONSOLE_CURSOR) || defined(CONFIG_VIDEO_SW_CURSOR) 625 static void video_set_cursor(void) 626 { 627 if (cursor_state) 628 console_cursor(0); 629 console_cursor(1); 630 } 631 632 static void video_invertchar(int xx, int yy) 633 { 634 int firstx = xx * VIDEO_PIXEL_SIZE; 635 int lastx = (xx + VIDEO_FONT_WIDTH) * VIDEO_PIXEL_SIZE; 636 int firsty = yy * VIDEO_LINE_LEN; 637 int lasty = (yy + VIDEO_FONT_HEIGHT) * VIDEO_LINE_LEN; 638 int x, y; 639 for (y = firsty; y < lasty; y += VIDEO_LINE_LEN) { 640 for (x = firstx; x < lastx; x++) { 641 u8 *dest = (u8 *)(video_fb_address) + x + y; 642 *dest = ~*dest; 643 } 644 } 645 } 646 647 void console_cursor(int state) 648 { 649 #ifdef CONFIG_CONSOLE_TIME 650 struct rtc_time tm; 651 char info[16]; 652 653 /* time update only if cursor is on (faster scroll) */ 654 if (state) { 655 rtc_get(&tm); 656 657 sprintf(info, " %02d:%02d:%02d ", tm.tm_hour, tm.tm_min, 658 tm.tm_sec); 659 video_drawstring(VIDEO_VISIBLE_COLS - 10 * VIDEO_FONT_WIDTH, 660 VIDEO_INFO_Y, (uchar *) info); 661 662 sprintf(info, "%02d.%02d.%04d", tm.tm_mday, tm.tm_mon, 663 tm.tm_year); 664 video_drawstring(VIDEO_VISIBLE_COLS - 10 * VIDEO_FONT_WIDTH, 665 VIDEO_INFO_Y + 1 * VIDEO_FONT_HEIGHT, 666 (uchar *) info); 667 } 668 #endif 669 670 if (cursor_state != state) { 671 if (cursor_state) { 672 /* turn off the cursor */ 673 video_invertchar(old_col * VIDEO_FONT_WIDTH, 674 old_row * VIDEO_FONT_HEIGHT + 675 video_logo_height); 676 } else { 677 /* turn off the cursor and record where it is */ 678 video_invertchar(console_col * VIDEO_FONT_WIDTH, 679 console_row * VIDEO_FONT_HEIGHT + 680 video_logo_height); 681 old_col = console_col; 682 old_row = console_row; 683 } 684 cursor_state = state; 685 } 686 if (cfb_do_flush_cache) 687 flush_cache(VIDEO_FB_ADRS, VIDEO_SIZE); 688 } 689 #endif 690 691 #ifndef VIDEO_HW_RECTFILL 692 static void memsetl(int *p, int c, int v) 693 { 694 while (c--) 695 *(p++) = v; 696 } 697 #endif 698 699 #ifndef VIDEO_HW_BITBLT 700 static void memcpyl(int *d, int *s, int c) 701 { 702 while (c--) 703 *(d++) = *(s++); 704 } 705 #endif 706 707 static void console_clear_line(int line, int begin, int end) 708 { 709 #ifdef VIDEO_HW_RECTFILL 710 video_hw_rectfill(VIDEO_PIXEL_SIZE, /* bytes per pixel */ 711 VIDEO_FONT_WIDTH * begin, /* dest pos x */ 712 video_logo_height + 713 VIDEO_FONT_HEIGHT * line, /* dest pos y */ 714 VIDEO_FONT_WIDTH * (end - begin + 1), /* fr. width */ 715 VIDEO_FONT_HEIGHT, /* frame height */ 716 bgx /* fill color */ 717 ); 718 #else 719 if (begin == 0 && (end + 1) == CONSOLE_COLS) { 720 memsetl(CONSOLE_ROW_FIRST + 721 CONSOLE_ROW_SIZE * line, /* offset of row */ 722 CONSOLE_ROW_SIZE >> 2, /* length of row */ 723 bgx /* fill color */ 724 ); 725 } else { 726 void *offset; 727 int i, size; 728 729 offset = CONSOLE_ROW_FIRST + 730 CONSOLE_ROW_SIZE * line + /* offset of row */ 731 VIDEO_FONT_WIDTH * 732 VIDEO_PIXEL_SIZE * begin; /* offset of col */ 733 size = VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE * (end - begin + 1); 734 size >>= 2; /* length to end for memsetl() */ 735 /* fill at col offset of i'th line using bgx as fill color */ 736 for (i = 0; i < VIDEO_FONT_HEIGHT; i++) 737 memsetl(offset + i * VIDEO_LINE_LEN, size, bgx); 738 } 739 #endif 740 } 741 742 static void console_scrollup(void) 743 { 744 /* copy up rows ignoring the first one */ 745 746 #ifdef VIDEO_HW_BITBLT 747 video_hw_bitblt(VIDEO_PIXEL_SIZE, /* bytes per pixel */ 748 0, /* source pos x */ 749 video_logo_height + 750 VIDEO_FONT_HEIGHT, /* source pos y */ 751 0, /* dest pos x */ 752 video_logo_height, /* dest pos y */ 753 VIDEO_VISIBLE_COLS, /* frame width */ 754 VIDEO_VISIBLE_ROWS 755 - video_logo_height 756 - VIDEO_FONT_HEIGHT /* frame height */ 757 ); 758 #else 759 memcpyl(CONSOLE_ROW_FIRST, CONSOLE_ROW_SECOND, 760 CONSOLE_SCROLL_SIZE >> 2); 761 #endif 762 /* clear the last one */ 763 console_clear_line(CONSOLE_ROWS - 1, 0, CONSOLE_COLS - 1); 764 } 765 766 static void console_back(void) 767 { 768 console_col--; 769 770 if (console_col < 0) { 771 console_col = CONSOLE_COLS - 1; 772 console_row--; 773 if (console_row < 0) 774 console_row = 0; 775 } 776 } 777 778 #ifdef CONFIG_CFB_CONSOLE_ANSI 779 780 static void console_clear(void) 781 { 782 #ifdef VIDEO_HW_RECTFILL 783 video_hw_rectfill(VIDEO_PIXEL_SIZE, /* bytes per pixel */ 784 0, /* dest pos x */ 785 video_logo_height, /* dest pos y */ 786 VIDEO_VISIBLE_COLS, /* frame width */ 787 VIDEO_VISIBLE_ROWS, /* frame height */ 788 bgx /* fill color */ 789 ); 790 #else 791 memsetl(CONSOLE_ROW_FIRST, CONSOLE_SIZE, bgx); 792 #endif 793 } 794 795 static void console_cursor_fix(void) 796 { 797 if (console_row < 0) 798 console_row = 0; 799 if (console_row >= CONSOLE_ROWS) 800 console_row = CONSOLE_ROWS - 1; 801 if (console_col < 0) 802 console_col = 0; 803 if (console_col >= CONSOLE_COLS) 804 console_col = CONSOLE_COLS - 1; 805 } 806 807 static void console_cursor_up(int n) 808 { 809 console_row -= n; 810 console_cursor_fix(); 811 } 812 813 static void console_cursor_down(int n) 814 { 815 console_row += n; 816 console_cursor_fix(); 817 } 818 819 static void console_cursor_left(int n) 820 { 821 console_col -= n; 822 console_cursor_fix(); 823 } 824 825 static void console_cursor_right(int n) 826 { 827 console_col += n; 828 console_cursor_fix(); 829 } 830 831 static void console_cursor_set_position(int row, int col) 832 { 833 if (console_row != -1) 834 console_row = row; 835 if (console_col != -1) 836 console_col = col; 837 console_cursor_fix(); 838 } 839 840 static void console_previousline(int n) 841 { 842 /* FIXME: also scroll terminal ? */ 843 console_row -= n; 844 console_cursor_fix(); 845 } 846 847 static void console_swap_colors(void) 848 { 849 eorx = fgx; 850 fgx = bgx; 851 bgx = eorx; 852 eorx = fgx ^ bgx; 853 } 854 855 static inline int console_cursor_is_visible(void) 856 { 857 return !ansi_cursor_hidden; 858 } 859 #else 860 static inline int console_cursor_is_visible(void) 861 { 862 return 1; 863 } 864 #endif 865 866 static void console_newline(int n) 867 { 868 console_row += n; 869 console_col = 0; 870 871 /* Check if we need to scroll the terminal */ 872 if (console_row >= CONSOLE_ROWS) { 873 /* Scroll everything up */ 874 console_scrollup(); 875 876 /* Decrement row number */ 877 console_row = CONSOLE_ROWS - 1; 878 } 879 } 880 881 static void console_cr(void) 882 { 883 console_col = 0; 884 } 885 886 static void parse_putc(const char c) 887 { 888 static int nl = 1; 889 890 if (console_cursor_is_visible()) 891 CURSOR_OFF; 892 893 switch (c) { 894 case 13: /* back to first column */ 895 console_cr(); 896 break; 897 898 case '\n': /* next line */ 899 if (console_col || (!console_col && nl)) 900 console_newline(1); 901 nl = 1; 902 break; 903 904 case 9: /* tab 8 */ 905 console_col |= 0x0008; 906 console_col &= ~0x0007; 907 908 if (console_col >= CONSOLE_COLS) 909 console_newline(1); 910 break; 911 912 case 8: /* backspace */ 913 console_back(); 914 break; 915 916 case 7: /* bell */ 917 break; /* ignored */ 918 919 default: /* draw the char */ 920 video_putchar(console_col * VIDEO_FONT_WIDTH, 921 console_row * VIDEO_FONT_HEIGHT, c); 922 console_col++; 923 924 /* check for newline */ 925 if (console_col >= CONSOLE_COLS) { 926 console_newline(1); 927 nl = 0; 928 } 929 } 930 931 if (console_cursor_is_visible()) 932 CURSOR_SET; 933 } 934 935 void video_putc(const char c) 936 { 937 #ifdef CONFIG_CFB_CONSOLE_ANSI 938 int i; 939 940 if (c == 27) { 941 for (i = 0; i < ansi_buf_size; ++i) 942 parse_putc(ansi_buf[i]); 943 ansi_buf[0] = 27; 944 ansi_buf_size = 1; 945 return; 946 } 947 948 if (ansi_buf_size > 0) { 949 /* 950 * 0 - ESC 951 * 1 - [ 952 * 2 - num1 953 * 3 - .. 954 * 4 - ; 955 * 5 - num2 956 * 6 - .. 957 * - cchar 958 */ 959 int next = 0; 960 961 int flush = 0; 962 int fail = 0; 963 964 int num1 = 0; 965 int num2 = 0; 966 int cchar = 0; 967 968 ansi_buf[ansi_buf_size++] = c; 969 970 if (ansi_buf_size >= sizeof(ansi_buf)) 971 fail = 1; 972 973 for (i = 0; i < ansi_buf_size; ++i) { 974 if (fail) 975 break; 976 977 switch (next) { 978 case 0: 979 if (ansi_buf[i] == 27) 980 next = 1; 981 else 982 fail = 1; 983 break; 984 985 case 1: 986 if (ansi_buf[i] == '[') 987 next = 2; 988 else 989 fail = 1; 990 break; 991 992 case 2: 993 if (ansi_buf[i] >= '0' && ansi_buf[i] <= '9') { 994 num1 = ansi_buf[i]-'0'; 995 next = 3; 996 } else if (ansi_buf[i] != '?') { 997 --i; 998 num1 = 1; 999 next = 4; 1000 } 1001 break; 1002 1003 case 3: 1004 if (ansi_buf[i] >= '0' && ansi_buf[i] <= '9') { 1005 num1 *= 10; 1006 num1 += ansi_buf[i]-'0'; 1007 } else { 1008 --i; 1009 next = 4; 1010 } 1011 break; 1012 1013 case 4: 1014 if (ansi_buf[i] != ';') { 1015 --i; 1016 next = 7; 1017 } else 1018 next = 5; 1019 break; 1020 1021 case 5: 1022 if (ansi_buf[i] >= '0' && ansi_buf[i] <= '9') { 1023 num2 = ansi_buf[i]-'0'; 1024 next = 6; 1025 } else 1026 fail = 1; 1027 break; 1028 1029 case 6: 1030 if (ansi_buf[i] >= '0' && ansi_buf[i] <= '9') { 1031 num2 *= 10; 1032 num2 += ansi_buf[i]-'0'; 1033 } else { 1034 --i; 1035 next = 7; 1036 } 1037 break; 1038 1039 case 7: 1040 if ((ansi_buf[i] >= 'A' && ansi_buf[i] <= 'H') 1041 || ansi_buf[i] == 'J' 1042 || ansi_buf[i] == 'K' 1043 || ansi_buf[i] == 'h' 1044 || ansi_buf[i] == 'l' 1045 || ansi_buf[i] == 'm') { 1046 cchar = ansi_buf[i]; 1047 flush = 1; 1048 } else 1049 fail = 1; 1050 break; 1051 } 1052 } 1053 1054 if (fail) { 1055 for (i = 0; i < ansi_buf_size; ++i) 1056 parse_putc(ansi_buf[i]); 1057 ansi_buf_size = 0; 1058 return; 1059 } 1060 1061 if (flush) { 1062 if (!ansi_cursor_hidden) 1063 CURSOR_OFF; 1064 ansi_buf_size = 0; 1065 switch (cchar) { 1066 case 'A': 1067 /* move cursor num1 rows up */ 1068 console_cursor_up(num1); 1069 break; 1070 case 'B': 1071 /* move cursor num1 rows down */ 1072 console_cursor_down(num1); 1073 break; 1074 case 'C': 1075 /* move cursor num1 columns forward */ 1076 console_cursor_right(num1); 1077 break; 1078 case 'D': 1079 /* move cursor num1 columns back */ 1080 console_cursor_left(num1); 1081 break; 1082 case 'E': 1083 /* move cursor num1 rows up at begin of row */ 1084 console_previousline(num1); 1085 break; 1086 case 'F': 1087 /* move cursor num1 rows down at begin of row */ 1088 console_newline(num1); 1089 break; 1090 case 'G': 1091 /* move cursor to column num1 */ 1092 console_cursor_set_position(-1, num1-1); 1093 break; 1094 case 'H': 1095 /* move cursor to row num1, column num2 */ 1096 console_cursor_set_position(num1-1, num2-1); 1097 break; 1098 case 'J': 1099 /* clear console and move cursor to 0, 0 */ 1100 console_clear(); 1101 console_cursor_set_position(0, 0); 1102 break; 1103 case 'K': 1104 /* clear line */ 1105 if (num1 == 0) 1106 console_clear_line(console_row, 1107 console_col, 1108 CONSOLE_COLS-1); 1109 else if (num1 == 1) 1110 console_clear_line(console_row, 1111 0, console_col); 1112 else 1113 console_clear_line(console_row, 1114 0, CONSOLE_COLS-1); 1115 break; 1116 case 'h': 1117 ansi_cursor_hidden = 0; 1118 break; 1119 case 'l': 1120 ansi_cursor_hidden = 1; 1121 break; 1122 case 'm': 1123 if (num1 == 0) { /* reset swapped colors */ 1124 if (ansi_colors_need_revert) { 1125 console_swap_colors(); 1126 ansi_colors_need_revert = 0; 1127 } 1128 } else if (num1 == 7) { /* once swap colors */ 1129 if (!ansi_colors_need_revert) { 1130 console_swap_colors(); 1131 ansi_colors_need_revert = 1; 1132 } 1133 } 1134 break; 1135 } 1136 if (!ansi_cursor_hidden) 1137 CURSOR_SET; 1138 } 1139 } else { 1140 parse_putc(c); 1141 } 1142 #else 1143 parse_putc(c); 1144 #endif 1145 if (cfb_do_flush_cache) 1146 flush_cache(VIDEO_FB_ADRS, VIDEO_SIZE); 1147 } 1148 1149 void video_puts(const char *s) 1150 { 1151 int count = strlen(s); 1152 1153 while (count--) 1154 video_putc(*s++); 1155 } 1156 1157 /* 1158 * Do not enforce drivers (or board code) to provide empty 1159 * video_set_lut() if they do not support 8 bpp format. 1160 * Implement weak default function instead. 1161 */ 1162 void __video_set_lut(unsigned int index, unsigned char r, 1163 unsigned char g, unsigned char b) 1164 { 1165 } 1166 1167 void video_set_lut(unsigned int, unsigned char, unsigned char, unsigned char) 1168 __attribute__ ((weak, alias("__video_set_lut"))); 1169 1170 #if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN) 1171 1172 #define FILL_8BIT_332RGB(r,g,b) { \ 1173 *fb = ((r>>5)<<5) | ((g>>5)<<2) | (b>>6); \ 1174 fb ++; \ 1175 } 1176 1177 #define FILL_15BIT_555RGB(r,g,b) { \ 1178 *(unsigned short *)fb = \ 1179 SWAP16((unsigned short)(((r>>3)<<10) | \ 1180 ((g>>3)<<5) | \ 1181 (b>>3))); \ 1182 fb += 2; \ 1183 } 1184 1185 #define FILL_16BIT_565RGB(r,g,b) { \ 1186 *(unsigned short *)fb = \ 1187 SWAP16((unsigned short)((((r)>>3)<<11)| \ 1188 (((g)>>2)<<5) | \ 1189 ((b)>>3))); \ 1190 fb += 2; \ 1191 } 1192 1193 #define FILL_32BIT_X888RGB(r,g,b) { \ 1194 *(unsigned long *)fb = \ 1195 SWAP32((unsigned long)(((r<<16) | \ 1196 (g<<8) | \ 1197 b))); \ 1198 fb += 4; \ 1199 } 1200 1201 #ifdef VIDEO_FB_LITTLE_ENDIAN 1202 #define FILL_24BIT_888RGB(r,g,b) { \ 1203 fb[0] = b; \ 1204 fb[1] = g; \ 1205 fb[2] = r; \ 1206 fb += 3; \ 1207 } 1208 #else 1209 #define FILL_24BIT_888RGB(r,g,b) { \ 1210 fb[0] = r; \ 1211 fb[1] = g; \ 1212 fb[2] = b; \ 1213 fb += 3; \ 1214 } 1215 #endif 1216 1217 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 1218 static inline void fill_555rgb_pswap(uchar *fb, int x, u8 r, u8 g, u8 b) 1219 { 1220 ushort *dst = (ushort *) fb; 1221 ushort color = (ushort) (((r >> 3) << 10) | 1222 ((g >> 3) << 5) | 1223 (b >> 3)); 1224 if (x & 1) 1225 *(--dst) = color; 1226 else 1227 *(++dst) = color; 1228 } 1229 #endif 1230 1231 /* 1232 * RLE8 bitmap support 1233 */ 1234 1235 #ifdef CONFIG_VIDEO_BMP_RLE8 1236 /* Pre-calculated color table entry */ 1237 struct palette { 1238 union { 1239 unsigned short w; /* word */ 1240 unsigned int dw; /* double word */ 1241 } ce; /* color entry */ 1242 }; 1243 1244 /* 1245 * Helper to draw encoded/unencoded run. 1246 */ 1247 static void draw_bitmap(uchar **fb, uchar *bm, struct palette *p, 1248 int cnt, int enc) 1249 { 1250 ulong addr = (ulong) *fb; 1251 int *off; 1252 int enc_off = 1; 1253 int i; 1254 1255 /* 1256 * Setup offset of the color index in the bitmap. 1257 * Color index of encoded run is at offset 1. 1258 */ 1259 off = enc ? &enc_off : &i; 1260 1261 switch (VIDEO_DATA_FORMAT) { 1262 case GDF__8BIT_INDEX: 1263 for (i = 0; i < cnt; i++) 1264 *(unsigned char *) addr++ = bm[*off]; 1265 break; 1266 case GDF_15BIT_555RGB: 1267 case GDF_16BIT_565RGB: 1268 /* differences handled while pre-calculating palette */ 1269 for (i = 0; i < cnt; i++) { 1270 *(unsigned short *) addr = p[bm[*off]].ce.w; 1271 addr += 2; 1272 } 1273 break; 1274 case GDF_32BIT_X888RGB: 1275 for (i = 0; i < cnt; i++) { 1276 *(unsigned long *) addr = p[bm[*off]].ce.dw; 1277 addr += 4; 1278 } 1279 break; 1280 } 1281 *fb = (uchar *) addr; /* return modified address */ 1282 } 1283 1284 static int display_rle8_bitmap(bmp_image_t *img, int xoff, int yoff, 1285 int width, int height) 1286 { 1287 unsigned char *bm; 1288 unsigned char *fbp; 1289 unsigned int cnt, runlen; 1290 int decode = 1; 1291 int x, y, bpp, i, ncolors; 1292 struct palette p[256]; 1293 bmp_color_table_entry_t cte; 1294 int green_shift, red_off; 1295 int limit = VIDEO_COLS * VIDEO_ROWS; 1296 int pixels = 0; 1297 1298 x = 0; 1299 y = __le32_to_cpu(img->header.height) - 1; 1300 ncolors = __le32_to_cpu(img->header.colors_used); 1301 bpp = VIDEO_PIXEL_SIZE; 1302 fbp = (unsigned char *) ((unsigned int) video_fb_address + 1303 (((y + yoff) * VIDEO_COLS) + xoff) * bpp); 1304 1305 bm = (uchar *) img + __le32_to_cpu(img->header.data_offset); 1306 1307 /* pre-calculate and setup palette */ 1308 switch (VIDEO_DATA_FORMAT) { 1309 case GDF__8BIT_INDEX: 1310 for (i = 0; i < ncolors; i++) { 1311 cte = img->color_table[i]; 1312 video_set_lut(i, cte.red, cte.green, cte.blue); 1313 } 1314 break; 1315 case GDF_15BIT_555RGB: 1316 case GDF_16BIT_565RGB: 1317 if (VIDEO_DATA_FORMAT == GDF_15BIT_555RGB) { 1318 green_shift = 3; 1319 red_off = 10; 1320 } else { 1321 green_shift = 2; 1322 red_off = 11; 1323 } 1324 for (i = 0; i < ncolors; i++) { 1325 cte = img->color_table[i]; 1326 p[i].ce.w = SWAP16((unsigned short) 1327 (((cte.red >> 3) << red_off) | 1328 ((cte.green >> green_shift) << 5) | 1329 cte.blue >> 3)); 1330 } 1331 break; 1332 case GDF_32BIT_X888RGB: 1333 for (i = 0; i < ncolors; i++) { 1334 cte = img->color_table[i]; 1335 p[i].ce.dw = SWAP32((cte.red << 16) | 1336 (cte.green << 8) | 1337 cte.blue); 1338 } 1339 break; 1340 default: 1341 printf("RLE Bitmap unsupported in video mode 0x%x\n", 1342 VIDEO_DATA_FORMAT); 1343 return -1; 1344 } 1345 1346 while (decode) { 1347 switch (bm[0]) { 1348 case 0: 1349 switch (bm[1]) { 1350 case 0: 1351 /* scan line end marker */ 1352 bm += 2; 1353 x = 0; 1354 y--; 1355 fbp = (unsigned char *) 1356 ((unsigned int) video_fb_address + 1357 (((y + yoff) * VIDEO_COLS) + 1358 xoff) * bpp); 1359 continue; 1360 case 1: 1361 /* end of bitmap data marker */ 1362 decode = 0; 1363 break; 1364 case 2: 1365 /* run offset marker */ 1366 x += bm[2]; 1367 y -= bm[3]; 1368 fbp = (unsigned char *) 1369 ((unsigned int) video_fb_address + 1370 (((y + yoff) * VIDEO_COLS) + 1371 x + xoff) * bpp); 1372 bm += 4; 1373 break; 1374 default: 1375 /* unencoded run */ 1376 cnt = bm[1]; 1377 runlen = cnt; 1378 pixels += cnt; 1379 if (pixels > limit) 1380 goto error; 1381 1382 bm += 2; 1383 if (y < height) { 1384 if (x >= width) { 1385 x += runlen; 1386 goto next_run; 1387 } 1388 if (x + runlen > width) 1389 cnt = width - x; 1390 draw_bitmap(&fbp, bm, p, cnt, 0); 1391 x += runlen; 1392 } 1393 next_run: 1394 bm += runlen; 1395 if (runlen & 1) 1396 bm++; /* 0 padding if length is odd */ 1397 } 1398 break; 1399 default: 1400 /* encoded run */ 1401 cnt = bm[0]; 1402 runlen = cnt; 1403 pixels += cnt; 1404 if (pixels > limit) 1405 goto error; 1406 1407 if (y < height) { /* only draw into visible area */ 1408 if (x >= width) { 1409 x += runlen; 1410 bm += 2; 1411 continue; 1412 } 1413 if (x + runlen > width) 1414 cnt = width - x; 1415 draw_bitmap(&fbp, bm, p, cnt, 1); 1416 x += runlen; 1417 } 1418 bm += 2; 1419 break; 1420 } 1421 } 1422 return 0; 1423 error: 1424 printf("Error: Too much encoded pixel data, validate your bitmap\n"); 1425 return -1; 1426 } 1427 #endif 1428 1429 /* 1430 * Display the BMP file located at address bmp_image. 1431 */ 1432 int video_display_bitmap(ulong bmp_image, int x, int y) 1433 { 1434 ushort xcount, ycount; 1435 uchar *fb; 1436 bmp_image_t *bmp = (bmp_image_t *) bmp_image; 1437 uchar *bmap; 1438 ushort padded_line; 1439 unsigned long width, height, bpp; 1440 unsigned colors; 1441 unsigned long compression; 1442 bmp_color_table_entry_t cte; 1443 1444 #ifdef CONFIG_VIDEO_BMP_GZIP 1445 unsigned char *dst = NULL; 1446 ulong len; 1447 #endif 1448 1449 WATCHDOG_RESET(); 1450 1451 if (!((bmp->header.signature[0] == 'B') && 1452 (bmp->header.signature[1] == 'M'))) { 1453 1454 #ifdef CONFIG_VIDEO_BMP_GZIP 1455 /* 1456 * Could be a gzipped bmp image, try to decrompress... 1457 */ 1458 len = CONFIG_SYS_VIDEO_LOGO_MAX_SIZE; 1459 dst = malloc(CONFIG_SYS_VIDEO_LOGO_MAX_SIZE); 1460 if (dst == NULL) { 1461 printf("Error: malloc in gunzip failed!\n"); 1462 return 1; 1463 } 1464 if (gunzip(dst, CONFIG_SYS_VIDEO_LOGO_MAX_SIZE, 1465 (uchar *) bmp_image, 1466 &len) != 0) { 1467 printf("Error: no valid bmp or bmp.gz image at %lx\n", 1468 bmp_image); 1469 free(dst); 1470 return 1; 1471 } 1472 if (len == CONFIG_SYS_VIDEO_LOGO_MAX_SIZE) { 1473 printf("Image could be truncated " 1474 "(increase CONFIG_SYS_VIDEO_LOGO_MAX_SIZE)!\n"); 1475 } 1476 1477 /* 1478 * Set addr to decompressed image 1479 */ 1480 bmp = (bmp_image_t *) dst; 1481 1482 if (!((bmp->header.signature[0] == 'B') && 1483 (bmp->header.signature[1] == 'M'))) { 1484 printf("Error: no valid bmp.gz image at %lx\n", 1485 bmp_image); 1486 free(dst); 1487 return 1; 1488 } 1489 #else 1490 printf("Error: no valid bmp image at %lx\n", bmp_image); 1491 return 1; 1492 #endif /* CONFIG_VIDEO_BMP_GZIP */ 1493 } 1494 1495 width = le32_to_cpu(bmp->header.width); 1496 height = le32_to_cpu(bmp->header.height); 1497 bpp = le16_to_cpu(bmp->header.bit_count); 1498 colors = le32_to_cpu(bmp->header.colors_used); 1499 compression = le32_to_cpu(bmp->header.compression); 1500 1501 debug("Display-bmp: %ld x %ld with %d colors\n", 1502 width, height, colors); 1503 1504 if (compression != BMP_BI_RGB 1505 #ifdef CONFIG_VIDEO_BMP_RLE8 1506 && compression != BMP_BI_RLE8 1507 #endif 1508 ) { 1509 printf("Error: compression type %ld not supported\n", 1510 compression); 1511 #ifdef CONFIG_VIDEO_BMP_GZIP 1512 if (dst) 1513 free(dst); 1514 #endif 1515 return 1; 1516 } 1517 1518 padded_line = (((width * bpp + 7) / 8) + 3) & ~0x3; 1519 1520 #ifdef CONFIG_SPLASH_SCREEN_ALIGN 1521 if (x == BMP_ALIGN_CENTER) 1522 x = max(0, (VIDEO_VISIBLE_COLS - width) / 2); 1523 else if (x < 0) 1524 x = max(0, VIDEO_VISIBLE_COLS - width + x + 1); 1525 1526 if (y == BMP_ALIGN_CENTER) 1527 y = max(0, (VIDEO_VISIBLE_ROWS - height) / 2); 1528 else if (y < 0) 1529 y = max(0, VIDEO_VISIBLE_ROWS - height + y + 1); 1530 #endif /* CONFIG_SPLASH_SCREEN_ALIGN */ 1531 1532 /* 1533 * Just ignore elements which are completely beyond screen 1534 * dimensions. 1535 */ 1536 if ((x >= VIDEO_VISIBLE_COLS) || (y >= VIDEO_VISIBLE_ROWS)) 1537 return 0; 1538 1539 if ((x + width) > VIDEO_VISIBLE_COLS) 1540 width = VIDEO_VISIBLE_COLS - x; 1541 if ((y + height) > VIDEO_VISIBLE_ROWS) 1542 height = VIDEO_VISIBLE_ROWS - y; 1543 1544 bmap = (uchar *) bmp + le32_to_cpu(bmp->header.data_offset); 1545 fb = (uchar *) (video_fb_address + 1546 ((y + height - 1) * VIDEO_COLS * VIDEO_PIXEL_SIZE) + 1547 x * VIDEO_PIXEL_SIZE); 1548 1549 #ifdef CONFIG_VIDEO_BMP_RLE8 1550 if (compression == BMP_BI_RLE8) { 1551 return display_rle8_bitmap(bmp, x, y, width, height); 1552 } 1553 #endif 1554 1555 /* We handle only 4, 8, or 24 bpp bitmaps */ 1556 switch (le16_to_cpu(bmp->header.bit_count)) { 1557 case 4: 1558 padded_line -= width / 2; 1559 ycount = height; 1560 1561 switch (VIDEO_DATA_FORMAT) { 1562 case GDF_32BIT_X888RGB: 1563 while (ycount--) { 1564 WATCHDOG_RESET(); 1565 /* 1566 * Don't assume that 'width' is an 1567 * even number 1568 */ 1569 for (xcount = 0; xcount < width; xcount++) { 1570 uchar idx; 1571 1572 if (xcount & 1) { 1573 idx = *bmap & 0xF; 1574 bmap++; 1575 } else 1576 idx = *bmap >> 4; 1577 cte = bmp->color_table[idx]; 1578 FILL_32BIT_X888RGB(cte.red, cte.green, 1579 cte.blue); 1580 } 1581 bmap += padded_line; 1582 fb -= (VIDEO_VISIBLE_COLS + width) * 1583 VIDEO_PIXEL_SIZE; 1584 } 1585 break; 1586 default: 1587 puts("4bpp bitmap unsupported with current " 1588 "video mode\n"); 1589 break; 1590 } 1591 break; 1592 1593 case 8: 1594 padded_line -= width; 1595 if (VIDEO_DATA_FORMAT == GDF__8BIT_INDEX) { 1596 /* Copy colormap */ 1597 for (xcount = 0; xcount < colors; ++xcount) { 1598 cte = bmp->color_table[xcount]; 1599 video_set_lut(xcount, cte.red, cte.green, 1600 cte.blue); 1601 } 1602 } 1603 ycount = height; 1604 switch (VIDEO_DATA_FORMAT) { 1605 case GDF__8BIT_INDEX: 1606 while (ycount--) { 1607 WATCHDOG_RESET(); 1608 xcount = width; 1609 while (xcount--) { 1610 *fb++ = *bmap++; 1611 } 1612 bmap += padded_line; 1613 fb -= (VIDEO_VISIBLE_COLS + width) * 1614 VIDEO_PIXEL_SIZE; 1615 } 1616 break; 1617 case GDF__8BIT_332RGB: 1618 while (ycount--) { 1619 WATCHDOG_RESET(); 1620 xcount = width; 1621 while (xcount--) { 1622 cte = bmp->color_table[*bmap++]; 1623 FILL_8BIT_332RGB(cte.red, cte.green, 1624 cte.blue); 1625 } 1626 bmap += padded_line; 1627 fb -= (VIDEO_VISIBLE_COLS + width) * 1628 VIDEO_PIXEL_SIZE; 1629 } 1630 break; 1631 case GDF_15BIT_555RGB: 1632 while (ycount--) { 1633 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 1634 int xpos = x; 1635 #endif 1636 WATCHDOG_RESET(); 1637 xcount = width; 1638 while (xcount--) { 1639 cte = bmp->color_table[*bmap++]; 1640 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 1641 fill_555rgb_pswap(fb, xpos++, cte.red, 1642 cte.green, 1643 cte.blue); 1644 fb += 2; 1645 #else 1646 FILL_15BIT_555RGB(cte.red, cte.green, 1647 cte.blue); 1648 #endif 1649 } 1650 bmap += padded_line; 1651 fb -= (VIDEO_VISIBLE_COLS + width) * 1652 VIDEO_PIXEL_SIZE; 1653 } 1654 break; 1655 case GDF_16BIT_565RGB: 1656 while (ycount--) { 1657 WATCHDOG_RESET(); 1658 xcount = width; 1659 while (xcount--) { 1660 cte = bmp->color_table[*bmap++]; 1661 FILL_16BIT_565RGB(cte.red, cte.green, 1662 cte.blue); 1663 } 1664 bmap += padded_line; 1665 fb -= (VIDEO_VISIBLE_COLS + width) * 1666 VIDEO_PIXEL_SIZE; 1667 } 1668 break; 1669 case GDF_32BIT_X888RGB: 1670 while (ycount--) { 1671 WATCHDOG_RESET(); 1672 xcount = width; 1673 while (xcount--) { 1674 cte = bmp->color_table[*bmap++]; 1675 FILL_32BIT_X888RGB(cte.red, cte.green, 1676 cte.blue); 1677 } 1678 bmap += padded_line; 1679 fb -= (VIDEO_VISIBLE_COLS + width) * 1680 VIDEO_PIXEL_SIZE; 1681 } 1682 break; 1683 case GDF_24BIT_888RGB: 1684 while (ycount--) { 1685 WATCHDOG_RESET(); 1686 xcount = width; 1687 while (xcount--) { 1688 cte = bmp->color_table[*bmap++]; 1689 FILL_24BIT_888RGB(cte.red, cte.green, 1690 cte.blue); 1691 } 1692 bmap += padded_line; 1693 fb -= (VIDEO_VISIBLE_COLS + width) * 1694 VIDEO_PIXEL_SIZE; 1695 } 1696 break; 1697 } 1698 break; 1699 case 24: 1700 padded_line -= 3 * width; 1701 ycount = height; 1702 switch (VIDEO_DATA_FORMAT) { 1703 case GDF__8BIT_332RGB: 1704 while (ycount--) { 1705 WATCHDOG_RESET(); 1706 xcount = width; 1707 while (xcount--) { 1708 FILL_8BIT_332RGB(bmap[2], bmap[1], 1709 bmap[0]); 1710 bmap += 3; 1711 } 1712 bmap += padded_line; 1713 fb -= (VIDEO_VISIBLE_COLS + width) * 1714 VIDEO_PIXEL_SIZE; 1715 } 1716 break; 1717 case GDF_15BIT_555RGB: 1718 while (ycount--) { 1719 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 1720 int xpos = x; 1721 #endif 1722 WATCHDOG_RESET(); 1723 xcount = width; 1724 while (xcount--) { 1725 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 1726 fill_555rgb_pswap(fb, xpos++, bmap[2], 1727 bmap[1], bmap[0]); 1728 fb += 2; 1729 #else 1730 FILL_15BIT_555RGB(bmap[2], bmap[1], 1731 bmap[0]); 1732 #endif 1733 bmap += 3; 1734 } 1735 bmap += padded_line; 1736 fb -= (VIDEO_VISIBLE_COLS + width) * 1737 VIDEO_PIXEL_SIZE; 1738 } 1739 break; 1740 case GDF_16BIT_565RGB: 1741 while (ycount--) { 1742 WATCHDOG_RESET(); 1743 xcount = width; 1744 while (xcount--) { 1745 FILL_16BIT_565RGB(bmap[2], bmap[1], 1746 bmap[0]); 1747 bmap += 3; 1748 } 1749 bmap += padded_line; 1750 fb -= (VIDEO_VISIBLE_COLS + width) * 1751 VIDEO_PIXEL_SIZE; 1752 } 1753 break; 1754 case GDF_32BIT_X888RGB: 1755 while (ycount--) { 1756 WATCHDOG_RESET(); 1757 xcount = width; 1758 while (xcount--) { 1759 FILL_32BIT_X888RGB(bmap[2], bmap[1], 1760 bmap[0]); 1761 bmap += 3; 1762 } 1763 bmap += padded_line; 1764 fb -= (VIDEO_VISIBLE_COLS + width) * 1765 VIDEO_PIXEL_SIZE; 1766 } 1767 break; 1768 case GDF_24BIT_888RGB: 1769 while (ycount--) { 1770 WATCHDOG_RESET(); 1771 xcount = width; 1772 while (xcount--) { 1773 FILL_24BIT_888RGB(bmap[2], bmap[1], 1774 bmap[0]); 1775 bmap += 3; 1776 } 1777 bmap += padded_line; 1778 fb -= (VIDEO_VISIBLE_COLS + width) * 1779 VIDEO_PIXEL_SIZE; 1780 } 1781 break; 1782 default: 1783 printf("Error: 24 bits/pixel bitmap incompatible " 1784 "with current video mode\n"); 1785 break; 1786 } 1787 break; 1788 default: 1789 printf("Error: %d bit/pixel bitmaps not supported by U-Boot\n", 1790 le16_to_cpu(bmp->header.bit_count)); 1791 break; 1792 } 1793 1794 #ifdef CONFIG_VIDEO_BMP_GZIP 1795 if (dst) { 1796 free(dst); 1797 } 1798 #endif 1799 1800 if (cfb_do_flush_cache) 1801 flush_cache(VIDEO_FB_ADRS, VIDEO_SIZE); 1802 return (0); 1803 } 1804 #endif 1805 1806 1807 #ifdef CONFIG_VIDEO_LOGO 1808 static int video_logo_xpos; 1809 static int video_logo_ypos; 1810 1811 static void plot_logo_or_black(void *screen, int width, int x, int y, \ 1812 int black); 1813 1814 static void logo_plot(void *screen, int width, int x, int y) 1815 { 1816 plot_logo_or_black(screen, width, x, y, 0); 1817 } 1818 1819 static void logo_black(void) 1820 { 1821 plot_logo_or_black(video_fb_address, \ 1822 VIDEO_COLS, \ 1823 video_logo_xpos, \ 1824 video_logo_ypos, \ 1825 1); 1826 } 1827 1828 static int do_clrlogo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) 1829 { 1830 if (argc != 1) 1831 return cmd_usage(cmdtp); 1832 1833 logo_black(); 1834 return 0; 1835 } 1836 1837 U_BOOT_CMD( 1838 clrlogo, 1, 0, do_clrlogo, 1839 "fill the boot logo area with black", 1840 " " 1841 ); 1842 1843 static void plot_logo_or_black(void *screen, int width, int x, int y, int black) 1844 { 1845 1846 int xcount, i; 1847 int skip = (width - VIDEO_LOGO_WIDTH) * VIDEO_PIXEL_SIZE; 1848 int ycount = video_logo_height; 1849 unsigned char r, g, b, *logo_red, *logo_blue, *logo_green; 1850 unsigned char *source; 1851 unsigned char *dest; 1852 1853 #ifdef CONFIG_SPLASH_SCREEN_ALIGN 1854 if (x == BMP_ALIGN_CENTER) 1855 x = max(0, (VIDEO_VISIBLE_COLS - VIDEO_LOGO_WIDTH) / 2); 1856 else if (x < 0) 1857 x = max(0, VIDEO_VISIBLE_COLS - VIDEO_LOGO_WIDTH + x + 1); 1858 1859 if (y == BMP_ALIGN_CENTER) 1860 y = max(0, (VIDEO_VISIBLE_ROWS - VIDEO_LOGO_HEIGHT) / 2); 1861 else if (y < 0) 1862 y = max(0, VIDEO_VISIBLE_ROWS - VIDEO_LOGO_HEIGHT + y + 1); 1863 #endif /* CONFIG_SPLASH_SCREEN_ALIGN */ 1864 1865 dest = (unsigned char *)screen + (y * width + x) * VIDEO_PIXEL_SIZE; 1866 1867 #ifdef CONFIG_VIDEO_BMP_LOGO 1868 source = bmp_logo_bitmap; 1869 1870 /* Allocate temporary space for computing colormap */ 1871 logo_red = malloc(BMP_LOGO_COLORS); 1872 logo_green = malloc(BMP_LOGO_COLORS); 1873 logo_blue = malloc(BMP_LOGO_COLORS); 1874 /* Compute color map */ 1875 for (i = 0; i < VIDEO_LOGO_COLORS; i++) { 1876 logo_red[i] = (bmp_logo_palette[i] & 0x0f00) >> 4; 1877 logo_green[i] = (bmp_logo_palette[i] & 0x00f0); 1878 logo_blue[i] = (bmp_logo_palette[i] & 0x000f) << 4; 1879 } 1880 #else 1881 source = linux_logo; 1882 logo_red = linux_logo_red; 1883 logo_green = linux_logo_green; 1884 logo_blue = linux_logo_blue; 1885 #endif 1886 1887 if (VIDEO_DATA_FORMAT == GDF__8BIT_INDEX) { 1888 for (i = 0; i < VIDEO_LOGO_COLORS; i++) { 1889 video_set_lut(i + VIDEO_LOGO_LUT_OFFSET, 1890 logo_red[i], logo_green[i], 1891 logo_blue[i]); 1892 } 1893 } 1894 1895 while (ycount--) { 1896 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 1897 int xpos = x; 1898 #endif 1899 xcount = VIDEO_LOGO_WIDTH; 1900 while (xcount--) { 1901 if (black) { 1902 r = 0x00; 1903 g = 0x00; 1904 b = 0x00; 1905 } else { 1906 r = logo_red[*source - VIDEO_LOGO_LUT_OFFSET]; 1907 g = logo_green[*source - VIDEO_LOGO_LUT_OFFSET]; 1908 b = logo_blue[*source - VIDEO_LOGO_LUT_OFFSET]; 1909 } 1910 1911 switch (VIDEO_DATA_FORMAT) { 1912 case GDF__8BIT_INDEX: 1913 *dest = *source; 1914 break; 1915 case GDF__8BIT_332RGB: 1916 *dest = ((r >> 5) << 5) | 1917 ((g >> 5) << 2) | 1918 (b >> 6); 1919 break; 1920 case GDF_15BIT_555RGB: 1921 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 1922 fill_555rgb_pswap(dest, xpos++, r, g, b); 1923 #else 1924 *(unsigned short *) dest = 1925 SWAP16((unsigned short) ( 1926 ((r >> 3) << 10) | 1927 ((g >> 3) << 5) | 1928 (b >> 3))); 1929 #endif 1930 break; 1931 case GDF_16BIT_565RGB: 1932 *(unsigned short *) dest = 1933 SWAP16((unsigned short) ( 1934 ((r >> 3) << 11) | 1935 ((g >> 2) << 5) | 1936 (b >> 3))); 1937 break; 1938 case GDF_32BIT_X888RGB: 1939 *(unsigned long *) dest = 1940 SWAP32((unsigned long) ( 1941 (r << 16) | 1942 (g << 8) | 1943 b)); 1944 break; 1945 case GDF_24BIT_888RGB: 1946 #ifdef VIDEO_FB_LITTLE_ENDIAN 1947 dest[0] = b; 1948 dest[1] = g; 1949 dest[2] = r; 1950 #else 1951 dest[0] = r; 1952 dest[1] = g; 1953 dest[2] = b; 1954 #endif 1955 break; 1956 } 1957 source++; 1958 dest += VIDEO_PIXEL_SIZE; 1959 } 1960 dest += skip; 1961 } 1962 #ifdef CONFIG_VIDEO_BMP_LOGO 1963 free(logo_red); 1964 free(logo_green); 1965 free(logo_blue); 1966 #endif 1967 } 1968 1969 static void *video_logo(void) 1970 { 1971 char info[128]; 1972 int space, len; 1973 __maybe_unused int y_off = 0; 1974 __maybe_unused ulong addr; 1975 __maybe_unused char *s; 1976 1977 #ifdef CONFIG_SPLASH_SCREEN_ALIGN 1978 s = getenv("splashpos"); 1979 if (s != NULL) { 1980 if (s[0] == 'm') 1981 video_logo_xpos = BMP_ALIGN_CENTER; 1982 else 1983 video_logo_xpos = simple_strtol(s, NULL, 0); 1984 1985 s = strchr(s + 1, ','); 1986 if (s != NULL) { 1987 if (s[1] == 'm') 1988 video_logo_ypos = BMP_ALIGN_CENTER; 1989 else 1990 video_logo_ypos = simple_strtol(s + 1, NULL, 0); 1991 } 1992 } 1993 #endif /* CONFIG_SPLASH_SCREEN_ALIGN */ 1994 1995 #ifdef CONFIG_SPLASH_SCREEN 1996 s = getenv("splashimage"); 1997 if (s != NULL) { 1998 1999 addr = simple_strtoul(s, NULL, 16); 2000 2001 2002 if (video_display_bitmap(addr, 2003 video_logo_xpos, 2004 video_logo_ypos) == 0) { 2005 video_logo_height = 0; 2006 return ((void *) (video_fb_address)); 2007 } 2008 } 2009 #endif /* CONFIG_SPLASH_SCREEN */ 2010 2011 logo_plot(video_fb_address, VIDEO_COLS, 2012 video_logo_xpos, video_logo_ypos); 2013 2014 #ifdef CONFIG_SPLASH_SCREEN_ALIGN 2015 /* 2016 * when using splashpos for video_logo, skip any info 2017 * output on video console if the logo is not at 0,0 2018 */ 2019 if (video_logo_xpos || video_logo_ypos) { 2020 /* 2021 * video_logo_height is used in text and cursor offset 2022 * calculations. Since the console is below the logo, 2023 * we need to adjust the logo height 2024 */ 2025 if (video_logo_ypos == BMP_ALIGN_CENTER) 2026 video_logo_height += max(0, (VIDEO_VISIBLE_ROWS - \ 2027 VIDEO_LOGO_HEIGHT) / 2); 2028 else if (video_logo_ypos > 0) 2029 video_logo_height += video_logo_ypos; 2030 2031 return video_fb_address + video_logo_height * VIDEO_LINE_LEN; 2032 } 2033 #endif 2034 2035 sprintf(info, " %s", version_string); 2036 2037 space = (VIDEO_LINE_LEN / 2 - VIDEO_INFO_X) / VIDEO_FONT_WIDTH; 2038 len = strlen(info); 2039 2040 if (len > space) { 2041 video_drawchars(VIDEO_INFO_X, VIDEO_INFO_Y, 2042 (uchar *) info, space); 2043 video_drawchars(VIDEO_INFO_X + VIDEO_FONT_WIDTH, 2044 VIDEO_INFO_Y + VIDEO_FONT_HEIGHT, 2045 (uchar *) info + space, len - space); 2046 y_off = 1; 2047 } else 2048 video_drawstring(VIDEO_INFO_X, VIDEO_INFO_Y, (uchar *) info); 2049 2050 #ifdef CONFIG_CONSOLE_EXTRA_INFO 2051 { 2052 int i, n = 2053 ((video_logo_height - 2054 VIDEO_FONT_HEIGHT) / VIDEO_FONT_HEIGHT); 2055 2056 for (i = 1; i < n; i++) { 2057 video_get_info_str(i, info); 2058 if (!*info) 2059 continue; 2060 2061 len = strlen(info); 2062 if (len > space) { 2063 video_drawchars(VIDEO_INFO_X, 2064 VIDEO_INFO_Y + 2065 (i + y_off) * 2066 VIDEO_FONT_HEIGHT, 2067 (uchar *) info, space); 2068 y_off++; 2069 video_drawchars(VIDEO_INFO_X + 2070 VIDEO_FONT_WIDTH, 2071 VIDEO_INFO_Y + 2072 (i + y_off) * 2073 VIDEO_FONT_HEIGHT, 2074 (uchar *) info + space, 2075 len - space); 2076 } else { 2077 video_drawstring(VIDEO_INFO_X, 2078 VIDEO_INFO_Y + 2079 (i + y_off) * 2080 VIDEO_FONT_HEIGHT, 2081 (uchar *) info); 2082 } 2083 } 2084 } 2085 #endif 2086 2087 return (video_fb_address + video_logo_height * VIDEO_LINE_LEN); 2088 } 2089 #endif 2090 2091 static int cfb_fb_is_in_dram(void) 2092 { 2093 bd_t *bd = gd->bd; 2094 #if defined(CONFIG_ARM) || defined(CONFIG_AVR32) || defined(COFNIG_NDS32) || \ 2095 defined(CONFIG_SANDBOX) || defined(CONFIG_X86) 2096 ulong start, end; 2097 int i; 2098 2099 for (i = 0; i < CONFIG_NR_DRAM_BANKS; ++i) { 2100 start = bd->bi_dram[i].start; 2101 end = bd->bi_dram[i].start + bd->bi_dram[i].size - 1; 2102 if ((ulong)video_fb_address >= start && 2103 (ulong)video_fb_address < end) 2104 return 1; 2105 } 2106 #else 2107 if ((ulong)video_fb_address >= bd->bi_memstart && 2108 (ulong)video_fb_address < bd->bi_memstart + bd->bi_memsize) 2109 return 1; 2110 #endif 2111 return 0; 2112 } 2113 2114 static int video_init(void) 2115 { 2116 unsigned char color8; 2117 2118 pGD = video_hw_init(); 2119 if (pGD == NULL) 2120 return -1; 2121 2122 video_fb_address = (void *) VIDEO_FB_ADRS; 2123 #ifdef CONFIG_VIDEO_HW_CURSOR 2124 video_init_hw_cursor(VIDEO_FONT_WIDTH, VIDEO_FONT_HEIGHT); 2125 #endif 2126 2127 cfb_do_flush_cache = cfb_fb_is_in_dram() && dcache_status(); 2128 2129 /* Init drawing pats */ 2130 switch (VIDEO_DATA_FORMAT) { 2131 case GDF__8BIT_INDEX: 2132 video_set_lut(0x01, CONSOLE_FG_COL, CONSOLE_FG_COL, 2133 CONSOLE_FG_COL); 2134 video_set_lut(0x00, CONSOLE_BG_COL, CONSOLE_BG_COL, 2135 CONSOLE_BG_COL); 2136 fgx = 0x01010101; 2137 bgx = 0x00000000; 2138 break; 2139 case GDF__8BIT_332RGB: 2140 color8 = ((CONSOLE_FG_COL & 0xe0) | 2141 ((CONSOLE_FG_COL >> 3) & 0x1c) | 2142 CONSOLE_FG_COL >> 6); 2143 fgx = (color8 << 24) | (color8 << 16) | (color8 << 8) | 2144 color8; 2145 color8 = ((CONSOLE_BG_COL & 0xe0) | 2146 ((CONSOLE_BG_COL >> 3) & 0x1c) | 2147 CONSOLE_BG_COL >> 6); 2148 bgx = (color8 << 24) | (color8 << 16) | (color8 << 8) | 2149 color8; 2150 break; 2151 case GDF_15BIT_555RGB: 2152 fgx = (((CONSOLE_FG_COL >> 3) << 26) | 2153 ((CONSOLE_FG_COL >> 3) << 21) | 2154 ((CONSOLE_FG_COL >> 3) << 16) | 2155 ((CONSOLE_FG_COL >> 3) << 10) | 2156 ((CONSOLE_FG_COL >> 3) << 5) | 2157 (CONSOLE_FG_COL >> 3)); 2158 bgx = (((CONSOLE_BG_COL >> 3) << 26) | 2159 ((CONSOLE_BG_COL >> 3) << 21) | 2160 ((CONSOLE_BG_COL >> 3) << 16) | 2161 ((CONSOLE_BG_COL >> 3) << 10) | 2162 ((CONSOLE_BG_COL >> 3) << 5) | 2163 (CONSOLE_BG_COL >> 3)); 2164 break; 2165 case GDF_16BIT_565RGB: 2166 fgx = (((CONSOLE_FG_COL >> 3) << 27) | 2167 ((CONSOLE_FG_COL >> 2) << 21) | 2168 ((CONSOLE_FG_COL >> 3) << 16) | 2169 ((CONSOLE_FG_COL >> 3) << 11) | 2170 ((CONSOLE_FG_COL >> 2) << 5) | 2171 (CONSOLE_FG_COL >> 3)); 2172 bgx = (((CONSOLE_BG_COL >> 3) << 27) | 2173 ((CONSOLE_BG_COL >> 2) << 21) | 2174 ((CONSOLE_BG_COL >> 3) << 16) | 2175 ((CONSOLE_BG_COL >> 3) << 11) | 2176 ((CONSOLE_BG_COL >> 2) << 5) | 2177 (CONSOLE_BG_COL >> 3)); 2178 break; 2179 case GDF_32BIT_X888RGB: 2180 fgx = (CONSOLE_FG_COL << 16) | 2181 (CONSOLE_FG_COL << 8) | 2182 CONSOLE_FG_COL; 2183 bgx = (CONSOLE_BG_COL << 16) | 2184 (CONSOLE_BG_COL << 8) | 2185 CONSOLE_BG_COL; 2186 break; 2187 case GDF_24BIT_888RGB: 2188 fgx = (CONSOLE_FG_COL << 24) | 2189 (CONSOLE_FG_COL << 16) | 2190 (CONSOLE_FG_COL << 8) | 2191 CONSOLE_FG_COL; 2192 bgx = (CONSOLE_BG_COL << 24) | 2193 (CONSOLE_BG_COL << 16) | 2194 (CONSOLE_BG_COL << 8) | 2195 CONSOLE_BG_COL; 2196 break; 2197 } 2198 eorx = fgx ^ bgx; 2199 2200 #ifdef CONFIG_VIDEO_LOGO 2201 /* Plot the logo and get start point of console */ 2202 debug("Video: Drawing the logo ...\n"); 2203 video_console_address = video_logo(); 2204 #else 2205 video_console_address = video_fb_address; 2206 #endif 2207 2208 /* Initialize the console */ 2209 console_col = 0; 2210 console_row = 0; 2211 2212 if (cfb_do_flush_cache) 2213 flush_cache(VIDEO_FB_ADRS, VIDEO_SIZE); 2214 2215 return 0; 2216 } 2217 2218 /* 2219 * Implement a weak default function for boards that optionally 2220 * need to skip the video initialization. 2221 */ 2222 int __board_video_skip(void) 2223 { 2224 /* As default, don't skip test */ 2225 return 0; 2226 } 2227 2228 int board_video_skip(void) 2229 __attribute__ ((weak, alias("__board_video_skip"))); 2230 2231 int drv_video_init(void) 2232 { 2233 int skip_dev_init; 2234 struct stdio_dev console_dev; 2235 2236 /* Check if video initialization should be skipped */ 2237 if (board_video_skip()) 2238 return 0; 2239 2240 /* Init video chip - returns with framebuffer cleared */ 2241 skip_dev_init = (video_init() == -1); 2242 2243 #if !defined(CONFIG_VGA_AS_SINGLE_DEVICE) 2244 debug("KBD: Keyboard init ...\n"); 2245 skip_dev_init |= (VIDEO_KBD_INIT_FCT == -1); 2246 #endif 2247 2248 if (skip_dev_init) 2249 return 0; 2250 2251 /* Init vga device */ 2252 memset(&console_dev, 0, sizeof(console_dev)); 2253 strcpy(console_dev.name, "vga"); 2254 console_dev.ext = DEV_EXT_VIDEO; /* Video extensions */ 2255 console_dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_SYSTEM; 2256 console_dev.putc = video_putc; /* 'putc' function */ 2257 console_dev.puts = video_puts; /* 'puts' function */ 2258 console_dev.tstc = NULL; /* 'tstc' function */ 2259 console_dev.getc = NULL; /* 'getc' function */ 2260 2261 #if !defined(CONFIG_VGA_AS_SINGLE_DEVICE) 2262 /* Also init console device */ 2263 console_dev.flags |= DEV_FLAGS_INPUT; 2264 console_dev.tstc = VIDEO_TSTC_FCT; /* 'tstc' function */ 2265 console_dev.getc = VIDEO_GETC_FCT; /* 'getc' function */ 2266 #endif /* CONFIG_VGA_AS_SINGLE_DEVICE */ 2267 2268 if (stdio_register(&console_dev) != 0) 2269 return 0; 2270 2271 /* Return success */ 2272 return 1; 2273 } 2274 2275 void video_position_cursor(unsigned col, unsigned row) 2276 { 2277 console_col = min(col, CONSOLE_COLS - 1); 2278 console_row = min(row, CONSOLE_ROWS - 1); 2279 } 2280 2281 int video_get_pixel_width(void) 2282 { 2283 return VIDEO_VISIBLE_COLS; 2284 } 2285 2286 int video_get_pixel_height(void) 2287 { 2288 return VIDEO_VISIBLE_ROWS; 2289 } 2290 2291 int video_get_screen_rows(void) 2292 { 2293 return CONSOLE_ROWS; 2294 } 2295 2296 int video_get_screen_columns(void) 2297 { 2298 return CONSOLE_COLS; 2299 } 2300 2301 void video_clear(void) 2302 { 2303 if (!video_fb_address) 2304 return; 2305 #ifdef VIDEO_HW_RECTFILL 2306 video_hw_rectfill(VIDEO_PIXEL_SIZE, /* bytes per pixel */ 2307 0, /* dest pos x */ 2308 0, /* dest pos y */ 2309 VIDEO_VISIBLE_COLS, /* frame width */ 2310 VIDEO_VISIBLE_ROWS, /* frame height */ 2311 bgx /* fill color */ 2312 ); 2313 #else 2314 memsetl(video_fb_address, 2315 (VIDEO_VISIBLE_ROWS * VIDEO_LINE_LEN) / sizeof(int), bgx); 2316 #endif 2317 } 2318