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 if (cfb_do_flush_cache) 576 flush_cache((ulong)dest0, 32); 577 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE; 578 s++; 579 } 580 break; 581 582 case GDF_24BIT_888RGB: 583 while (count--) { 584 c = *s; 585 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT; 586 for (rows = VIDEO_FONT_HEIGHT, dest = dest0; 587 rows--; dest += VIDEO_LINE_LEN) { 588 u8 bits = *cdat++; 589 590 ((u32 *) dest)[0] = 591 (video_font_draw_table24[bits >> 4][0] 592 & eorx) ^ bgx; 593 ((u32 *) dest)[1] = 594 (video_font_draw_table24[bits >> 4][1] 595 & eorx) ^ bgx; 596 ((u32 *) dest)[2] = 597 (video_font_draw_table24[bits >> 4][2] 598 & eorx) ^ bgx; 599 ((u32 *) dest)[3] = 600 (video_font_draw_table24[bits & 15][0] 601 & eorx) ^ bgx; 602 ((u32 *) dest)[4] = 603 (video_font_draw_table24[bits & 15][1] 604 & eorx) ^ bgx; 605 ((u32 *) dest)[5] = 606 (video_font_draw_table24[bits & 15][2] 607 & eorx) ^ bgx; 608 } 609 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE; 610 s++; 611 } 612 break; 613 } 614 } 615 616 static inline void video_drawstring(int xx, int yy, unsigned char *s) 617 { 618 video_drawchars(xx, yy, s, strlen((char *) s)); 619 } 620 621 static void video_putchar(int xx, int yy, unsigned char c) 622 { 623 video_drawchars(xx, yy + video_logo_height, &c, 1); 624 } 625 626 #if defined(CONFIG_CONSOLE_CURSOR) || defined(CONFIG_VIDEO_SW_CURSOR) 627 static void video_set_cursor(void) 628 { 629 if (cursor_state) 630 console_cursor(0); 631 console_cursor(1); 632 } 633 634 static void video_invertchar(int xx, int yy) 635 { 636 int firstx = xx * VIDEO_PIXEL_SIZE; 637 int lastx = (xx + VIDEO_FONT_WIDTH) * VIDEO_PIXEL_SIZE; 638 int firsty = yy * VIDEO_LINE_LEN; 639 int lasty = (yy + VIDEO_FONT_HEIGHT) * VIDEO_LINE_LEN; 640 int x, y; 641 for (y = firsty; y < lasty; y += VIDEO_LINE_LEN) { 642 for (x = firstx; x < lastx; x++) { 643 u8 *dest = (u8 *)(video_fb_address) + x + y; 644 *dest = ~*dest; 645 if (cfb_do_flush_cache) 646 flush_cache((ulong)dest, 4); 647 } 648 } 649 } 650 651 void console_cursor(int state) 652 { 653 #ifdef CONFIG_CONSOLE_TIME 654 struct rtc_time tm; 655 char info[16]; 656 657 /* time update only if cursor is on (faster scroll) */ 658 if (state) { 659 rtc_get(&tm); 660 661 sprintf(info, " %02d:%02d:%02d ", tm.tm_hour, tm.tm_min, 662 tm.tm_sec); 663 video_drawstring(VIDEO_VISIBLE_COLS - 10 * VIDEO_FONT_WIDTH, 664 VIDEO_INFO_Y, (uchar *) info); 665 666 sprintf(info, "%02d.%02d.%04d", tm.tm_mday, tm.tm_mon, 667 tm.tm_year); 668 video_drawstring(VIDEO_VISIBLE_COLS - 10 * VIDEO_FONT_WIDTH, 669 VIDEO_INFO_Y + 1 * VIDEO_FONT_HEIGHT, 670 (uchar *) info); 671 } 672 #endif 673 674 if (cursor_state != state) { 675 if (cursor_state) { 676 /* turn off the cursor */ 677 video_invertchar(old_col * VIDEO_FONT_WIDTH, 678 old_row * VIDEO_FONT_HEIGHT + 679 video_logo_height); 680 } else { 681 /* turn off the cursor and record where it is */ 682 video_invertchar(console_col * VIDEO_FONT_WIDTH, 683 console_row * VIDEO_FONT_HEIGHT + 684 video_logo_height); 685 old_col = console_col; 686 old_row = console_row; 687 } 688 cursor_state = state; 689 } 690 } 691 #endif 692 693 #ifndef VIDEO_HW_RECTFILL 694 static void memsetl(int *p, int c, int v) 695 { 696 while (c--) 697 *(p++) = v; 698 } 699 #endif 700 701 #ifndef VIDEO_HW_BITBLT 702 static void memcpyl(int *d, int *s, int c) 703 { 704 while (c--) 705 *(d++) = *(s++); 706 } 707 #endif 708 709 static void console_clear_line(int line, int begin, int end) 710 { 711 #ifdef VIDEO_HW_RECTFILL 712 video_hw_rectfill(VIDEO_PIXEL_SIZE, /* bytes per pixel */ 713 VIDEO_FONT_WIDTH * begin, /* dest pos x */ 714 video_logo_height + 715 VIDEO_FONT_HEIGHT * line, /* dest pos y */ 716 VIDEO_FONT_WIDTH * (end - begin + 1), /* fr. width */ 717 VIDEO_FONT_HEIGHT, /* frame height */ 718 bgx /* fill color */ 719 ); 720 #else 721 if (begin == 0 && (end + 1) == CONSOLE_COLS) { 722 memsetl(CONSOLE_ROW_FIRST + 723 CONSOLE_ROW_SIZE * line, /* offset of row */ 724 CONSOLE_ROW_SIZE >> 2, /* length of row */ 725 bgx /* fill color */ 726 ); 727 } else { 728 void *offset; 729 int i, size; 730 731 offset = CONSOLE_ROW_FIRST + 732 CONSOLE_ROW_SIZE * line + /* offset of row */ 733 VIDEO_FONT_WIDTH * 734 VIDEO_PIXEL_SIZE * begin; /* offset of col */ 735 size = VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE * (end - begin + 1); 736 size >>= 2; /* length to end for memsetl() */ 737 /* fill at col offset of i'th line using bgx as fill color */ 738 for (i = 0; i < VIDEO_FONT_HEIGHT; i++) 739 memsetl(offset + i * VIDEO_LINE_LEN, size, bgx); 740 } 741 #endif 742 if (cfb_do_flush_cache) 743 flush_cache((ulong)CONSOLE_ROW_FIRST, CONSOLE_SIZE); 744 } 745 746 static void console_scrollup(void) 747 { 748 /* copy up rows ignoring the first one */ 749 750 #ifdef VIDEO_HW_BITBLT 751 video_hw_bitblt(VIDEO_PIXEL_SIZE, /* bytes per pixel */ 752 0, /* source pos x */ 753 video_logo_height + 754 VIDEO_FONT_HEIGHT, /* source pos y */ 755 0, /* dest pos x */ 756 video_logo_height, /* dest pos y */ 757 VIDEO_VISIBLE_COLS, /* frame width */ 758 VIDEO_VISIBLE_ROWS 759 - video_logo_height 760 - VIDEO_FONT_HEIGHT /* frame height */ 761 ); 762 #else 763 memcpyl(CONSOLE_ROW_FIRST, CONSOLE_ROW_SECOND, 764 CONSOLE_SCROLL_SIZE >> 2); 765 #endif 766 /* clear the last one */ 767 console_clear_line(CONSOLE_ROWS - 1, 0, CONSOLE_COLS - 1); 768 } 769 770 static void console_back(void) 771 { 772 console_col--; 773 774 if (console_col < 0) { 775 console_col = CONSOLE_COLS - 1; 776 console_row--; 777 if (console_row < 0) 778 console_row = 0; 779 } 780 } 781 782 #ifdef CONFIG_CFB_CONSOLE_ANSI 783 784 static void console_clear(void) 785 { 786 #ifdef VIDEO_HW_RECTFILL 787 video_hw_rectfill(VIDEO_PIXEL_SIZE, /* bytes per pixel */ 788 0, /* dest pos x */ 789 video_logo_height, /* dest pos y */ 790 VIDEO_VISIBLE_COLS, /* frame width */ 791 VIDEO_VISIBLE_ROWS, /* frame height */ 792 bgx /* fill color */ 793 ); 794 #else 795 memsetl(CONSOLE_ROW_FIRST, CONSOLE_SIZE, bgx); 796 #endif 797 } 798 799 static void console_cursor_fix(void) 800 { 801 if (console_row < 0) 802 console_row = 0; 803 if (console_row >= CONSOLE_ROWS) 804 console_row = CONSOLE_ROWS - 1; 805 if (console_col < 0) 806 console_col = 0; 807 if (console_col >= CONSOLE_COLS) 808 console_col = CONSOLE_COLS - 1; 809 } 810 811 static void console_cursor_up(int n) 812 { 813 console_row -= n; 814 console_cursor_fix(); 815 } 816 817 static void console_cursor_down(int n) 818 { 819 console_row += n; 820 console_cursor_fix(); 821 } 822 823 static void console_cursor_left(int n) 824 { 825 console_col -= n; 826 console_cursor_fix(); 827 } 828 829 static void console_cursor_right(int n) 830 { 831 console_col += n; 832 console_cursor_fix(); 833 } 834 835 static void console_cursor_set_position(int row, int col) 836 { 837 if (console_row != -1) 838 console_row = row; 839 if (console_col != -1) 840 console_col = col; 841 console_cursor_fix(); 842 } 843 844 static void console_previousline(int n) 845 { 846 /* FIXME: also scroll terminal ? */ 847 console_row -= n; 848 console_cursor_fix(); 849 } 850 851 static void console_swap_colors(void) 852 { 853 eorx = fgx; 854 fgx = bgx; 855 bgx = eorx; 856 eorx = fgx ^ bgx; 857 } 858 859 static inline int console_cursor_is_visible(void) 860 { 861 return !ansi_cursor_hidden; 862 } 863 #else 864 static inline int console_cursor_is_visible(void) 865 { 866 return 1; 867 } 868 #endif 869 870 static void console_newline(int n) 871 { 872 console_row += n; 873 console_col = 0; 874 875 /* Check if we need to scroll the terminal */ 876 if (console_row >= CONSOLE_ROWS) { 877 /* Scroll everything up */ 878 console_scrollup(); 879 880 /* Decrement row number */ 881 console_row = CONSOLE_ROWS - 1; 882 } 883 } 884 885 static void console_cr(void) 886 { 887 console_col = 0; 888 } 889 890 static void parse_putc(const char c) 891 { 892 static int nl = 1; 893 894 if (console_cursor_is_visible()) 895 CURSOR_OFF; 896 897 switch (c) { 898 case 13: /* back to first column */ 899 console_cr(); 900 break; 901 902 case '\n': /* next line */ 903 if (console_col || (!console_col && nl)) 904 console_newline(1); 905 nl = 1; 906 break; 907 908 case 9: /* tab 8 */ 909 console_col |= 0x0008; 910 console_col &= ~0x0007; 911 912 if (console_col >= CONSOLE_COLS) 913 console_newline(1); 914 break; 915 916 case 8: /* backspace */ 917 console_back(); 918 break; 919 920 case 7: /* bell */ 921 break; /* ignored */ 922 923 default: /* draw the char */ 924 video_putchar(console_col * VIDEO_FONT_WIDTH, 925 console_row * VIDEO_FONT_HEIGHT, c); 926 console_col++; 927 928 /* check for newline */ 929 if (console_col >= CONSOLE_COLS) { 930 console_newline(1); 931 nl = 0; 932 } 933 } 934 935 if (console_cursor_is_visible()) 936 CURSOR_SET; 937 } 938 939 void video_putc(const char c) 940 { 941 #ifdef CONFIG_CFB_CONSOLE_ANSI 942 int i; 943 944 if (c == 27) { 945 for (i = 0; i < ansi_buf_size; ++i) 946 parse_putc(ansi_buf[i]); 947 ansi_buf[0] = 27; 948 ansi_buf_size = 1; 949 return; 950 } 951 952 if (ansi_buf_size > 0) { 953 /* 954 * 0 - ESC 955 * 1 - [ 956 * 2 - num1 957 * 3 - .. 958 * 4 - ; 959 * 5 - num2 960 * 6 - .. 961 * - cchar 962 */ 963 int next = 0; 964 965 int flush = 0; 966 int fail = 0; 967 968 int num1 = 0; 969 int num2 = 0; 970 int cchar = 0; 971 972 ansi_buf[ansi_buf_size++] = c; 973 974 if (ansi_buf_size >= sizeof(ansi_buf)) 975 fail = 1; 976 977 for (i = 0; i < ansi_buf_size; ++i) { 978 if (fail) 979 break; 980 981 switch (next) { 982 case 0: 983 if (ansi_buf[i] == 27) 984 next = 1; 985 else 986 fail = 1; 987 break; 988 989 case 1: 990 if (ansi_buf[i] == '[') 991 next = 2; 992 else 993 fail = 1; 994 break; 995 996 case 2: 997 if (ansi_buf[i] >= '0' && ansi_buf[i] <= '9') { 998 num1 = ansi_buf[i]-'0'; 999 next = 3; 1000 } else if (ansi_buf[i] != '?') { 1001 --i; 1002 num1 = 1; 1003 next = 4; 1004 } 1005 break; 1006 1007 case 3: 1008 if (ansi_buf[i] >= '0' && ansi_buf[i] <= '9') { 1009 num1 *= 10; 1010 num1 += ansi_buf[i]-'0'; 1011 } else { 1012 --i; 1013 next = 4; 1014 } 1015 break; 1016 1017 case 4: 1018 if (ansi_buf[i] != ';') { 1019 --i; 1020 next = 7; 1021 } else 1022 next = 5; 1023 break; 1024 1025 case 5: 1026 if (ansi_buf[i] >= '0' && ansi_buf[i] <= '9') { 1027 num2 = ansi_buf[i]-'0'; 1028 next = 6; 1029 } else 1030 fail = 1; 1031 break; 1032 1033 case 6: 1034 if (ansi_buf[i] >= '0' && ansi_buf[i] <= '9') { 1035 num2 *= 10; 1036 num2 += ansi_buf[i]-'0'; 1037 } else { 1038 --i; 1039 next = 7; 1040 } 1041 break; 1042 1043 case 7: 1044 if ((ansi_buf[i] >= 'A' && ansi_buf[i] <= 'H') 1045 || ansi_buf[i] == 'J' 1046 || ansi_buf[i] == 'K' 1047 || ansi_buf[i] == 'h' 1048 || ansi_buf[i] == 'l' 1049 || ansi_buf[i] == 'm') { 1050 cchar = ansi_buf[i]; 1051 flush = 1; 1052 } else 1053 fail = 1; 1054 break; 1055 } 1056 } 1057 1058 if (fail) { 1059 for (i = 0; i < ansi_buf_size; ++i) 1060 parse_putc(ansi_buf[i]); 1061 ansi_buf_size = 0; 1062 return; 1063 } 1064 1065 if (flush) { 1066 if (!ansi_cursor_hidden) 1067 CURSOR_OFF; 1068 ansi_buf_size = 0; 1069 switch (cchar) { 1070 case 'A': 1071 /* move cursor num1 rows up */ 1072 console_cursor_up(num1); 1073 break; 1074 case 'B': 1075 /* move cursor num1 rows down */ 1076 console_cursor_down(num1); 1077 break; 1078 case 'C': 1079 /* move cursor num1 columns forward */ 1080 console_cursor_right(num1); 1081 break; 1082 case 'D': 1083 /* move cursor num1 columns back */ 1084 console_cursor_left(num1); 1085 break; 1086 case 'E': 1087 /* move cursor num1 rows up at begin of row */ 1088 console_previousline(num1); 1089 break; 1090 case 'F': 1091 /* move cursor num1 rows down at begin of row */ 1092 console_newline(num1); 1093 break; 1094 case 'G': 1095 /* move cursor to column num1 */ 1096 console_cursor_set_position(-1, num1-1); 1097 break; 1098 case 'H': 1099 /* move cursor to row num1, column num2 */ 1100 console_cursor_set_position(num1-1, num2-1); 1101 break; 1102 case 'J': 1103 /* clear console and move cursor to 0, 0 */ 1104 console_clear(); 1105 console_cursor_set_position(0, 0); 1106 break; 1107 case 'K': 1108 /* clear line */ 1109 if (num1 == 0) 1110 console_clear_line(console_row, 1111 console_col, 1112 CONSOLE_COLS-1); 1113 else if (num1 == 1) 1114 console_clear_line(console_row, 1115 0, console_col); 1116 else 1117 console_clear_line(console_row, 1118 0, CONSOLE_COLS-1); 1119 break; 1120 case 'h': 1121 ansi_cursor_hidden = 0; 1122 break; 1123 case 'l': 1124 ansi_cursor_hidden = 1; 1125 break; 1126 case 'm': 1127 if (num1 == 0) { /* reset swapped colors */ 1128 if (ansi_colors_need_revert) { 1129 console_swap_colors(); 1130 ansi_colors_need_revert = 0; 1131 } 1132 } else if (num1 == 7) { /* once swap colors */ 1133 if (!ansi_colors_need_revert) { 1134 console_swap_colors(); 1135 ansi_colors_need_revert = 1; 1136 } 1137 } 1138 break; 1139 } 1140 if (!ansi_cursor_hidden) 1141 CURSOR_SET; 1142 } 1143 } else { 1144 parse_putc(c); 1145 } 1146 #else 1147 parse_putc(c); 1148 #endif 1149 } 1150 1151 void video_puts(const char *s) 1152 { 1153 int count = strlen(s); 1154 1155 while (count--) 1156 video_putc(*s++); 1157 } 1158 1159 /* 1160 * Do not enforce drivers (or board code) to provide empty 1161 * video_set_lut() if they do not support 8 bpp format. 1162 * Implement weak default function instead. 1163 */ 1164 void __video_set_lut(unsigned int index, unsigned char r, 1165 unsigned char g, unsigned char b) 1166 { 1167 } 1168 1169 void video_set_lut(unsigned int, unsigned char, unsigned char, unsigned char) 1170 __attribute__ ((weak, alias("__video_set_lut"))); 1171 1172 #if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN) 1173 1174 #define FILL_8BIT_332RGB(r,g,b) { \ 1175 *fb = ((r>>5)<<5) | ((g>>5)<<2) | (b>>6); \ 1176 fb ++; \ 1177 } 1178 1179 #define FILL_15BIT_555RGB(r,g,b) { \ 1180 *(unsigned short *)fb = \ 1181 SWAP16((unsigned short)(((r>>3)<<10) | \ 1182 ((g>>3)<<5) | \ 1183 (b>>3))); \ 1184 fb += 2; \ 1185 } 1186 1187 #define FILL_16BIT_565RGB(r,g,b) { \ 1188 *(unsigned short *)fb = \ 1189 SWAP16((unsigned short)((((r)>>3)<<11)| \ 1190 (((g)>>2)<<5) | \ 1191 ((b)>>3))); \ 1192 fb += 2; \ 1193 } 1194 1195 #define FILL_32BIT_X888RGB(r,g,b) { \ 1196 *(unsigned long *)fb = \ 1197 SWAP32((unsigned long)(((r<<16) | \ 1198 (g<<8) | \ 1199 b))); \ 1200 fb += 4; \ 1201 } 1202 1203 #ifdef VIDEO_FB_LITTLE_ENDIAN 1204 #define FILL_24BIT_888RGB(r,g,b) { \ 1205 fb[0] = b; \ 1206 fb[1] = g; \ 1207 fb[2] = r; \ 1208 fb += 3; \ 1209 } 1210 #else 1211 #define FILL_24BIT_888RGB(r,g,b) { \ 1212 fb[0] = r; \ 1213 fb[1] = g; \ 1214 fb[2] = b; \ 1215 fb += 3; \ 1216 } 1217 #endif 1218 1219 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 1220 static inline void fill_555rgb_pswap(uchar *fb, int x, u8 r, u8 g, u8 b) 1221 { 1222 ushort *dst = (ushort *) fb; 1223 ushort color = (ushort) (((r >> 3) << 10) | 1224 ((g >> 3) << 5) | 1225 (b >> 3)); 1226 if (x & 1) 1227 *(--dst) = color; 1228 else 1229 *(++dst) = color; 1230 } 1231 #endif 1232 1233 /* 1234 * RLE8 bitmap support 1235 */ 1236 1237 #ifdef CONFIG_VIDEO_BMP_RLE8 1238 /* Pre-calculated color table entry */ 1239 struct palette { 1240 union { 1241 unsigned short w; /* word */ 1242 unsigned int dw; /* double word */ 1243 } ce; /* color entry */ 1244 }; 1245 1246 /* 1247 * Helper to draw encoded/unencoded run. 1248 */ 1249 static void draw_bitmap(uchar **fb, uchar *bm, struct palette *p, 1250 int cnt, int enc) 1251 { 1252 ulong addr = (ulong) *fb; 1253 int *off; 1254 int enc_off = 1; 1255 int i; 1256 1257 /* 1258 * Setup offset of the color index in the bitmap. 1259 * Color index of encoded run is at offset 1. 1260 */ 1261 off = enc ? &enc_off : &i; 1262 1263 switch (VIDEO_DATA_FORMAT) { 1264 case GDF__8BIT_INDEX: 1265 for (i = 0; i < cnt; i++) 1266 *(unsigned char *) addr++ = bm[*off]; 1267 break; 1268 case GDF_15BIT_555RGB: 1269 case GDF_16BIT_565RGB: 1270 /* differences handled while pre-calculating palette */ 1271 for (i = 0; i < cnt; i++) { 1272 *(unsigned short *) addr = p[bm[*off]].ce.w; 1273 addr += 2; 1274 } 1275 break; 1276 case GDF_32BIT_X888RGB: 1277 for (i = 0; i < cnt; i++) { 1278 *(unsigned long *) addr = p[bm[*off]].ce.dw; 1279 addr += 4; 1280 } 1281 break; 1282 } 1283 *fb = (uchar *) addr; /* return modified address */ 1284 } 1285 1286 static int display_rle8_bitmap(bmp_image_t *img, int xoff, int yoff, 1287 int width, int height) 1288 { 1289 unsigned char *bm; 1290 unsigned char *fbp; 1291 unsigned int cnt, runlen; 1292 int decode = 1; 1293 int x, y, bpp, i, ncolors; 1294 struct palette p[256]; 1295 bmp_color_table_entry_t cte; 1296 int green_shift, red_off; 1297 int limit = VIDEO_COLS * VIDEO_ROWS; 1298 int pixels = 0; 1299 1300 x = 0; 1301 y = __le32_to_cpu(img->header.height) - 1; 1302 ncolors = __le32_to_cpu(img->header.colors_used); 1303 bpp = VIDEO_PIXEL_SIZE; 1304 fbp = (unsigned char *) ((unsigned int) video_fb_address + 1305 (((y + yoff) * VIDEO_COLS) + xoff) * bpp); 1306 1307 bm = (uchar *) img + __le32_to_cpu(img->header.data_offset); 1308 1309 /* pre-calculate and setup palette */ 1310 switch (VIDEO_DATA_FORMAT) { 1311 case GDF__8BIT_INDEX: 1312 for (i = 0; i < ncolors; i++) { 1313 cte = img->color_table[i]; 1314 video_set_lut(i, cte.red, cte.green, cte.blue); 1315 } 1316 break; 1317 case GDF_15BIT_555RGB: 1318 case GDF_16BIT_565RGB: 1319 if (VIDEO_DATA_FORMAT == GDF_15BIT_555RGB) { 1320 green_shift = 3; 1321 red_off = 10; 1322 } else { 1323 green_shift = 2; 1324 red_off = 11; 1325 } 1326 for (i = 0; i < ncolors; i++) { 1327 cte = img->color_table[i]; 1328 p[i].ce.w = SWAP16((unsigned short) 1329 (((cte.red >> 3) << red_off) | 1330 ((cte.green >> green_shift) << 5) | 1331 cte.blue >> 3)); 1332 } 1333 break; 1334 case GDF_32BIT_X888RGB: 1335 for (i = 0; i < ncolors; i++) { 1336 cte = img->color_table[i]; 1337 p[i].ce.dw = SWAP32((cte.red << 16) | 1338 (cte.green << 8) | 1339 cte.blue); 1340 } 1341 break; 1342 default: 1343 printf("RLE Bitmap unsupported in video mode 0x%x\n", 1344 VIDEO_DATA_FORMAT); 1345 return -1; 1346 } 1347 1348 while (decode) { 1349 switch (bm[0]) { 1350 case 0: 1351 switch (bm[1]) { 1352 case 0: 1353 /* scan line end marker */ 1354 bm += 2; 1355 x = 0; 1356 y--; 1357 fbp = (unsigned char *) 1358 ((unsigned int) video_fb_address + 1359 (((y + yoff) * VIDEO_COLS) + 1360 xoff) * bpp); 1361 continue; 1362 case 1: 1363 /* end of bitmap data marker */ 1364 decode = 0; 1365 break; 1366 case 2: 1367 /* run offset marker */ 1368 x += bm[2]; 1369 y -= bm[3]; 1370 fbp = (unsigned char *) 1371 ((unsigned int) video_fb_address + 1372 (((y + yoff) * VIDEO_COLS) + 1373 x + xoff) * bpp); 1374 bm += 4; 1375 break; 1376 default: 1377 /* unencoded run */ 1378 cnt = bm[1]; 1379 runlen = cnt; 1380 pixels += cnt; 1381 if (pixels > limit) 1382 goto error; 1383 1384 bm += 2; 1385 if (y < height) { 1386 if (x >= width) { 1387 x += runlen; 1388 goto next_run; 1389 } 1390 if (x + runlen > width) 1391 cnt = width - x; 1392 draw_bitmap(&fbp, bm, p, cnt, 0); 1393 x += runlen; 1394 } 1395 next_run: 1396 bm += runlen; 1397 if (runlen & 1) 1398 bm++; /* 0 padding if length is odd */ 1399 } 1400 break; 1401 default: 1402 /* encoded run */ 1403 cnt = bm[0]; 1404 runlen = cnt; 1405 pixels += cnt; 1406 if (pixels > limit) 1407 goto error; 1408 1409 if (y < height) { /* only draw into visible area */ 1410 if (x >= width) { 1411 x += runlen; 1412 bm += 2; 1413 continue; 1414 } 1415 if (x + runlen > width) 1416 cnt = width - x; 1417 draw_bitmap(&fbp, bm, p, cnt, 1); 1418 x += runlen; 1419 } 1420 bm += 2; 1421 break; 1422 } 1423 } 1424 return 0; 1425 error: 1426 printf("Error: Too much encoded pixel data, validate your bitmap\n"); 1427 return -1; 1428 } 1429 #endif 1430 1431 /* 1432 * Display the BMP file located at address bmp_image. 1433 */ 1434 int video_display_bitmap(ulong bmp_image, int x, int y) 1435 { 1436 ushort xcount, ycount; 1437 uchar *fb; 1438 bmp_image_t *bmp = (bmp_image_t *) bmp_image; 1439 uchar *bmap; 1440 ushort padded_line; 1441 unsigned long width, height, bpp; 1442 unsigned colors; 1443 unsigned long compression; 1444 bmp_color_table_entry_t cte; 1445 1446 #ifdef CONFIG_VIDEO_BMP_GZIP 1447 unsigned char *dst = NULL; 1448 ulong len; 1449 #endif 1450 1451 WATCHDOG_RESET(); 1452 1453 if (!((bmp->header.signature[0] == 'B') && 1454 (bmp->header.signature[1] == 'M'))) { 1455 1456 #ifdef CONFIG_VIDEO_BMP_GZIP 1457 /* 1458 * Could be a gzipped bmp image, try to decrompress... 1459 */ 1460 len = CONFIG_SYS_VIDEO_LOGO_MAX_SIZE; 1461 dst = malloc(CONFIG_SYS_VIDEO_LOGO_MAX_SIZE); 1462 if (dst == NULL) { 1463 printf("Error: malloc in gunzip failed!\n"); 1464 return 1; 1465 } 1466 if (gunzip(dst, CONFIG_SYS_VIDEO_LOGO_MAX_SIZE, 1467 (uchar *) bmp_image, 1468 &len) != 0) { 1469 printf("Error: no valid bmp or bmp.gz image at %lx\n", 1470 bmp_image); 1471 free(dst); 1472 return 1; 1473 } 1474 if (len == CONFIG_SYS_VIDEO_LOGO_MAX_SIZE) { 1475 printf("Image could be truncated " 1476 "(increase CONFIG_SYS_VIDEO_LOGO_MAX_SIZE)!\n"); 1477 } 1478 1479 /* 1480 * Set addr to decompressed image 1481 */ 1482 bmp = (bmp_image_t *) dst; 1483 1484 if (!((bmp->header.signature[0] == 'B') && 1485 (bmp->header.signature[1] == 'M'))) { 1486 printf("Error: no valid bmp.gz image at %lx\n", 1487 bmp_image); 1488 free(dst); 1489 return 1; 1490 } 1491 #else 1492 printf("Error: no valid bmp image at %lx\n", bmp_image); 1493 return 1; 1494 #endif /* CONFIG_VIDEO_BMP_GZIP */ 1495 } 1496 1497 width = le32_to_cpu(bmp->header.width); 1498 height = le32_to_cpu(bmp->header.height); 1499 bpp = le16_to_cpu(bmp->header.bit_count); 1500 colors = le32_to_cpu(bmp->header.colors_used); 1501 compression = le32_to_cpu(bmp->header.compression); 1502 1503 debug("Display-bmp: %ld x %ld with %d colors\n", 1504 width, height, colors); 1505 1506 if (compression != BMP_BI_RGB 1507 #ifdef CONFIG_VIDEO_BMP_RLE8 1508 && compression != BMP_BI_RLE8 1509 #endif 1510 ) { 1511 printf("Error: compression type %ld not supported\n", 1512 compression); 1513 #ifdef CONFIG_VIDEO_BMP_GZIP 1514 if (dst) 1515 free(dst); 1516 #endif 1517 return 1; 1518 } 1519 1520 padded_line = (((width * bpp + 7) / 8) + 3) & ~0x3; 1521 1522 #ifdef CONFIG_SPLASH_SCREEN_ALIGN 1523 if (x == BMP_ALIGN_CENTER) 1524 x = max(0, (VIDEO_VISIBLE_COLS - width) / 2); 1525 else if (x < 0) 1526 x = max(0, VIDEO_VISIBLE_COLS - width + x + 1); 1527 1528 if (y == BMP_ALIGN_CENTER) 1529 y = max(0, (VIDEO_VISIBLE_ROWS - height) / 2); 1530 else if (y < 0) 1531 y = max(0, VIDEO_VISIBLE_ROWS - height + y + 1); 1532 #endif /* CONFIG_SPLASH_SCREEN_ALIGN */ 1533 1534 /* 1535 * Just ignore elements which are completely beyond screen 1536 * dimensions. 1537 */ 1538 if ((x >= VIDEO_VISIBLE_COLS) || (y >= VIDEO_VISIBLE_ROWS)) 1539 return 0; 1540 1541 if ((x + width) > VIDEO_VISIBLE_COLS) 1542 width = VIDEO_VISIBLE_COLS - x; 1543 if ((y + height) > VIDEO_VISIBLE_ROWS) 1544 height = VIDEO_VISIBLE_ROWS - y; 1545 1546 bmap = (uchar *) bmp + le32_to_cpu(bmp->header.data_offset); 1547 fb = (uchar *) (video_fb_address + 1548 ((y + height - 1) * VIDEO_COLS * VIDEO_PIXEL_SIZE) + 1549 x * VIDEO_PIXEL_SIZE); 1550 1551 #ifdef CONFIG_VIDEO_BMP_RLE8 1552 if (compression == BMP_BI_RLE8) { 1553 return display_rle8_bitmap(bmp, x, y, width, height); 1554 } 1555 #endif 1556 1557 /* We handle only 4, 8, or 24 bpp bitmaps */ 1558 switch (le16_to_cpu(bmp->header.bit_count)) { 1559 case 4: 1560 padded_line -= width / 2; 1561 ycount = height; 1562 1563 switch (VIDEO_DATA_FORMAT) { 1564 case GDF_32BIT_X888RGB: 1565 while (ycount--) { 1566 WATCHDOG_RESET(); 1567 /* 1568 * Don't assume that 'width' is an 1569 * even number 1570 */ 1571 for (xcount = 0; xcount < width; xcount++) { 1572 uchar idx; 1573 1574 if (xcount & 1) { 1575 idx = *bmap & 0xF; 1576 bmap++; 1577 } else 1578 idx = *bmap >> 4; 1579 cte = bmp->color_table[idx]; 1580 FILL_32BIT_X888RGB(cte.red, cte.green, 1581 cte.blue); 1582 } 1583 bmap += padded_line; 1584 fb -= (VIDEO_VISIBLE_COLS + width) * 1585 VIDEO_PIXEL_SIZE; 1586 } 1587 break; 1588 default: 1589 puts("4bpp bitmap unsupported with current " 1590 "video mode\n"); 1591 break; 1592 } 1593 break; 1594 1595 case 8: 1596 padded_line -= width; 1597 if (VIDEO_DATA_FORMAT == GDF__8BIT_INDEX) { 1598 /* Copy colormap */ 1599 for (xcount = 0; xcount < colors; ++xcount) { 1600 cte = bmp->color_table[xcount]; 1601 video_set_lut(xcount, cte.red, cte.green, 1602 cte.blue); 1603 } 1604 } 1605 ycount = height; 1606 switch (VIDEO_DATA_FORMAT) { 1607 case GDF__8BIT_INDEX: 1608 while (ycount--) { 1609 WATCHDOG_RESET(); 1610 xcount = width; 1611 while (xcount--) { 1612 *fb++ = *bmap++; 1613 } 1614 bmap += padded_line; 1615 fb -= (VIDEO_VISIBLE_COLS + width) * 1616 VIDEO_PIXEL_SIZE; 1617 } 1618 break; 1619 case GDF__8BIT_332RGB: 1620 while (ycount--) { 1621 WATCHDOG_RESET(); 1622 xcount = width; 1623 while (xcount--) { 1624 cte = bmp->color_table[*bmap++]; 1625 FILL_8BIT_332RGB(cte.red, cte.green, 1626 cte.blue); 1627 } 1628 bmap += padded_line; 1629 fb -= (VIDEO_VISIBLE_COLS + width) * 1630 VIDEO_PIXEL_SIZE; 1631 } 1632 break; 1633 case GDF_15BIT_555RGB: 1634 while (ycount--) { 1635 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 1636 int xpos = x; 1637 #endif 1638 WATCHDOG_RESET(); 1639 xcount = width; 1640 while (xcount--) { 1641 cte = bmp->color_table[*bmap++]; 1642 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 1643 fill_555rgb_pswap(fb, xpos++, cte.red, 1644 cte.green, 1645 cte.blue); 1646 fb += 2; 1647 #else 1648 FILL_15BIT_555RGB(cte.red, cte.green, 1649 cte.blue); 1650 #endif 1651 } 1652 bmap += padded_line; 1653 fb -= (VIDEO_VISIBLE_COLS + width) * 1654 VIDEO_PIXEL_SIZE; 1655 } 1656 break; 1657 case GDF_16BIT_565RGB: 1658 while (ycount--) { 1659 WATCHDOG_RESET(); 1660 xcount = width; 1661 while (xcount--) { 1662 cte = bmp->color_table[*bmap++]; 1663 FILL_16BIT_565RGB(cte.red, cte.green, 1664 cte.blue); 1665 } 1666 bmap += padded_line; 1667 fb -= (VIDEO_VISIBLE_COLS + width) * 1668 VIDEO_PIXEL_SIZE; 1669 } 1670 break; 1671 case GDF_32BIT_X888RGB: 1672 while (ycount--) { 1673 WATCHDOG_RESET(); 1674 xcount = width; 1675 while (xcount--) { 1676 cte = bmp->color_table[*bmap++]; 1677 FILL_32BIT_X888RGB(cte.red, cte.green, 1678 cte.blue); 1679 } 1680 bmap += padded_line; 1681 fb -= (VIDEO_VISIBLE_COLS + width) * 1682 VIDEO_PIXEL_SIZE; 1683 } 1684 break; 1685 case GDF_24BIT_888RGB: 1686 while (ycount--) { 1687 WATCHDOG_RESET(); 1688 xcount = width; 1689 while (xcount--) { 1690 cte = bmp->color_table[*bmap++]; 1691 FILL_24BIT_888RGB(cte.red, cte.green, 1692 cte.blue); 1693 } 1694 bmap += padded_line; 1695 fb -= (VIDEO_VISIBLE_COLS + width) * 1696 VIDEO_PIXEL_SIZE; 1697 } 1698 break; 1699 } 1700 break; 1701 case 24: 1702 padded_line -= 3 * width; 1703 ycount = height; 1704 switch (VIDEO_DATA_FORMAT) { 1705 case GDF__8BIT_332RGB: 1706 while (ycount--) { 1707 WATCHDOG_RESET(); 1708 xcount = width; 1709 while (xcount--) { 1710 FILL_8BIT_332RGB(bmap[2], bmap[1], 1711 bmap[0]); 1712 bmap += 3; 1713 } 1714 bmap += padded_line; 1715 fb -= (VIDEO_VISIBLE_COLS + width) * 1716 VIDEO_PIXEL_SIZE; 1717 } 1718 break; 1719 case GDF_15BIT_555RGB: 1720 while (ycount--) { 1721 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 1722 int xpos = x; 1723 #endif 1724 WATCHDOG_RESET(); 1725 xcount = width; 1726 while (xcount--) { 1727 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 1728 fill_555rgb_pswap(fb, xpos++, bmap[2], 1729 bmap[1], bmap[0]); 1730 fb += 2; 1731 #else 1732 FILL_15BIT_555RGB(bmap[2], bmap[1], 1733 bmap[0]); 1734 #endif 1735 bmap += 3; 1736 } 1737 bmap += padded_line; 1738 fb -= (VIDEO_VISIBLE_COLS + width) * 1739 VIDEO_PIXEL_SIZE; 1740 } 1741 break; 1742 case GDF_16BIT_565RGB: 1743 while (ycount--) { 1744 WATCHDOG_RESET(); 1745 xcount = width; 1746 while (xcount--) { 1747 FILL_16BIT_565RGB(bmap[2], bmap[1], 1748 bmap[0]); 1749 bmap += 3; 1750 } 1751 bmap += padded_line; 1752 fb -= (VIDEO_VISIBLE_COLS + width) * 1753 VIDEO_PIXEL_SIZE; 1754 } 1755 break; 1756 case GDF_32BIT_X888RGB: 1757 while (ycount--) { 1758 WATCHDOG_RESET(); 1759 xcount = width; 1760 while (xcount--) { 1761 FILL_32BIT_X888RGB(bmap[2], bmap[1], 1762 bmap[0]); 1763 bmap += 3; 1764 } 1765 bmap += padded_line; 1766 fb -= (VIDEO_VISIBLE_COLS + width) * 1767 VIDEO_PIXEL_SIZE; 1768 } 1769 break; 1770 case GDF_24BIT_888RGB: 1771 while (ycount--) { 1772 WATCHDOG_RESET(); 1773 xcount = width; 1774 while (xcount--) { 1775 FILL_24BIT_888RGB(bmap[2], bmap[1], 1776 bmap[0]); 1777 bmap += 3; 1778 } 1779 bmap += padded_line; 1780 fb -= (VIDEO_VISIBLE_COLS + width) * 1781 VIDEO_PIXEL_SIZE; 1782 } 1783 break; 1784 default: 1785 printf("Error: 24 bits/pixel bitmap incompatible " 1786 "with current video mode\n"); 1787 break; 1788 } 1789 break; 1790 default: 1791 printf("Error: %d bit/pixel bitmaps not supported by U-Boot\n", 1792 le16_to_cpu(bmp->header.bit_count)); 1793 break; 1794 } 1795 1796 #ifdef CONFIG_VIDEO_BMP_GZIP 1797 if (dst) { 1798 free(dst); 1799 } 1800 #endif 1801 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 return 0; 2213 } 2214 2215 /* 2216 * Implement a weak default function for boards that optionally 2217 * need to skip the video initialization. 2218 */ 2219 int __board_video_skip(void) 2220 { 2221 /* As default, don't skip test */ 2222 return 0; 2223 } 2224 2225 int board_video_skip(void) 2226 __attribute__ ((weak, alias("__board_video_skip"))); 2227 2228 int drv_video_init(void) 2229 { 2230 int skip_dev_init; 2231 struct stdio_dev console_dev; 2232 2233 /* Check if video initialization should be skipped */ 2234 if (board_video_skip()) 2235 return 0; 2236 2237 /* Init video chip - returns with framebuffer cleared */ 2238 skip_dev_init = (video_init() == -1); 2239 2240 #if !defined(CONFIG_VGA_AS_SINGLE_DEVICE) 2241 debug("KBD: Keyboard init ...\n"); 2242 skip_dev_init |= (VIDEO_KBD_INIT_FCT == -1); 2243 #endif 2244 2245 if (skip_dev_init) 2246 return 0; 2247 2248 /* Init vga device */ 2249 memset(&console_dev, 0, sizeof(console_dev)); 2250 strcpy(console_dev.name, "vga"); 2251 console_dev.ext = DEV_EXT_VIDEO; /* Video extensions */ 2252 console_dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_SYSTEM; 2253 console_dev.putc = video_putc; /* 'putc' function */ 2254 console_dev.puts = video_puts; /* 'puts' function */ 2255 console_dev.tstc = NULL; /* 'tstc' function */ 2256 console_dev.getc = NULL; /* 'getc' function */ 2257 2258 #if !defined(CONFIG_VGA_AS_SINGLE_DEVICE) 2259 /* Also init console device */ 2260 console_dev.flags |= DEV_FLAGS_INPUT; 2261 console_dev.tstc = VIDEO_TSTC_FCT; /* 'tstc' function */ 2262 console_dev.getc = VIDEO_GETC_FCT; /* 'getc' function */ 2263 #endif /* CONFIG_VGA_AS_SINGLE_DEVICE */ 2264 2265 if (stdio_register(&console_dev) != 0) 2266 return 0; 2267 2268 /* Return success */ 2269 return 1; 2270 } 2271 2272 void video_position_cursor(unsigned col, unsigned row) 2273 { 2274 console_col = min(col, CONSOLE_COLS - 1); 2275 console_row = min(row, CONSOLE_ROWS - 1); 2276 } 2277 2278 int video_get_pixel_width(void) 2279 { 2280 return VIDEO_VISIBLE_COLS; 2281 } 2282 2283 int video_get_pixel_height(void) 2284 { 2285 return VIDEO_VISIBLE_ROWS; 2286 } 2287 2288 int video_get_screen_rows(void) 2289 { 2290 return CONSOLE_ROWS; 2291 } 2292 2293 int video_get_screen_columns(void) 2294 { 2295 return CONSOLE_COLS; 2296 } 2297 2298 void video_clear(void) 2299 { 2300 if (!video_fb_address) 2301 return; 2302 #ifdef VIDEO_HW_RECTFILL 2303 video_hw_rectfill(VIDEO_PIXEL_SIZE, /* bytes per pixel */ 2304 0, /* dest pos x */ 2305 0, /* dest pos y */ 2306 VIDEO_VISIBLE_COLS, /* frame width */ 2307 VIDEO_VISIBLE_ROWS, /* frame height */ 2308 bgx /* fill color */ 2309 ); 2310 #else 2311 memsetl(video_fb_address, 2312 (VIDEO_VISIBLE_ROWS * VIDEO_LINE_LEN) / sizeof(int), bgx); 2313 #endif 2314 } 2315