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 * CONFIG_VIDEO_BMP_LOGO - use bmp_logo instead of linux_logo 71 * CONFIG_CONSOLE_EXTRA_INFO - display additional board information 72 * strings that normaly goes to serial 73 * port. This define requires a board 74 * specific function: 75 * video_drawstring (VIDEO_INFO_X, 76 * VIDEO_INFO_Y + i*VIDEO_FONT_HEIGHT, 77 * info); 78 * that fills a info buffer at i=row. 79 * s.a: board/eltec/bab7xx. 80 * CONFIG_VGA_AS_SINGLE_DEVICE - If set the framebuffer device will be 81 * initialized as an output only device. 82 * The Keyboard driver will not be 83 * set-up. This may be used, if you have 84 * no or more than one Keyboard devices 85 * (USB Keyboard, AT Keyboard). 86 * 87 * CONFIG_VIDEO_SW_CURSOR: - Draws a cursor after the last 88 * character. No blinking is provided. 89 * Uses the macros CURSOR_SET and 90 * CURSOR_OFF. 91 * 92 * CONFIG_VIDEO_HW_CURSOR: - Uses the hardware cursor capability 93 * of the graphic chip. Uses the macro 94 * CURSOR_SET. ATTENTION: If booting an 95 * OS, the display driver must disable 96 * the hardware register of the graphic 97 * chip. Otherwise a blinking field is 98 * displayed. 99 */ 100 101 #include <common.h> 102 #include <version.h> 103 #include <malloc.h> 104 #include <linux/compiler.h> 105 106 /* 107 * Console device defines with SMI graphic 108 * Any other graphic must change this section 109 */ 110 111 #ifdef CONFIG_VIDEO_SMI_LYNXEM 112 113 #define VIDEO_FB_LITTLE_ENDIAN 114 #define VIDEO_HW_RECTFILL 115 #define VIDEO_HW_BITBLT 116 #endif 117 118 /* 119 * Defines for the CT69000 driver 120 */ 121 #ifdef CONFIG_VIDEO_CT69000 122 123 #define VIDEO_FB_LITTLE_ENDIAN 124 #define VIDEO_HW_RECTFILL 125 #define VIDEO_HW_BITBLT 126 #endif 127 128 /* 129 * Defines for the SED13806 driver 130 */ 131 #ifdef CONFIG_VIDEO_SED13806 132 133 #ifndef CONFIG_TOTAL5200 134 #define VIDEO_FB_LITTLE_ENDIAN 135 #endif 136 #define VIDEO_HW_RECTFILL 137 #define VIDEO_HW_BITBLT 138 #endif 139 140 /* 141 * Defines for the SED13806 driver 142 */ 143 #ifdef CONFIG_VIDEO_SM501 144 145 #ifdef CONFIG_HH405 146 #define VIDEO_FB_LITTLE_ENDIAN 147 #endif 148 #endif 149 150 /* 151 * Defines for the MB862xx driver 152 */ 153 #ifdef CONFIG_VIDEO_MB862xx 154 155 #ifdef CONFIG_VIDEO_CORALP 156 #define VIDEO_FB_LITTLE_ENDIAN 157 #endif 158 #ifdef CONFIG_VIDEO_MB862xx_ACCEL 159 #define VIDEO_HW_RECTFILL 160 #define VIDEO_HW_BITBLT 161 #endif 162 #endif 163 164 /* 165 * Defines for the i.MX31 driver (mx3fb.c) 166 */ 167 #ifdef CONFIG_VIDEO_MX3 168 #define VIDEO_FB_16BPP_WORD_SWAP 169 #endif 170 171 /* 172 * Include video_fb.h after definitions of VIDEO_HW_RECTFILL etc. 173 */ 174 #include <video_fb.h> 175 176 /* 177 * some Macros 178 */ 179 #define VIDEO_VISIBLE_COLS (pGD->winSizeX) 180 #define VIDEO_VISIBLE_ROWS (pGD->winSizeY) 181 #define VIDEO_PIXEL_SIZE (pGD->gdfBytesPP) 182 #define VIDEO_DATA_FORMAT (pGD->gdfIndex) 183 #define VIDEO_FB_ADRS (pGD->frameAdrs) 184 185 /* 186 * Console device defines with i8042 keyboard controller 187 * Any other keyboard controller must change this section 188 */ 189 190 #ifdef CONFIG_I8042_KBD 191 #include <i8042.h> 192 193 #define VIDEO_KBD_INIT_FCT i8042_kbd_init() 194 #define VIDEO_TSTC_FCT i8042_tstc 195 #define VIDEO_GETC_FCT i8042_getc 196 #endif 197 198 /* 199 * Console device 200 */ 201 202 #include <version.h> 203 #include <linux/types.h> 204 #include <stdio_dev.h> 205 #include <video_font.h> 206 207 #if defined(CONFIG_CMD_DATE) 208 #include <rtc.h> 209 #endif 210 211 #if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN) 212 #include <watchdog.h> 213 #include <bmp_layout.h> 214 215 #ifdef CONFIG_SPLASH_SCREEN_ALIGN 216 #define BMP_ALIGN_CENTER 0x7FFF 217 #endif 218 219 #endif 220 221 /* 222 * Cursor definition: 223 * CONFIG_CONSOLE_CURSOR: Uses a timer function (see drivers/input/i8042.c) 224 * to let the cursor blink. Uses the macros 225 * CURSOR_OFF and CURSOR_ON. 226 * CONFIG_VIDEO_SW_CURSOR: Draws a cursor after the last character. No 227 * blinking is provided. Uses the macros CURSOR_SET 228 * and CURSOR_OFF. 229 * CONFIG_VIDEO_HW_CURSOR: Uses the hardware cursor capability of the 230 * graphic chip. Uses the macro CURSOR_SET. 231 * ATTENTION: If booting an OS, the display driver 232 * must disable the hardware register of the graphic 233 * chip. Otherwise a blinking field is displayed 234 */ 235 #if !defined(CONFIG_CONSOLE_CURSOR) && \ 236 !defined(CONFIG_VIDEO_SW_CURSOR) && \ 237 !defined(CONFIG_VIDEO_HW_CURSOR) 238 /* no Cursor defined */ 239 #define CURSOR_ON 240 #define CURSOR_OFF 241 #define CURSOR_SET 242 #endif 243 244 #ifdef CONFIG_CONSOLE_CURSOR 245 #ifdef CURSOR_ON 246 #error only one of CONFIG_CONSOLE_CURSOR, CONFIG_VIDEO_SW_CURSOR, \ 247 or CONFIG_VIDEO_HW_CURSOR can be defined 248 #endif 249 void console_cursor(int state); 250 251 #define CURSOR_ON console_cursor(1) 252 #define CURSOR_OFF console_cursor(0) 253 #define CURSOR_SET 254 #ifndef CONFIG_I8042_KBD 255 #warning Cursor drawing on/off needs timer function s.a. drivers/input/i8042.c 256 #endif 257 #else 258 #ifdef CONFIG_CONSOLE_TIME 259 #error CONFIG_CONSOLE_CURSOR must be defined for CONFIG_CONSOLE_TIME 260 #endif 261 #endif /* CONFIG_CONSOLE_CURSOR */ 262 263 #ifdef CONFIG_VIDEO_SW_CURSOR 264 #ifdef CURSOR_ON 265 #error only one of CONFIG_CONSOLE_CURSOR, CONFIG_VIDEO_SW_CURSOR, \ 266 or CONFIG_VIDEO_HW_CURSOR can be defined 267 #endif 268 #define CURSOR_ON 269 #define CURSOR_OFF video_putchar(console_col * VIDEO_FONT_WIDTH,\ 270 console_row * VIDEO_FONT_HEIGHT, ' ') 271 #define CURSOR_SET video_set_cursor() 272 #endif /* CONFIG_VIDEO_SW_CURSOR */ 273 274 275 #ifdef CONFIG_VIDEO_HW_CURSOR 276 #ifdef CURSOR_ON 277 #error only one of CONFIG_CONSOLE_CURSOR, CONFIG_VIDEO_SW_CURSOR, \ 278 or CONFIG_VIDEO_HW_CURSOR can be defined 279 #endif 280 #define CURSOR_ON 281 #define CURSOR_OFF 282 #define CURSOR_SET video_set_hw_cursor(console_col * VIDEO_FONT_WIDTH, \ 283 (console_row * VIDEO_FONT_HEIGHT) + video_logo_height) 284 #endif /* CONFIG_VIDEO_HW_CURSOR */ 285 286 #ifdef CONFIG_VIDEO_LOGO 287 #ifdef CONFIG_VIDEO_BMP_LOGO 288 #include <bmp_logo.h> 289 #define VIDEO_LOGO_WIDTH BMP_LOGO_WIDTH 290 #define VIDEO_LOGO_HEIGHT BMP_LOGO_HEIGHT 291 #define VIDEO_LOGO_LUT_OFFSET BMP_LOGO_OFFSET 292 #define VIDEO_LOGO_COLORS BMP_LOGO_COLORS 293 294 #else /* CONFIG_VIDEO_BMP_LOGO */ 295 #define LINUX_LOGO_WIDTH 80 296 #define LINUX_LOGO_HEIGHT 80 297 #define LINUX_LOGO_COLORS 214 298 #define LINUX_LOGO_LUT_OFFSET 0x20 299 #define __initdata 300 #include <linux_logo.h> 301 #define VIDEO_LOGO_WIDTH LINUX_LOGO_WIDTH 302 #define VIDEO_LOGO_HEIGHT LINUX_LOGO_HEIGHT 303 #define VIDEO_LOGO_LUT_OFFSET LINUX_LOGO_LUT_OFFSET 304 #define VIDEO_LOGO_COLORS LINUX_LOGO_COLORS 305 #endif /* CONFIG_VIDEO_BMP_LOGO */ 306 #define VIDEO_INFO_X (VIDEO_LOGO_WIDTH) 307 #define VIDEO_INFO_Y (VIDEO_FONT_HEIGHT/2) 308 #else /* CONFIG_VIDEO_LOGO */ 309 #define VIDEO_LOGO_WIDTH 0 310 #define VIDEO_LOGO_HEIGHT 0 311 #endif /* CONFIG_VIDEO_LOGO */ 312 313 #define VIDEO_COLS VIDEO_VISIBLE_COLS 314 #define VIDEO_ROWS VIDEO_VISIBLE_ROWS 315 #define VIDEO_SIZE (VIDEO_ROWS*VIDEO_COLS*VIDEO_PIXEL_SIZE) 316 #define VIDEO_PIX_BLOCKS (VIDEO_SIZE >> 2) 317 #define VIDEO_LINE_LEN (VIDEO_COLS*VIDEO_PIXEL_SIZE) 318 #define VIDEO_BURST_LEN (VIDEO_COLS/8) 319 320 #ifdef CONFIG_VIDEO_LOGO 321 #define CONSOLE_ROWS ((VIDEO_ROWS - video_logo_height) / VIDEO_FONT_HEIGHT) 322 #else 323 #define CONSOLE_ROWS (VIDEO_ROWS / VIDEO_FONT_HEIGHT) 324 #endif 325 326 #define CONSOLE_COLS (VIDEO_COLS / VIDEO_FONT_WIDTH) 327 #define CONSOLE_ROW_SIZE (VIDEO_FONT_HEIGHT * VIDEO_LINE_LEN) 328 #define CONSOLE_ROW_FIRST (video_console_address) 329 #define CONSOLE_ROW_SECOND (video_console_address + CONSOLE_ROW_SIZE) 330 #define CONSOLE_ROW_LAST (video_console_address + CONSOLE_SIZE - CONSOLE_ROW_SIZE) 331 #define CONSOLE_SIZE (CONSOLE_ROW_SIZE * CONSOLE_ROWS) 332 #define CONSOLE_SCROLL_SIZE (CONSOLE_SIZE - CONSOLE_ROW_SIZE) 333 334 /* Macros */ 335 #ifdef VIDEO_FB_LITTLE_ENDIAN 336 #define SWAP16(x) ((((x) & 0x00ff) << 8) | \ 337 ((x) >> 8) \ 338 ) 339 #define SWAP32(x) ((((x) & 0x000000ff) << 24) | \ 340 (((x) & 0x0000ff00) << 8) | \ 341 (((x) & 0x00ff0000) >> 8) | \ 342 (((x) & 0xff000000) >> 24) \ 343 ) 344 #define SHORTSWAP32(x) ((((x) & 0x000000ff) << 8) | \ 345 (((x) & 0x0000ff00) >> 8) | \ 346 (((x) & 0x00ff0000) << 8) | \ 347 (((x) & 0xff000000) >> 8) \ 348 ) 349 #else 350 #define SWAP16(x) (x) 351 #define SWAP32(x) (x) 352 #if defined(VIDEO_FB_16BPP_WORD_SWAP) 353 #define SHORTSWAP32(x) (((x) >> 16) | ((x) << 16)) 354 #else 355 #define SHORTSWAP32(x) (x) 356 #endif 357 #endif 358 359 #ifdef CONFIG_CONSOLE_EXTRA_INFO 360 /* 361 * setup a board string: type, speed, etc. 362 * 363 * line_number: location to place info string beside logo 364 * info: buffer for info string 365 */ 366 extern void video_get_info_str(int line_number, char *info); 367 #endif 368 369 /* Locals */ 370 static GraphicDevice *pGD; /* Pointer to Graphic array */ 371 372 static void *video_fb_address; /* frame buffer address */ 373 static void *video_console_address; /* console buffer start address */ 374 375 static int video_logo_height = VIDEO_LOGO_HEIGHT; 376 377 static int console_col; /* cursor col */ 378 static int console_row; /* cursor row */ 379 380 static u32 eorx, fgx, bgx; /* color pats */ 381 382 static const int video_font_draw_table8[] = { 383 0x00000000, 0x000000ff, 0x0000ff00, 0x0000ffff, 384 0x00ff0000, 0x00ff00ff, 0x00ffff00, 0x00ffffff, 385 0xff000000, 0xff0000ff, 0xff00ff00, 0xff00ffff, 386 0xffff0000, 0xffff00ff, 0xffffff00, 0xffffffff 387 }; 388 389 static const int video_font_draw_table15[] = { 390 0x00000000, 0x00007fff, 0x7fff0000, 0x7fff7fff 391 }; 392 393 static const int video_font_draw_table16[] = { 394 0x00000000, 0x0000ffff, 0xffff0000, 0xffffffff 395 }; 396 397 static const int video_font_draw_table24[16][3] = { 398 {0x00000000, 0x00000000, 0x00000000}, 399 {0x00000000, 0x00000000, 0x00ffffff}, 400 {0x00000000, 0x0000ffff, 0xff000000}, 401 {0x00000000, 0x0000ffff, 0xffffffff}, 402 {0x000000ff, 0xffff0000, 0x00000000}, 403 {0x000000ff, 0xffff0000, 0x00ffffff}, 404 {0x000000ff, 0xffffffff, 0xff000000}, 405 {0x000000ff, 0xffffffff, 0xffffffff}, 406 {0xffffff00, 0x00000000, 0x00000000}, 407 {0xffffff00, 0x00000000, 0x00ffffff}, 408 {0xffffff00, 0x0000ffff, 0xff000000}, 409 {0xffffff00, 0x0000ffff, 0xffffffff}, 410 {0xffffffff, 0xffff0000, 0x00000000}, 411 {0xffffffff, 0xffff0000, 0x00ffffff}, 412 {0xffffffff, 0xffffffff, 0xff000000}, 413 {0xffffffff, 0xffffffff, 0xffffffff} 414 }; 415 416 static const int video_font_draw_table32[16][4] = { 417 {0x00000000, 0x00000000, 0x00000000, 0x00000000}, 418 {0x00000000, 0x00000000, 0x00000000, 0x00ffffff}, 419 {0x00000000, 0x00000000, 0x00ffffff, 0x00000000}, 420 {0x00000000, 0x00000000, 0x00ffffff, 0x00ffffff}, 421 {0x00000000, 0x00ffffff, 0x00000000, 0x00000000}, 422 {0x00000000, 0x00ffffff, 0x00000000, 0x00ffffff}, 423 {0x00000000, 0x00ffffff, 0x00ffffff, 0x00000000}, 424 {0x00000000, 0x00ffffff, 0x00ffffff, 0x00ffffff}, 425 {0x00ffffff, 0x00000000, 0x00000000, 0x00000000}, 426 {0x00ffffff, 0x00000000, 0x00000000, 0x00ffffff}, 427 {0x00ffffff, 0x00000000, 0x00ffffff, 0x00000000}, 428 {0x00ffffff, 0x00000000, 0x00ffffff, 0x00ffffff}, 429 {0x00ffffff, 0x00ffffff, 0x00000000, 0x00000000}, 430 {0x00ffffff, 0x00ffffff, 0x00000000, 0x00ffffff}, 431 {0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00000000}, 432 {0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00ffffff} 433 }; 434 435 436 static void video_drawchars(int xx, int yy, unsigned char *s, int count) 437 { 438 u8 *cdat, *dest, *dest0; 439 int rows, offset, c; 440 441 offset = yy * VIDEO_LINE_LEN + xx * VIDEO_PIXEL_SIZE; 442 dest0 = video_fb_address + offset; 443 444 switch (VIDEO_DATA_FORMAT) { 445 case GDF__8BIT_INDEX: 446 case GDF__8BIT_332RGB: 447 while (count--) { 448 c = *s; 449 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT; 450 for (rows = VIDEO_FONT_HEIGHT, dest = dest0; 451 rows--; dest += VIDEO_LINE_LEN) { 452 u8 bits = *cdat++; 453 454 ((u32 *) dest)[0] = 455 (video_font_draw_table8[bits >> 4] & 456 eorx) ^ bgx; 457 ((u32 *) dest)[1] = 458 (video_font_draw_table8[bits & 15] & 459 eorx) ^ bgx; 460 } 461 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE; 462 s++; 463 } 464 break; 465 466 case GDF_15BIT_555RGB: 467 while (count--) { 468 c = *s; 469 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT; 470 for (rows = VIDEO_FONT_HEIGHT, dest = dest0; 471 rows--; dest += VIDEO_LINE_LEN) { 472 u8 bits = *cdat++; 473 474 ((u32 *) dest)[0] = 475 SHORTSWAP32((video_font_draw_table15 476 [bits >> 6] & eorx) ^ 477 bgx); 478 ((u32 *) dest)[1] = 479 SHORTSWAP32((video_font_draw_table15 480 [bits >> 4 & 3] & eorx) ^ 481 bgx); 482 ((u32 *) dest)[2] = 483 SHORTSWAP32((video_font_draw_table15 484 [bits >> 2 & 3] & eorx) ^ 485 bgx); 486 ((u32 *) dest)[3] = 487 SHORTSWAP32((video_font_draw_table15 488 [bits & 3] & eorx) ^ 489 bgx); 490 } 491 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE; 492 s++; 493 } 494 break; 495 496 case GDF_16BIT_565RGB: 497 while (count--) { 498 c = *s; 499 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT; 500 for (rows = VIDEO_FONT_HEIGHT, dest = dest0; 501 rows--; dest += VIDEO_LINE_LEN) { 502 u8 bits = *cdat++; 503 504 ((u32 *) dest)[0] = 505 SHORTSWAP32((video_font_draw_table16 506 [bits >> 6] & eorx) ^ 507 bgx); 508 ((u32 *) dest)[1] = 509 SHORTSWAP32((video_font_draw_table16 510 [bits >> 4 & 3] & eorx) ^ 511 bgx); 512 ((u32 *) dest)[2] = 513 SHORTSWAP32((video_font_draw_table16 514 [bits >> 2 & 3] & eorx) ^ 515 bgx); 516 ((u32 *) dest)[3] = 517 SHORTSWAP32((video_font_draw_table16 518 [bits & 3] & eorx) ^ 519 bgx); 520 } 521 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE; 522 s++; 523 } 524 break; 525 526 case GDF_32BIT_X888RGB: 527 while (count--) { 528 c = *s; 529 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT; 530 for (rows = VIDEO_FONT_HEIGHT, dest = dest0; 531 rows--; dest += VIDEO_LINE_LEN) { 532 u8 bits = *cdat++; 533 534 ((u32 *) dest)[0] = 535 SWAP32((video_font_draw_table32 536 [bits >> 4][0] & eorx) ^ bgx); 537 ((u32 *) dest)[1] = 538 SWAP32((video_font_draw_table32 539 [bits >> 4][1] & eorx) ^ bgx); 540 ((u32 *) dest)[2] = 541 SWAP32((video_font_draw_table32 542 [bits >> 4][2] & eorx) ^ bgx); 543 ((u32 *) dest)[3] = 544 SWAP32((video_font_draw_table32 545 [bits >> 4][3] & eorx) ^ bgx); 546 ((u32 *) dest)[4] = 547 SWAP32((video_font_draw_table32 548 [bits & 15][0] & eorx) ^ bgx); 549 ((u32 *) dest)[5] = 550 SWAP32((video_font_draw_table32 551 [bits & 15][1] & eorx) ^ bgx); 552 ((u32 *) dest)[6] = 553 SWAP32((video_font_draw_table32 554 [bits & 15][2] & eorx) ^ bgx); 555 ((u32 *) dest)[7] = 556 SWAP32((video_font_draw_table32 557 [bits & 15][3] & eorx) ^ bgx); 558 } 559 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE; 560 s++; 561 } 562 break; 563 564 case GDF_24BIT_888RGB: 565 while (count--) { 566 c = *s; 567 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT; 568 for (rows = VIDEO_FONT_HEIGHT, dest = dest0; 569 rows--; dest += VIDEO_LINE_LEN) { 570 u8 bits = *cdat++; 571 572 ((u32 *) dest)[0] = 573 (video_font_draw_table24[bits >> 4][0] 574 & eorx) ^ bgx; 575 ((u32 *) dest)[1] = 576 (video_font_draw_table24[bits >> 4][1] 577 & eorx) ^ bgx; 578 ((u32 *) dest)[2] = 579 (video_font_draw_table24[bits >> 4][2] 580 & eorx) ^ bgx; 581 ((u32 *) dest)[3] = 582 (video_font_draw_table24[bits & 15][0] 583 & eorx) ^ bgx; 584 ((u32 *) dest)[4] = 585 (video_font_draw_table24[bits & 15][1] 586 & eorx) ^ bgx; 587 ((u32 *) dest)[5] = 588 (video_font_draw_table24[bits & 15][2] 589 & eorx) ^ bgx; 590 } 591 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE; 592 s++; 593 } 594 break; 595 } 596 } 597 598 static inline void video_drawstring(int xx, int yy, unsigned char *s) 599 { 600 video_drawchars(xx, yy, s, strlen((char *) s)); 601 } 602 603 static void video_putchar(int xx, int yy, unsigned char c) 604 { 605 video_drawchars(xx, yy + video_logo_height, &c, 1); 606 } 607 608 #if defined(CONFIG_CONSOLE_CURSOR) || defined(CONFIG_VIDEO_SW_CURSOR) 609 static void video_set_cursor(void) 610 { 611 /* swap drawing colors */ 612 eorx = fgx; 613 fgx = bgx; 614 bgx = eorx; 615 eorx = fgx ^ bgx; 616 /* draw cursor */ 617 video_putchar(console_col * VIDEO_FONT_WIDTH, 618 console_row * VIDEO_FONT_HEIGHT, ' '); 619 /* restore drawing colors */ 620 eorx = fgx; 621 fgx = bgx; 622 bgx = eorx; 623 eorx = fgx ^ bgx; 624 } 625 #endif 626 627 #ifdef CONFIG_CONSOLE_CURSOR 628 void console_cursor(int state) 629 { 630 static int last_state = 0; 631 632 #ifdef CONFIG_CONSOLE_TIME 633 struct rtc_time tm; 634 char info[16]; 635 636 /* time update only if cursor is on (faster scroll) */ 637 if (state) { 638 rtc_get(&tm); 639 640 sprintf(info, " %02d:%02d:%02d ", tm.tm_hour, tm.tm_min, 641 tm.tm_sec); 642 video_drawstring(VIDEO_VISIBLE_COLS - 10 * VIDEO_FONT_WIDTH, 643 VIDEO_INFO_Y, (uchar *) info); 644 645 sprintf(info, "%02d.%02d.%04d", tm.tm_mday, tm.tm_mon, 646 tm.tm_year); 647 video_drawstring(VIDEO_VISIBLE_COLS - 10 * VIDEO_FONT_WIDTH, 648 VIDEO_INFO_Y + 1 * VIDEO_FONT_HEIGHT, 649 (uchar *) info); 650 } 651 #endif 652 653 if (state && (last_state != state)) { 654 video_set_cursor(); 655 } 656 657 if (!state && (last_state != state)) { 658 /* clear cursor */ 659 video_putchar(console_col * VIDEO_FONT_WIDTH, 660 console_row * VIDEO_FONT_HEIGHT, ' '); 661 } 662 663 last_state = state; 664 } 665 #endif 666 667 #ifndef VIDEO_HW_RECTFILL 668 static void memsetl(int *p, int c, int v) 669 { 670 while (c--) 671 *(p++) = v; 672 } 673 #endif 674 675 #ifndef VIDEO_HW_BITBLT 676 static void memcpyl(int *d, int *s, int c) 677 { 678 while (c--) 679 *(d++) = *(s++); 680 } 681 #endif 682 683 static void console_scrollup(void) 684 { 685 /* copy up rows ignoring the first one */ 686 687 #ifdef VIDEO_HW_BITBLT 688 video_hw_bitblt(VIDEO_PIXEL_SIZE, /* bytes per pixel */ 689 0, /* source pos x */ 690 video_logo_height + 691 VIDEO_FONT_HEIGHT, /* source pos y */ 692 0, /* dest pos x */ 693 video_logo_height, /* dest pos y */ 694 VIDEO_VISIBLE_COLS, /* frame width */ 695 VIDEO_VISIBLE_ROWS 696 - video_logo_height 697 - VIDEO_FONT_HEIGHT /* frame height */ 698 ); 699 #else 700 memcpyl(CONSOLE_ROW_FIRST, CONSOLE_ROW_SECOND, 701 CONSOLE_SCROLL_SIZE >> 2); 702 #endif 703 704 /* clear the last one */ 705 #ifdef VIDEO_HW_RECTFILL 706 video_hw_rectfill(VIDEO_PIXEL_SIZE, /* bytes per pixel */ 707 0, /* dest pos x */ 708 VIDEO_VISIBLE_ROWS 709 - VIDEO_FONT_HEIGHT, /* dest pos y */ 710 VIDEO_VISIBLE_COLS, /* frame width */ 711 VIDEO_FONT_HEIGHT, /* frame height */ 712 CONSOLE_BG_COL /* fill color */ 713 ); 714 #else 715 memsetl(CONSOLE_ROW_LAST, CONSOLE_ROW_SIZE >> 2, CONSOLE_BG_COL); 716 #endif 717 } 718 719 static void console_back(void) 720 { 721 CURSOR_OFF; 722 console_col--; 723 724 if (console_col < 0) { 725 console_col = CONSOLE_COLS - 1; 726 console_row--; 727 if (console_row < 0) 728 console_row = 0; 729 } 730 video_putchar(console_col * VIDEO_FONT_WIDTH, 731 console_row * VIDEO_FONT_HEIGHT, ' '); 732 } 733 734 static void console_newline(void) 735 { 736 /* Check if last character in the line was just drawn. If so, cursor was 737 overwriten and need not to be cleared. Cursor clearing without this 738 check causes overwriting the 1st character of the line if line lenght 739 is >= CONSOLE_COLS 740 */ 741 if (console_col < CONSOLE_COLS) 742 CURSOR_OFF; 743 console_row++; 744 console_col = 0; 745 746 /* Check if we need to scroll the terminal */ 747 if (console_row >= CONSOLE_ROWS) { 748 /* Scroll everything up */ 749 console_scrollup(); 750 751 /* Decrement row number */ 752 console_row--; 753 } 754 } 755 756 static void console_cr(void) 757 { 758 CURSOR_OFF; 759 console_col = 0; 760 } 761 762 void video_putc(const char c) 763 { 764 static int nl = 1; 765 766 switch (c) { 767 case 13: /* back to first column */ 768 console_cr(); 769 break; 770 771 case '\n': /* next line */ 772 if (console_col || (!console_col && nl)) 773 console_newline(); 774 nl = 1; 775 break; 776 777 case 9: /* tab 8 */ 778 CURSOR_OFF; 779 console_col |= 0x0008; 780 console_col &= ~0x0007; 781 782 if (console_col >= CONSOLE_COLS) 783 console_newline(); 784 break; 785 786 case 8: /* backspace */ 787 console_back(); 788 break; 789 790 default: /* draw the char */ 791 video_putchar(console_col * VIDEO_FONT_WIDTH, 792 console_row * VIDEO_FONT_HEIGHT, c); 793 console_col++; 794 795 /* check for newline */ 796 if (console_col >= CONSOLE_COLS) { 797 console_newline(); 798 nl = 0; 799 } 800 } 801 CURSOR_SET; 802 } 803 804 void video_puts(const char *s) 805 { 806 int count = strlen(s); 807 808 while (count--) 809 video_putc(*s++); 810 } 811 812 /* 813 * Do not enforce drivers (or board code) to provide empty 814 * video_set_lut() if they do not support 8 bpp format. 815 * Implement weak default function instead. 816 */ 817 void __video_set_lut(unsigned int index, unsigned char r, 818 unsigned char g, unsigned char b) 819 { 820 } 821 822 void video_set_lut(unsigned int, unsigned char, unsigned char, unsigned char) 823 __attribute__ ((weak, alias("__video_set_lut"))); 824 825 #if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN) 826 827 #define FILL_8BIT_332RGB(r,g,b) { \ 828 *fb = ((r>>5)<<5) | ((g>>5)<<2) | (b>>6); \ 829 fb ++; \ 830 } 831 832 #define FILL_15BIT_555RGB(r,g,b) { \ 833 *(unsigned short *)fb = \ 834 SWAP16((unsigned short)(((r>>3)<<10) | \ 835 ((g>>3)<<5) | \ 836 (b>>3))); \ 837 fb += 2; \ 838 } 839 840 #define FILL_16BIT_565RGB(r,g,b) { \ 841 *(unsigned short *)fb = \ 842 SWAP16((unsigned short)((((r)>>3)<<11)| \ 843 (((g)>>2)<<5) | \ 844 ((b)>>3))); \ 845 fb += 2; \ 846 } 847 848 #define FILL_32BIT_X888RGB(r,g,b) { \ 849 *(unsigned long *)fb = \ 850 SWAP32((unsigned long)(((r<<16) | \ 851 (g<<8) | \ 852 b))); \ 853 fb += 4; \ 854 } 855 856 #ifdef VIDEO_FB_LITTLE_ENDIAN 857 #define FILL_24BIT_888RGB(r,g,b) { \ 858 fb[0] = b; \ 859 fb[1] = g; \ 860 fb[2] = r; \ 861 fb += 3; \ 862 } 863 #else 864 #define FILL_24BIT_888RGB(r,g,b) { \ 865 fb[0] = r; \ 866 fb[1] = g; \ 867 fb[2] = b; \ 868 fb += 3; \ 869 } 870 #endif 871 872 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 873 static inline void fill_555rgb_pswap(uchar *fb, int x, u8 r, u8 g, u8 b) 874 { 875 ushort *dst = (ushort *) fb; 876 ushort color = (ushort) (((r >> 3) << 10) | 877 ((g >> 3) << 5) | 878 (b >> 3)); 879 if (x & 1) 880 *(--dst) = color; 881 else 882 *(++dst) = color; 883 } 884 #endif 885 886 /* 887 * RLE8 bitmap support 888 */ 889 890 #ifdef CONFIG_VIDEO_BMP_RLE8 891 /* Pre-calculated color table entry */ 892 struct palette { 893 union { 894 unsigned short w; /* word */ 895 unsigned int dw; /* double word */ 896 } ce; /* color entry */ 897 }; 898 899 /* 900 * Helper to draw encoded/unencoded run. 901 */ 902 static void draw_bitmap(uchar **fb, uchar *bm, struct palette *p, 903 int cnt, int enc) 904 { 905 ulong addr = (ulong) *fb; 906 int *off; 907 int enc_off = 1; 908 int i; 909 910 /* 911 * Setup offset of the color index in the bitmap. 912 * Color index of encoded run is at offset 1. 913 */ 914 off = enc ? &enc_off : &i; 915 916 switch (VIDEO_DATA_FORMAT) { 917 case GDF__8BIT_INDEX: 918 for (i = 0; i < cnt; i++) 919 *(unsigned char *) addr++ = bm[*off]; 920 break; 921 case GDF_15BIT_555RGB: 922 case GDF_16BIT_565RGB: 923 /* differences handled while pre-calculating palette */ 924 for (i = 0; i < cnt; i++) { 925 *(unsigned short *) addr = p[bm[*off]].ce.w; 926 addr += 2; 927 } 928 break; 929 case GDF_32BIT_X888RGB: 930 for (i = 0; i < cnt; i++) { 931 *(unsigned long *) addr = p[bm[*off]].ce.dw; 932 addr += 4; 933 } 934 break; 935 } 936 *fb = (uchar *) addr; /* return modified address */ 937 } 938 939 static int display_rle8_bitmap(bmp_image_t *img, int xoff, int yoff, 940 int width, int height) 941 { 942 unsigned char *bm; 943 unsigned char *fbp; 944 unsigned int cnt, runlen; 945 int decode = 1; 946 int x, y, bpp, i, ncolors; 947 struct palette p[256]; 948 bmp_color_table_entry_t cte; 949 int green_shift, red_off; 950 int limit = VIDEO_COLS * VIDEO_ROWS; 951 int pixels = 0; 952 953 x = 0; 954 y = __le32_to_cpu(img->header.height) - 1; 955 ncolors = __le32_to_cpu(img->header.colors_used); 956 bpp = VIDEO_PIXEL_SIZE; 957 fbp = (unsigned char *) ((unsigned int) video_fb_address + 958 (((y + yoff) * VIDEO_COLS) + xoff) * bpp); 959 960 bm = (uchar *) img + __le32_to_cpu(img->header.data_offset); 961 962 /* pre-calculate and setup palette */ 963 switch (VIDEO_DATA_FORMAT) { 964 case GDF__8BIT_INDEX: 965 for (i = 0; i < ncolors; i++) { 966 cte = img->color_table[i]; 967 video_set_lut(i, cte.red, cte.green, cte.blue); 968 } 969 break; 970 case GDF_15BIT_555RGB: 971 case GDF_16BIT_565RGB: 972 if (VIDEO_DATA_FORMAT == GDF_15BIT_555RGB) { 973 green_shift = 3; 974 red_off = 10; 975 } else { 976 green_shift = 2; 977 red_off = 11; 978 } 979 for (i = 0; i < ncolors; i++) { 980 cte = img->color_table[i]; 981 p[i].ce.w = SWAP16((unsigned short) 982 (((cte.red >> 3) << red_off) | 983 ((cte.green >> green_shift) << 5) | 984 cte.blue >> 3)); 985 } 986 break; 987 case GDF_32BIT_X888RGB: 988 for (i = 0; i < ncolors; i++) { 989 cte = img->color_table[i]; 990 p[i].ce.dw = SWAP32((cte.red << 16) | 991 (cte.green << 8) | 992 cte.blue); 993 } 994 break; 995 default: 996 printf("RLE Bitmap unsupported in video mode 0x%x\n", 997 VIDEO_DATA_FORMAT); 998 return -1; 999 } 1000 1001 while (decode) { 1002 switch (bm[0]) { 1003 case 0: 1004 switch (bm[1]) { 1005 case 0: 1006 /* scan line end marker */ 1007 bm += 2; 1008 x = 0; 1009 y--; 1010 fbp = (unsigned char *) 1011 ((unsigned int) video_fb_address + 1012 (((y + yoff) * VIDEO_COLS) + 1013 xoff) * bpp); 1014 continue; 1015 case 1: 1016 /* end of bitmap data marker */ 1017 decode = 0; 1018 break; 1019 case 2: 1020 /* run offset marker */ 1021 x += bm[2]; 1022 y -= bm[3]; 1023 fbp = (unsigned char *) 1024 ((unsigned int) video_fb_address + 1025 (((y + yoff) * VIDEO_COLS) + 1026 x + xoff) * bpp); 1027 bm += 4; 1028 break; 1029 default: 1030 /* unencoded run */ 1031 cnt = bm[1]; 1032 runlen = cnt; 1033 pixels += cnt; 1034 if (pixels > limit) 1035 goto error; 1036 1037 bm += 2; 1038 if (y < height) { 1039 if (x >= width) { 1040 x += runlen; 1041 goto next_run; 1042 } 1043 if (x + runlen > width) 1044 cnt = width - x; 1045 draw_bitmap(&fbp, bm, p, cnt, 0); 1046 x += runlen; 1047 } 1048 next_run: 1049 bm += runlen; 1050 if (runlen & 1) 1051 bm++; /* 0 padding if length is odd */ 1052 } 1053 break; 1054 default: 1055 /* encoded run */ 1056 cnt = bm[0]; 1057 runlen = cnt; 1058 pixels += cnt; 1059 if (pixels > limit) 1060 goto error; 1061 1062 if (y < height) { /* only draw into visible area */ 1063 if (x >= width) { 1064 x += runlen; 1065 bm += 2; 1066 continue; 1067 } 1068 if (x + runlen > width) 1069 cnt = width - x; 1070 draw_bitmap(&fbp, bm, p, cnt, 1); 1071 x += runlen; 1072 } 1073 bm += 2; 1074 break; 1075 } 1076 } 1077 return 0; 1078 error: 1079 printf("Error: Too much encoded pixel data, validate your bitmap\n"); 1080 return -1; 1081 } 1082 #endif 1083 1084 /* 1085 * Display the BMP file located at address bmp_image. 1086 */ 1087 int video_display_bitmap(ulong bmp_image, int x, int y) 1088 { 1089 ushort xcount, ycount; 1090 uchar *fb; 1091 bmp_image_t *bmp = (bmp_image_t *) bmp_image; 1092 uchar *bmap; 1093 ushort padded_line; 1094 unsigned long width, height, bpp; 1095 unsigned colors; 1096 unsigned long compression; 1097 bmp_color_table_entry_t cte; 1098 1099 #ifdef CONFIG_VIDEO_BMP_GZIP 1100 unsigned char *dst = NULL; 1101 ulong len; 1102 #endif 1103 1104 WATCHDOG_RESET(); 1105 1106 if (!((bmp->header.signature[0] == 'B') && 1107 (bmp->header.signature[1] == 'M'))) { 1108 1109 #ifdef CONFIG_VIDEO_BMP_GZIP 1110 /* 1111 * Could be a gzipped bmp image, try to decrompress... 1112 */ 1113 len = CONFIG_SYS_VIDEO_LOGO_MAX_SIZE; 1114 dst = malloc(CONFIG_SYS_VIDEO_LOGO_MAX_SIZE); 1115 if (dst == NULL) { 1116 printf("Error: malloc in gunzip failed!\n"); 1117 return 1; 1118 } 1119 if (gunzip(dst, CONFIG_SYS_VIDEO_LOGO_MAX_SIZE, 1120 (uchar *) bmp_image, 1121 &len) != 0) { 1122 printf("Error: no valid bmp or bmp.gz image at %lx\n", 1123 bmp_image); 1124 free(dst); 1125 return 1; 1126 } 1127 if (len == CONFIG_SYS_VIDEO_LOGO_MAX_SIZE) { 1128 printf("Image could be truncated " 1129 "(increase CONFIG_SYS_VIDEO_LOGO_MAX_SIZE)!\n"); 1130 } 1131 1132 /* 1133 * Set addr to decompressed image 1134 */ 1135 bmp = (bmp_image_t *) dst; 1136 1137 if (!((bmp->header.signature[0] == 'B') && 1138 (bmp->header.signature[1] == 'M'))) { 1139 printf("Error: no valid bmp.gz image at %lx\n", 1140 bmp_image); 1141 free(dst); 1142 return 1; 1143 } 1144 #else 1145 printf("Error: no valid bmp image at %lx\n", bmp_image); 1146 return 1; 1147 #endif /* CONFIG_VIDEO_BMP_GZIP */ 1148 } 1149 1150 width = le32_to_cpu(bmp->header.width); 1151 height = le32_to_cpu(bmp->header.height); 1152 bpp = le16_to_cpu(bmp->header.bit_count); 1153 colors = le32_to_cpu(bmp->header.colors_used); 1154 compression = le32_to_cpu(bmp->header.compression); 1155 1156 debug("Display-bmp: %ld x %ld with %d colors\n", 1157 width, height, colors); 1158 1159 if (compression != BMP_BI_RGB 1160 #ifdef CONFIG_VIDEO_BMP_RLE8 1161 && compression != BMP_BI_RLE8 1162 #endif 1163 ) { 1164 printf("Error: compression type %ld not supported\n", 1165 compression); 1166 #ifdef CONFIG_VIDEO_BMP_GZIP 1167 if (dst) 1168 free(dst); 1169 #endif 1170 return 1; 1171 } 1172 1173 padded_line = (((width * bpp + 7) / 8) + 3) & ~0x3; 1174 1175 #ifdef CONFIG_SPLASH_SCREEN_ALIGN 1176 if (x == BMP_ALIGN_CENTER) 1177 x = max(0, (VIDEO_VISIBLE_COLS - width) / 2); 1178 else if (x < 0) 1179 x = max(0, VIDEO_VISIBLE_COLS - width + x + 1); 1180 1181 if (y == BMP_ALIGN_CENTER) 1182 y = max(0, (VIDEO_VISIBLE_ROWS - height) / 2); 1183 else if (y < 0) 1184 y = max(0, VIDEO_VISIBLE_ROWS - height + y + 1); 1185 #endif /* CONFIG_SPLASH_SCREEN_ALIGN */ 1186 1187 if ((x + width) > VIDEO_VISIBLE_COLS) 1188 width = VIDEO_VISIBLE_COLS - x; 1189 if ((y + height) > VIDEO_VISIBLE_ROWS) 1190 height = VIDEO_VISIBLE_ROWS - y; 1191 1192 bmap = (uchar *) bmp + le32_to_cpu(bmp->header.data_offset); 1193 fb = (uchar *) (video_fb_address + 1194 ((y + height - 1) * VIDEO_COLS * VIDEO_PIXEL_SIZE) + 1195 x * VIDEO_PIXEL_SIZE); 1196 1197 #ifdef CONFIG_VIDEO_BMP_RLE8 1198 if (compression == BMP_BI_RLE8) { 1199 return display_rle8_bitmap(bmp, x, y, width, height); 1200 } 1201 #endif 1202 1203 /* We handle only 4, 8, or 24 bpp bitmaps */ 1204 switch (le16_to_cpu(bmp->header.bit_count)) { 1205 case 4: 1206 padded_line -= width / 2; 1207 ycount = height; 1208 1209 switch (VIDEO_DATA_FORMAT) { 1210 case GDF_32BIT_X888RGB: 1211 while (ycount--) { 1212 WATCHDOG_RESET(); 1213 /* 1214 * Don't assume that 'width' is an 1215 * even number 1216 */ 1217 for (xcount = 0; xcount < width; xcount++) { 1218 uchar idx; 1219 1220 if (xcount & 1) { 1221 idx = *bmap & 0xF; 1222 bmap++; 1223 } else 1224 idx = *bmap >> 4; 1225 cte = bmp->color_table[idx]; 1226 FILL_32BIT_X888RGB(cte.red, cte.green, 1227 cte.blue); 1228 } 1229 bmap += padded_line; 1230 fb -= (VIDEO_VISIBLE_COLS + width) * 1231 VIDEO_PIXEL_SIZE; 1232 } 1233 break; 1234 default: 1235 puts("4bpp bitmap unsupported with current " 1236 "video mode\n"); 1237 break; 1238 } 1239 break; 1240 1241 case 8: 1242 padded_line -= width; 1243 if (VIDEO_DATA_FORMAT == GDF__8BIT_INDEX) { 1244 /* Copy colormap */ 1245 for (xcount = 0; xcount < colors; ++xcount) { 1246 cte = bmp->color_table[xcount]; 1247 video_set_lut(xcount, cte.red, cte.green, 1248 cte.blue); 1249 } 1250 } 1251 ycount = height; 1252 switch (VIDEO_DATA_FORMAT) { 1253 case GDF__8BIT_INDEX: 1254 while (ycount--) { 1255 WATCHDOG_RESET(); 1256 xcount = width; 1257 while (xcount--) { 1258 *fb++ = *bmap++; 1259 } 1260 bmap += padded_line; 1261 fb -= (VIDEO_VISIBLE_COLS + width) * 1262 VIDEO_PIXEL_SIZE; 1263 } 1264 break; 1265 case GDF__8BIT_332RGB: 1266 while (ycount--) { 1267 WATCHDOG_RESET(); 1268 xcount = width; 1269 while (xcount--) { 1270 cte = bmp->color_table[*bmap++]; 1271 FILL_8BIT_332RGB(cte.red, cte.green, 1272 cte.blue); 1273 } 1274 bmap += padded_line; 1275 fb -= (VIDEO_VISIBLE_COLS + width) * 1276 VIDEO_PIXEL_SIZE; 1277 } 1278 break; 1279 case GDF_15BIT_555RGB: 1280 while (ycount--) { 1281 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 1282 int xpos = x; 1283 #endif 1284 WATCHDOG_RESET(); 1285 xcount = width; 1286 while (xcount--) { 1287 cte = bmp->color_table[*bmap++]; 1288 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 1289 fill_555rgb_pswap(fb, xpos++, cte.red, 1290 cte.green, 1291 cte.blue); 1292 fb += 2; 1293 #else 1294 FILL_15BIT_555RGB(cte.red, cte.green, 1295 cte.blue); 1296 #endif 1297 } 1298 bmap += padded_line; 1299 fb -= (VIDEO_VISIBLE_COLS + width) * 1300 VIDEO_PIXEL_SIZE; 1301 } 1302 break; 1303 case GDF_16BIT_565RGB: 1304 while (ycount--) { 1305 WATCHDOG_RESET(); 1306 xcount = width; 1307 while (xcount--) { 1308 cte = bmp->color_table[*bmap++]; 1309 FILL_16BIT_565RGB(cte.red, cte.green, 1310 cte.blue); 1311 } 1312 bmap += padded_line; 1313 fb -= (VIDEO_VISIBLE_COLS + width) * 1314 VIDEO_PIXEL_SIZE; 1315 } 1316 break; 1317 case GDF_32BIT_X888RGB: 1318 while (ycount--) { 1319 WATCHDOG_RESET(); 1320 xcount = width; 1321 while (xcount--) { 1322 cte = bmp->color_table[*bmap++]; 1323 FILL_32BIT_X888RGB(cte.red, cte.green, 1324 cte.blue); 1325 } 1326 bmap += padded_line; 1327 fb -= (VIDEO_VISIBLE_COLS + width) * 1328 VIDEO_PIXEL_SIZE; 1329 } 1330 break; 1331 case GDF_24BIT_888RGB: 1332 while (ycount--) { 1333 WATCHDOG_RESET(); 1334 xcount = width; 1335 while (xcount--) { 1336 cte = bmp->color_table[*bmap++]; 1337 FILL_24BIT_888RGB(cte.red, cte.green, 1338 cte.blue); 1339 } 1340 bmap += padded_line; 1341 fb -= (VIDEO_VISIBLE_COLS + width) * 1342 VIDEO_PIXEL_SIZE; 1343 } 1344 break; 1345 } 1346 break; 1347 case 24: 1348 padded_line -= 3 * width; 1349 ycount = height; 1350 switch (VIDEO_DATA_FORMAT) { 1351 case GDF__8BIT_332RGB: 1352 while (ycount--) { 1353 WATCHDOG_RESET(); 1354 xcount = width; 1355 while (xcount--) { 1356 FILL_8BIT_332RGB(bmap[2], bmap[1], 1357 bmap[0]); 1358 bmap += 3; 1359 } 1360 bmap += padded_line; 1361 fb -= (VIDEO_VISIBLE_COLS + width) * 1362 VIDEO_PIXEL_SIZE; 1363 } 1364 break; 1365 case GDF_15BIT_555RGB: 1366 while (ycount--) { 1367 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 1368 int xpos = x; 1369 #endif 1370 WATCHDOG_RESET(); 1371 xcount = width; 1372 while (xcount--) { 1373 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 1374 fill_555rgb_pswap(fb, xpos++, bmap[2], 1375 bmap[1], bmap[0]); 1376 fb += 2; 1377 #else 1378 FILL_15BIT_555RGB(bmap[2], bmap[1], 1379 bmap[0]); 1380 #endif 1381 bmap += 3; 1382 } 1383 bmap += padded_line; 1384 fb -= (VIDEO_VISIBLE_COLS + width) * 1385 VIDEO_PIXEL_SIZE; 1386 } 1387 break; 1388 case GDF_16BIT_565RGB: 1389 while (ycount--) { 1390 WATCHDOG_RESET(); 1391 xcount = width; 1392 while (xcount--) { 1393 FILL_16BIT_565RGB(bmap[2], bmap[1], 1394 bmap[0]); 1395 bmap += 3; 1396 } 1397 bmap += padded_line; 1398 fb -= (VIDEO_VISIBLE_COLS + width) * 1399 VIDEO_PIXEL_SIZE; 1400 } 1401 break; 1402 case GDF_32BIT_X888RGB: 1403 while (ycount--) { 1404 WATCHDOG_RESET(); 1405 xcount = width; 1406 while (xcount--) { 1407 FILL_32BIT_X888RGB(bmap[2], bmap[1], 1408 bmap[0]); 1409 bmap += 3; 1410 } 1411 bmap += padded_line; 1412 fb -= (VIDEO_VISIBLE_COLS + width) * 1413 VIDEO_PIXEL_SIZE; 1414 } 1415 break; 1416 case GDF_24BIT_888RGB: 1417 while (ycount--) { 1418 WATCHDOG_RESET(); 1419 xcount = width; 1420 while (xcount--) { 1421 FILL_24BIT_888RGB(bmap[2], bmap[1], 1422 bmap[0]); 1423 bmap += 3; 1424 } 1425 bmap += padded_line; 1426 fb -= (VIDEO_VISIBLE_COLS + width) * 1427 VIDEO_PIXEL_SIZE; 1428 } 1429 break; 1430 default: 1431 printf("Error: 24 bits/pixel bitmap incompatible " 1432 "with current video mode\n"); 1433 break; 1434 } 1435 break; 1436 default: 1437 printf("Error: %d bit/pixel bitmaps not supported by U-Boot\n", 1438 le16_to_cpu(bmp->header.bit_count)); 1439 break; 1440 } 1441 1442 #ifdef CONFIG_VIDEO_BMP_GZIP 1443 if (dst) { 1444 free(dst); 1445 } 1446 #endif 1447 1448 return (0); 1449 } 1450 #endif 1451 1452 1453 #ifdef CONFIG_VIDEO_LOGO 1454 void logo_plot(void *screen, int width, int x, int y) 1455 { 1456 1457 int xcount, i; 1458 int skip = (width - VIDEO_LOGO_WIDTH) * VIDEO_PIXEL_SIZE; 1459 int ycount = video_logo_height; 1460 unsigned char r, g, b, *logo_red, *logo_blue, *logo_green; 1461 unsigned char *source; 1462 unsigned char *dest = (unsigned char *) screen + 1463 ((y * width * VIDEO_PIXEL_SIZE) + x * VIDEO_PIXEL_SIZE); 1464 1465 #ifdef CONFIG_VIDEO_BMP_LOGO 1466 source = bmp_logo_bitmap; 1467 1468 /* Allocate temporary space for computing colormap */ 1469 logo_red = malloc(BMP_LOGO_COLORS); 1470 logo_green = malloc(BMP_LOGO_COLORS); 1471 logo_blue = malloc(BMP_LOGO_COLORS); 1472 /* Compute color map */ 1473 for (i = 0; i < VIDEO_LOGO_COLORS; i++) { 1474 logo_red[i] = (bmp_logo_palette[i] & 0x0f00) >> 4; 1475 logo_green[i] = (bmp_logo_palette[i] & 0x00f0); 1476 logo_blue[i] = (bmp_logo_palette[i] & 0x000f) << 4; 1477 } 1478 #else 1479 source = linux_logo; 1480 logo_red = linux_logo_red; 1481 logo_green = linux_logo_green; 1482 logo_blue = linux_logo_blue; 1483 #endif 1484 1485 if (VIDEO_DATA_FORMAT == GDF__8BIT_INDEX) { 1486 for (i = 0; i < VIDEO_LOGO_COLORS; i++) { 1487 video_set_lut(i + VIDEO_LOGO_LUT_OFFSET, 1488 logo_red[i], logo_green[i], 1489 logo_blue[i]); 1490 } 1491 } 1492 1493 while (ycount--) { 1494 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 1495 int xpos = x; 1496 #endif 1497 xcount = VIDEO_LOGO_WIDTH; 1498 while (xcount--) { 1499 r = logo_red[*source - VIDEO_LOGO_LUT_OFFSET]; 1500 g = logo_green[*source - VIDEO_LOGO_LUT_OFFSET]; 1501 b = logo_blue[*source - VIDEO_LOGO_LUT_OFFSET]; 1502 1503 switch (VIDEO_DATA_FORMAT) { 1504 case GDF__8BIT_INDEX: 1505 *dest = *source; 1506 break; 1507 case GDF__8BIT_332RGB: 1508 *dest = ((r >> 5) << 5) | 1509 ((g >> 5) << 2) | 1510 (b >> 6); 1511 break; 1512 case GDF_15BIT_555RGB: 1513 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 1514 fill_555rgb_pswap(dest, xpos++, r, g, b); 1515 #else 1516 *(unsigned short *) dest = 1517 SWAP16((unsigned short) ( 1518 ((r >> 3) << 10) | 1519 ((g >> 3) << 5) | 1520 (b >> 3))); 1521 #endif 1522 break; 1523 case GDF_16BIT_565RGB: 1524 *(unsigned short *) dest = 1525 SWAP16((unsigned short) ( 1526 ((r >> 3) << 11) | 1527 ((g >> 2) << 5) | 1528 (b >> 3))); 1529 break; 1530 case GDF_32BIT_X888RGB: 1531 *(unsigned long *) dest = 1532 SWAP32((unsigned long) ( 1533 (r << 16) | 1534 (g << 8) | 1535 b)); 1536 break; 1537 case GDF_24BIT_888RGB: 1538 #ifdef VIDEO_FB_LITTLE_ENDIAN 1539 dest[0] = b; 1540 dest[1] = g; 1541 dest[2] = r; 1542 #else 1543 dest[0] = r; 1544 dest[1] = g; 1545 dest[2] = b; 1546 #endif 1547 break; 1548 } 1549 source++; 1550 dest += VIDEO_PIXEL_SIZE; 1551 } 1552 dest += skip; 1553 } 1554 #ifdef CONFIG_VIDEO_BMP_LOGO 1555 free(logo_red); 1556 free(logo_green); 1557 free(logo_blue); 1558 #endif 1559 } 1560 1561 static void *video_logo(void) 1562 { 1563 char info[128]; 1564 int space, len; 1565 __maybe_unused int y_off = 0; 1566 1567 #ifdef CONFIG_SPLASH_SCREEN 1568 char *s; 1569 ulong addr; 1570 1571 s = getenv("splashimage"); 1572 if (s != NULL) { 1573 int x = 0, y = 0; 1574 1575 addr = simple_strtoul(s, NULL, 16); 1576 #ifdef CONFIG_SPLASH_SCREEN_ALIGN 1577 s = getenv("splashpos"); 1578 if (s != NULL) { 1579 if (s[0] == 'm') 1580 x = BMP_ALIGN_CENTER; 1581 else 1582 x = simple_strtol(s, NULL, 0); 1583 1584 s = strchr(s + 1, ','); 1585 if (s != NULL) { 1586 if (s[1] == 'm') 1587 y = BMP_ALIGN_CENTER; 1588 else 1589 y = simple_strtol(s + 1, NULL, 0); 1590 } 1591 } 1592 #endif /* CONFIG_SPLASH_SCREEN_ALIGN */ 1593 1594 if (video_display_bitmap(addr, x, y) == 0) { 1595 video_logo_height = 0; 1596 return ((void *) (video_fb_address)); 1597 } 1598 } 1599 #endif /* CONFIG_SPLASH_SCREEN */ 1600 1601 logo_plot(video_fb_address, VIDEO_COLS, 0, 0); 1602 1603 sprintf(info, " %s", version_string); 1604 1605 space = (VIDEO_LINE_LEN / 2 - VIDEO_INFO_X) / VIDEO_FONT_WIDTH; 1606 len = strlen(info); 1607 1608 if (len > space) { 1609 video_drawchars(VIDEO_INFO_X, VIDEO_INFO_Y, 1610 (uchar *) info, space); 1611 video_drawchars(VIDEO_INFO_X + VIDEO_FONT_WIDTH, 1612 VIDEO_INFO_Y + VIDEO_FONT_HEIGHT, 1613 (uchar *) info + space, len - space); 1614 y_off = 1; 1615 } else 1616 video_drawstring(VIDEO_INFO_X, VIDEO_INFO_Y, (uchar *) info); 1617 1618 #ifdef CONFIG_CONSOLE_EXTRA_INFO 1619 { 1620 int i, n = 1621 ((video_logo_height - 1622 VIDEO_FONT_HEIGHT) / VIDEO_FONT_HEIGHT); 1623 1624 for (i = 1; i < n; i++) { 1625 video_get_info_str(i, info); 1626 if (!*info) 1627 continue; 1628 1629 len = strlen(info); 1630 if (len > space) { 1631 video_drawchars(VIDEO_INFO_X, 1632 VIDEO_INFO_Y + 1633 (i + y_off) * 1634 VIDEO_FONT_HEIGHT, 1635 (uchar *) info, space); 1636 y_off++; 1637 video_drawchars(VIDEO_INFO_X + 1638 VIDEO_FONT_WIDTH, 1639 VIDEO_INFO_Y + 1640 (i + y_off) * 1641 VIDEO_FONT_HEIGHT, 1642 (uchar *) info + space, 1643 len - space); 1644 } else { 1645 video_drawstring(VIDEO_INFO_X, 1646 VIDEO_INFO_Y + 1647 (i + y_off) * 1648 VIDEO_FONT_HEIGHT, 1649 (uchar *) info); 1650 } 1651 } 1652 } 1653 #endif 1654 1655 return (video_fb_address + video_logo_height * VIDEO_LINE_LEN); 1656 } 1657 #endif 1658 1659 static int video_init(void) 1660 { 1661 unsigned char color8; 1662 1663 pGD = video_hw_init(); 1664 if (pGD == NULL) 1665 return -1; 1666 1667 video_fb_address = (void *) VIDEO_FB_ADRS; 1668 #ifdef CONFIG_VIDEO_HW_CURSOR 1669 video_init_hw_cursor(VIDEO_FONT_WIDTH, VIDEO_FONT_HEIGHT); 1670 #endif 1671 1672 /* Init drawing pats */ 1673 switch (VIDEO_DATA_FORMAT) { 1674 case GDF__8BIT_INDEX: 1675 video_set_lut(0x01, CONSOLE_FG_COL, CONSOLE_FG_COL, 1676 CONSOLE_FG_COL); 1677 video_set_lut(0x00, CONSOLE_BG_COL, CONSOLE_BG_COL, 1678 CONSOLE_BG_COL); 1679 fgx = 0x01010101; 1680 bgx = 0x00000000; 1681 break; 1682 case GDF__8BIT_332RGB: 1683 color8 = ((CONSOLE_FG_COL & 0xe0) | 1684 ((CONSOLE_FG_COL >> 3) & 0x1c) | 1685 CONSOLE_FG_COL >> 6); 1686 fgx = (color8 << 24) | (color8 << 16) | (color8 << 8) | 1687 color8; 1688 color8 = ((CONSOLE_BG_COL & 0xe0) | 1689 ((CONSOLE_BG_COL >> 3) & 0x1c) | 1690 CONSOLE_BG_COL >> 6); 1691 bgx = (color8 << 24) | (color8 << 16) | (color8 << 8) | 1692 color8; 1693 break; 1694 case GDF_15BIT_555RGB: 1695 fgx = (((CONSOLE_FG_COL >> 3) << 26) | 1696 ((CONSOLE_FG_COL >> 3) << 21) | 1697 ((CONSOLE_FG_COL >> 3) << 16) | 1698 ((CONSOLE_FG_COL >> 3) << 10) | 1699 ((CONSOLE_FG_COL >> 3) << 5) | 1700 (CONSOLE_FG_COL >> 3)); 1701 bgx = (((CONSOLE_BG_COL >> 3) << 26) | 1702 ((CONSOLE_BG_COL >> 3) << 21) | 1703 ((CONSOLE_BG_COL >> 3) << 16) | 1704 ((CONSOLE_BG_COL >> 3) << 10) | 1705 ((CONSOLE_BG_COL >> 3) << 5) | 1706 (CONSOLE_BG_COL >> 3)); 1707 break; 1708 case GDF_16BIT_565RGB: 1709 fgx = (((CONSOLE_FG_COL >> 3) << 27) | 1710 ((CONSOLE_FG_COL >> 2) << 21) | 1711 ((CONSOLE_FG_COL >> 3) << 16) | 1712 ((CONSOLE_FG_COL >> 3) << 11) | 1713 ((CONSOLE_FG_COL >> 2) << 5) | 1714 (CONSOLE_FG_COL >> 3)); 1715 bgx = (((CONSOLE_BG_COL >> 3) << 27) | 1716 ((CONSOLE_BG_COL >> 2) << 21) | 1717 ((CONSOLE_BG_COL >> 3) << 16) | 1718 ((CONSOLE_BG_COL >> 3) << 11) | 1719 ((CONSOLE_BG_COL >> 2) << 5) | 1720 (CONSOLE_BG_COL >> 3)); 1721 break; 1722 case GDF_32BIT_X888RGB: 1723 fgx = (CONSOLE_FG_COL << 16) | 1724 (CONSOLE_FG_COL << 8) | 1725 CONSOLE_FG_COL; 1726 bgx = (CONSOLE_BG_COL << 16) | 1727 (CONSOLE_BG_COL << 8) | 1728 CONSOLE_BG_COL; 1729 break; 1730 case GDF_24BIT_888RGB: 1731 fgx = (CONSOLE_FG_COL << 24) | 1732 (CONSOLE_FG_COL << 16) | 1733 (CONSOLE_FG_COL << 8) | 1734 CONSOLE_FG_COL; 1735 bgx = (CONSOLE_BG_COL << 24) | 1736 (CONSOLE_BG_COL << 16) | 1737 (CONSOLE_BG_COL << 8) | 1738 CONSOLE_BG_COL; 1739 break; 1740 } 1741 eorx = fgx ^ bgx; 1742 1743 #ifdef CONFIG_VIDEO_LOGO 1744 /* Plot the logo and get start point of console */ 1745 debug("Video: Drawing the logo ...\n"); 1746 video_console_address = video_logo(); 1747 #else 1748 video_console_address = video_fb_address; 1749 #endif 1750 1751 /* Initialize the console */ 1752 console_col = 0; 1753 console_row = 0; 1754 1755 return 0; 1756 } 1757 1758 /* 1759 * Implement a weak default function for boards that optionally 1760 * need to skip the video initialization. 1761 */ 1762 int __board_video_skip(void) 1763 { 1764 /* As default, don't skip test */ 1765 return 0; 1766 } 1767 1768 int board_video_skip(void) 1769 __attribute__ ((weak, alias("__board_video_skip"))); 1770 1771 int drv_video_init(void) 1772 { 1773 int skip_dev_init; 1774 struct stdio_dev console_dev; 1775 1776 /* Check if video initialization should be skipped */ 1777 if (board_video_skip()) 1778 return 0; 1779 1780 /* Init video chip - returns with framebuffer cleared */ 1781 skip_dev_init = (video_init() == -1); 1782 1783 #if !defined(CONFIG_VGA_AS_SINGLE_DEVICE) 1784 debug("KBD: Keyboard init ...\n"); 1785 skip_dev_init |= (VIDEO_KBD_INIT_FCT == -1); 1786 #endif 1787 1788 if (skip_dev_init) 1789 return 0; 1790 1791 /* Init vga device */ 1792 memset(&console_dev, 0, sizeof(console_dev)); 1793 strcpy(console_dev.name, "vga"); 1794 console_dev.ext = DEV_EXT_VIDEO; /* Video extensions */ 1795 console_dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_SYSTEM; 1796 console_dev.putc = video_putc; /* 'putc' function */ 1797 console_dev.puts = video_puts; /* 'puts' function */ 1798 console_dev.tstc = NULL; /* 'tstc' function */ 1799 console_dev.getc = NULL; /* 'getc' function */ 1800 1801 #if !defined(CONFIG_VGA_AS_SINGLE_DEVICE) 1802 /* Also init console device */ 1803 console_dev.flags |= DEV_FLAGS_INPUT; 1804 console_dev.tstc = VIDEO_TSTC_FCT; /* 'tstc' function */ 1805 console_dev.getc = VIDEO_GETC_FCT; /* 'getc' function */ 1806 #endif /* CONFIG_VGA_AS_SINGLE_DEVICE */ 1807 1808 if (stdio_register(&console_dev) != 0) 1809 return 0; 1810 1811 /* Return success */ 1812 return 1; 1813 } 1814