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 normaly goes to serial port) can be drawed. 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 delay 63 loop in VIDEO_TSTC_FCT (i8042) 64 CONFIG_SYS_CONSOLE_BLINK_COUNT - value for delay loop - blink rate 65 CONFIG_CONSOLE_TIME - display time/date in upper right corner, 66 needs CONFIG_CMD_DATE and CONFIG_CONSOLE_CURSOR 67 CONFIG_VIDEO_LOGO - display Linux Logo in upper left corner 68 CONFIG_VIDEO_BMP_LOGO - use bmp_logo instead of linux_logo 69 CONFIG_CONSOLE_EXTRA_INFO - display additional board information strings 70 that normaly goes to serial port. This define 71 requires a board specific function: 72 video_drawstring (VIDEO_INFO_X, 73 VIDEO_INFO_Y + i*VIDEO_FONT_HEIGHT, 74 info); 75 that fills a info buffer at i=row. 76 s.a: board/eltec/bab7xx. 77 CONFIG_VGA_AS_SINGLE_DEVICE - If set the framebuffer device will be initialised 78 as an output only device. The Keyboard driver 79 will not be set-up. This may be used, if you 80 have none or more than one Keyboard devices 81 (USB Keyboard, AT Keyboard). 82 83 CONFIG_VIDEO_SW_CURSOR: - Draws a cursor after the last character. No 84 blinking is provided. Uses the macros CURSOR_SET 85 and CURSOR_OFF. 86 CONFIG_VIDEO_HW_CURSOR: - Uses the hardware cursor capability of the 87 graphic chip. Uses the macro CURSOR_SET. 88 ATTENTION: If booting an OS, the display driver 89 must disable the hardware register of the graphic 90 chip. Otherwise a blinking field is displayed 91 */ 92 93 #include <common.h> 94 95 #include <malloc.h> 96 97 /*****************************************************************************/ 98 /* Console device defines with SMI graphic */ 99 /* Any other graphic must change this section */ 100 /*****************************************************************************/ 101 102 #ifdef CONFIG_VIDEO_SMI_LYNXEM 103 104 #define VIDEO_FB_LITTLE_ENDIAN 105 #define VIDEO_HW_RECTFILL 106 #define VIDEO_HW_BITBLT 107 #endif 108 109 /*****************************************************************************/ 110 /* Defines for the CT69000 driver */ 111 /*****************************************************************************/ 112 #ifdef CONFIG_VIDEO_CT69000 113 114 #define VIDEO_FB_LITTLE_ENDIAN 115 #define VIDEO_HW_RECTFILL 116 #define VIDEO_HW_BITBLT 117 #endif 118 119 /*****************************************************************************/ 120 /* Defines for the SED13806 driver */ 121 /*****************************************************************************/ 122 #ifdef CONFIG_VIDEO_SED13806 123 124 #ifndef CONFIG_TOTAL5200 125 #define VIDEO_FB_LITTLE_ENDIAN 126 #endif 127 #define VIDEO_HW_RECTFILL 128 #define VIDEO_HW_BITBLT 129 #endif 130 131 /*****************************************************************************/ 132 /* Defines for the SED13806 driver */ 133 /*****************************************************************************/ 134 #ifdef CONFIG_VIDEO_SM501 135 136 #ifdef CONFIG_HH405 137 #define VIDEO_FB_LITTLE_ENDIAN 138 #endif 139 #endif 140 141 /*****************************************************************************/ 142 /* Defines for the MB862xx driver */ 143 /*****************************************************************************/ 144 #ifdef CONFIG_VIDEO_MB862xx 145 146 #ifdef CONFIG_VIDEO_CORALP 147 #define VIDEO_FB_LITTLE_ENDIAN 148 #endif 149 #define VIDEO_HW_RECTFILL 150 #define VIDEO_HW_BITBLT 151 #endif 152 153 /*****************************************************************************/ 154 /* Include video_fb.h after definitions of VIDEO_HW_RECTFILL etc */ 155 /*****************************************************************************/ 156 #include <video_fb.h> 157 158 /*****************************************************************************/ 159 /* some Macros */ 160 /*****************************************************************************/ 161 #define VIDEO_VISIBLE_COLS (pGD->winSizeX) 162 #define VIDEO_VISIBLE_ROWS (pGD->winSizeY) 163 #define VIDEO_PIXEL_SIZE (pGD->gdfBytesPP) 164 #define VIDEO_DATA_FORMAT (pGD->gdfIndex) 165 #define VIDEO_FB_ADRS (pGD->frameAdrs) 166 167 /*****************************************************************************/ 168 /* Console device defines with i8042 keyboard controller */ 169 /* Any other keyboard controller must change this section */ 170 /*****************************************************************************/ 171 172 #ifdef CONFIG_I8042_KBD 173 #include <i8042.h> 174 175 #define VIDEO_KBD_INIT_FCT i8042_kbd_init() 176 #define VIDEO_TSTC_FCT i8042_tstc 177 #define VIDEO_GETC_FCT i8042_getc 178 #endif 179 180 /*****************************************************************************/ 181 /* Console device */ 182 /*****************************************************************************/ 183 184 #include <version.h> 185 #include <linux/types.h> 186 #include <stdio_dev.h> 187 #include <video_font.h> 188 189 #if defined(CONFIG_CMD_DATE) 190 #include <rtc.h> 191 #endif 192 193 #if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN) 194 #include <watchdog.h> 195 #include <bmp_layout.h> 196 197 #ifdef CONFIG_SPLASH_SCREEN_ALIGN 198 #define BMP_ALIGN_CENTER 0x7FFF 199 #endif 200 201 #endif 202 203 /*****************************************************************************/ 204 /* Cursor definition: */ 205 /* CONFIG_CONSOLE_CURSOR: Uses a timer function (see drivers/input/i8042.c) */ 206 /* to let the cursor blink. Uses the macros */ 207 /* CURSOR_OFF and CURSOR_ON. */ 208 /* CONFIG_VIDEO_SW_CURSOR: Draws a cursor after the last character. No */ 209 /* blinking is provided. Uses the macros CURSOR_SET */ 210 /* and CURSOR_OFF. */ 211 /* CONFIG_VIDEO_HW_CURSOR: Uses the hardware cursor capability of the */ 212 /* graphic chip. Uses the macro CURSOR_SET. */ 213 /* ATTENTION: If booting an OS, the display driver */ 214 /* must disable the hardware register of the graphic */ 215 /* chip. Otherwise a blinking field is displayed */ 216 /*****************************************************************************/ 217 #if !defined(CONFIG_CONSOLE_CURSOR) && \ 218 !defined(CONFIG_VIDEO_SW_CURSOR) && \ 219 !defined(CONFIG_VIDEO_HW_CURSOR) 220 /* no Cursor defined */ 221 #define CURSOR_ON 222 #define CURSOR_OFF 223 #define CURSOR_SET 224 #endif 225 226 #ifdef CONFIG_CONSOLE_CURSOR 227 #ifdef CURSOR_ON 228 #error only one of CONFIG_CONSOLE_CURSOR,CONFIG_VIDEO_SW_CURSOR,CONFIG_VIDEO_HW_CURSOR can be defined 229 #endif 230 void console_cursor (int state); 231 #define CURSOR_ON console_cursor(1); 232 #define CURSOR_OFF console_cursor(0); 233 #define CURSOR_SET 234 #ifndef CONFIG_I8042_KBD 235 #warning Cursor drawing on/off needs timer function s.a. drivers/input/i8042.c 236 #endif 237 #else 238 #ifdef CONFIG_CONSOLE_TIME 239 #error CONFIG_CONSOLE_CURSOR must be defined for CONFIG_CONSOLE_TIME 240 #endif 241 #endif /* CONFIG_CONSOLE_CURSOR */ 242 243 #ifdef CONFIG_VIDEO_SW_CURSOR 244 #ifdef CURSOR_ON 245 #error only one of CONFIG_CONSOLE_CURSOR,CONFIG_VIDEO_SW_CURSOR,CONFIG_VIDEO_HW_CURSOR can be defined 246 #endif 247 #define CURSOR_ON 248 #define CURSOR_OFF video_putchar(console_col * VIDEO_FONT_WIDTH,\ 249 console_row * VIDEO_FONT_HEIGHT, ' '); 250 #define CURSOR_SET video_set_cursor(); 251 #endif /* CONFIG_VIDEO_SW_CURSOR */ 252 253 254 #ifdef CONFIG_VIDEO_HW_CURSOR 255 #ifdef CURSOR_ON 256 #error only one of CONFIG_CONSOLE_CURSOR,CONFIG_VIDEO_SW_CURSOR,CONFIG_VIDEO_HW_CURSOR can be defined 257 #endif 258 #define CURSOR_ON 259 #define CURSOR_OFF 260 #define CURSOR_SET video_set_hw_cursor(console_col * VIDEO_FONT_WIDTH, \ 261 (console_row * VIDEO_FONT_HEIGHT) + VIDEO_LOGO_HEIGHT); 262 #endif /* CONFIG_VIDEO_HW_CURSOR */ 263 264 #ifdef CONFIG_VIDEO_LOGO 265 #ifdef CONFIG_VIDEO_BMP_LOGO 266 #include <bmp_logo.h> 267 #define VIDEO_LOGO_WIDTH BMP_LOGO_WIDTH 268 #define VIDEO_LOGO_HEIGHT BMP_LOGO_HEIGHT 269 #define VIDEO_LOGO_LUT_OFFSET BMP_LOGO_OFFSET 270 #define VIDEO_LOGO_COLORS BMP_LOGO_COLORS 271 272 #else /* CONFIG_VIDEO_BMP_LOGO */ 273 #define LINUX_LOGO_WIDTH 80 274 #define LINUX_LOGO_HEIGHT 80 275 #define LINUX_LOGO_COLORS 214 276 #define LINUX_LOGO_LUT_OFFSET 0x20 277 #define __initdata 278 #include <linux_logo.h> 279 #define VIDEO_LOGO_WIDTH LINUX_LOGO_WIDTH 280 #define VIDEO_LOGO_HEIGHT LINUX_LOGO_HEIGHT 281 #define VIDEO_LOGO_LUT_OFFSET LINUX_LOGO_LUT_OFFSET 282 #define VIDEO_LOGO_COLORS LINUX_LOGO_COLORS 283 #endif /* CONFIG_VIDEO_BMP_LOGO */ 284 #define VIDEO_INFO_X (VIDEO_LOGO_WIDTH) 285 #define VIDEO_INFO_Y (VIDEO_FONT_HEIGHT/2) 286 #else /* CONFIG_VIDEO_LOGO */ 287 #define VIDEO_LOGO_WIDTH 0 288 #define VIDEO_LOGO_HEIGHT 0 289 #endif /* CONFIG_VIDEO_LOGO */ 290 291 #define VIDEO_COLS VIDEO_VISIBLE_COLS 292 #define VIDEO_ROWS VIDEO_VISIBLE_ROWS 293 #define VIDEO_SIZE (VIDEO_ROWS*VIDEO_COLS*VIDEO_PIXEL_SIZE) 294 #define VIDEO_PIX_BLOCKS (VIDEO_SIZE >> 2) 295 #define VIDEO_LINE_LEN (VIDEO_COLS*VIDEO_PIXEL_SIZE) 296 #define VIDEO_BURST_LEN (VIDEO_COLS/8) 297 298 #ifdef CONFIG_VIDEO_LOGO 299 #define CONSOLE_ROWS ((VIDEO_ROWS - VIDEO_LOGO_HEIGHT) / VIDEO_FONT_HEIGHT) 300 #else 301 #define CONSOLE_ROWS (VIDEO_ROWS / VIDEO_FONT_HEIGHT) 302 #endif 303 304 #define CONSOLE_COLS (VIDEO_COLS / VIDEO_FONT_WIDTH) 305 #define CONSOLE_ROW_SIZE (VIDEO_FONT_HEIGHT * VIDEO_LINE_LEN) 306 #define CONSOLE_ROW_FIRST (video_console_address) 307 #define CONSOLE_ROW_SECOND (video_console_address + CONSOLE_ROW_SIZE) 308 #define CONSOLE_ROW_LAST (video_console_address + CONSOLE_SIZE - CONSOLE_ROW_SIZE) 309 #define CONSOLE_SIZE (CONSOLE_ROW_SIZE * CONSOLE_ROWS) 310 #define CONSOLE_SCROLL_SIZE (CONSOLE_SIZE - CONSOLE_ROW_SIZE) 311 312 /* Macros */ 313 #ifdef VIDEO_FB_LITTLE_ENDIAN 314 #define SWAP16(x) ((((x) & 0x00ff) << 8) | ( (x) >> 8)) 315 #define SWAP32(x) ((((x) & 0x000000ff) << 24) | (((x) & 0x0000ff00) << 8)|\ 316 (((x) & 0x00ff0000) >> 8) | (((x) & 0xff000000) >> 24) ) 317 #define SHORTSWAP32(x) ((((x) & 0x000000ff) << 8) | (((x) & 0x0000ff00) >> 8)|\ 318 (((x) & 0x00ff0000) << 8) | (((x) & 0xff000000) >> 8) ) 319 #else 320 #define SWAP16(x) (x) 321 #define SWAP32(x) (x) 322 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 323 #define SHORTSWAP32(x) ( ((x) >> 16) | ((x) << 16) ) 324 #else 325 #define SHORTSWAP32(x) (x) 326 #endif 327 #endif 328 329 #if defined(DEBUG) || defined(DEBUG_CFB_CONSOLE) 330 #define PRINTD(x) printf(x) 331 #else 332 #define PRINTD(x) 333 #endif 334 335 336 #ifdef CONFIG_CONSOLE_EXTRA_INFO 337 extern void video_get_info_str ( /* setup a board string: type, speed, etc. */ 338 int line_number, /* location to place info string beside logo */ 339 char *info /* buffer for info string */ 340 ); 341 342 #endif 343 344 /* Locals */ 345 static GraphicDevice *pGD; /* Pointer to Graphic array */ 346 347 static void *video_fb_address; /* frame buffer address */ 348 static void *video_console_address; /* console buffer start address */ 349 350 static int console_col = 0; /* cursor col */ 351 static int console_row = 0; /* cursor row */ 352 353 static u32 eorx, fgx, bgx; /* color pats */ 354 355 static const int video_font_draw_table8[] = { 356 0x00000000, 0x000000ff, 0x0000ff00, 0x0000ffff, 357 0x00ff0000, 0x00ff00ff, 0x00ffff00, 0x00ffffff, 358 0xff000000, 0xff0000ff, 0xff00ff00, 0xff00ffff, 359 0xffff0000, 0xffff00ff, 0xffffff00, 0xffffffff }; 360 361 static const int video_font_draw_table15[] = { 362 0x00000000, 0x00007fff, 0x7fff0000, 0x7fff7fff }; 363 364 static const int video_font_draw_table16[] = { 365 0x00000000, 0x0000ffff, 0xffff0000, 0xffffffff }; 366 367 static const int video_font_draw_table24[16][3] = { 368 { 0x00000000, 0x00000000, 0x00000000 }, 369 { 0x00000000, 0x00000000, 0x00ffffff }, 370 { 0x00000000, 0x0000ffff, 0xff000000 }, 371 { 0x00000000, 0x0000ffff, 0xffffffff }, 372 { 0x000000ff, 0xffff0000, 0x00000000 }, 373 { 0x000000ff, 0xffff0000, 0x00ffffff }, 374 { 0x000000ff, 0xffffffff, 0xff000000 }, 375 { 0x000000ff, 0xffffffff, 0xffffffff }, 376 { 0xffffff00, 0x00000000, 0x00000000 }, 377 { 0xffffff00, 0x00000000, 0x00ffffff }, 378 { 0xffffff00, 0x0000ffff, 0xff000000 }, 379 { 0xffffff00, 0x0000ffff, 0xffffffff }, 380 { 0xffffffff, 0xffff0000, 0x00000000 }, 381 { 0xffffffff, 0xffff0000, 0x00ffffff }, 382 { 0xffffffff, 0xffffffff, 0xff000000 }, 383 { 0xffffffff, 0xffffffff, 0xffffffff } }; 384 385 static const int video_font_draw_table32[16][4] = { 386 { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, 387 { 0x00000000, 0x00000000, 0x00000000, 0x00ffffff }, 388 { 0x00000000, 0x00000000, 0x00ffffff, 0x00000000 }, 389 { 0x00000000, 0x00000000, 0x00ffffff, 0x00ffffff }, 390 { 0x00000000, 0x00ffffff, 0x00000000, 0x00000000 }, 391 { 0x00000000, 0x00ffffff, 0x00000000, 0x00ffffff }, 392 { 0x00000000, 0x00ffffff, 0x00ffffff, 0x00000000 }, 393 { 0x00000000, 0x00ffffff, 0x00ffffff, 0x00ffffff }, 394 { 0x00ffffff, 0x00000000, 0x00000000, 0x00000000 }, 395 { 0x00ffffff, 0x00000000, 0x00000000, 0x00ffffff }, 396 { 0x00ffffff, 0x00000000, 0x00ffffff, 0x00000000 }, 397 { 0x00ffffff, 0x00000000, 0x00ffffff, 0x00ffffff }, 398 { 0x00ffffff, 0x00ffffff, 0x00000000, 0x00000000 }, 399 { 0x00ffffff, 0x00ffffff, 0x00000000, 0x00ffffff }, 400 { 0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00000000 }, 401 { 0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00ffffff } }; 402 403 404 int gunzip(void *, int, unsigned char *, unsigned long *); 405 406 /******************************************************************************/ 407 408 static void video_drawchars (int xx, int yy, unsigned char *s, int count) 409 { 410 u8 *cdat, *dest, *dest0; 411 int rows, offset, c; 412 413 offset = yy * VIDEO_LINE_LEN + xx * VIDEO_PIXEL_SIZE; 414 dest0 = video_fb_address + offset; 415 416 switch (VIDEO_DATA_FORMAT) { 417 case GDF__8BIT_INDEX: 418 case GDF__8BIT_332RGB: 419 while (count--) { 420 c = *s; 421 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT; 422 for (rows = VIDEO_FONT_HEIGHT, dest = dest0; 423 rows--; 424 dest += VIDEO_LINE_LEN) { 425 u8 bits = *cdat++; 426 427 ((u32 *) dest)[0] = (video_font_draw_table8[bits >> 4] & eorx) ^ bgx; 428 ((u32 *) dest)[1] = (video_font_draw_table8[bits & 15] & eorx) ^ bgx; 429 } 430 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE; 431 s++; 432 } 433 break; 434 435 case GDF_15BIT_555RGB: 436 while (count--) { 437 c = *s; 438 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT; 439 for (rows = VIDEO_FONT_HEIGHT, dest = dest0; 440 rows--; 441 dest += VIDEO_LINE_LEN) { 442 u8 bits = *cdat++; 443 444 ((u32 *) dest)[0] = SHORTSWAP32 ((video_font_draw_table15 [bits >> 6] & eorx) ^ bgx); 445 ((u32 *) dest)[1] = SHORTSWAP32 ((video_font_draw_table15 [bits >> 4 & 3] & eorx) ^ bgx); 446 ((u32 *) dest)[2] = SHORTSWAP32 ((video_font_draw_table15 [bits >> 2 & 3] & eorx) ^ bgx); 447 ((u32 *) dest)[3] = SHORTSWAP32 ((video_font_draw_table15 [bits & 3] & eorx) ^ bgx); 448 } 449 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE; 450 s++; 451 } 452 break; 453 454 case GDF_16BIT_565RGB: 455 while (count--) { 456 c = *s; 457 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT; 458 for (rows = VIDEO_FONT_HEIGHT, dest = dest0; 459 rows--; 460 dest += VIDEO_LINE_LEN) { 461 u8 bits = *cdat++; 462 463 ((u32 *) dest)[0] = SHORTSWAP32 ((video_font_draw_table16 [bits >> 6] & eorx) ^ bgx); 464 ((u32 *) dest)[1] = SHORTSWAP32 ((video_font_draw_table16 [bits >> 4 & 3] & eorx) ^ bgx); 465 ((u32 *) dest)[2] = SHORTSWAP32 ((video_font_draw_table16 [bits >> 2 & 3] & eorx) ^ bgx); 466 ((u32 *) dest)[3] = SHORTSWAP32 ((video_font_draw_table16 [bits & 3] & eorx) ^ bgx); 467 } 468 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE; 469 s++; 470 } 471 break; 472 473 case GDF_32BIT_X888RGB: 474 while (count--) { 475 c = *s; 476 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT; 477 for (rows = VIDEO_FONT_HEIGHT, dest = dest0; 478 rows--; 479 dest += VIDEO_LINE_LEN) { 480 u8 bits = *cdat++; 481 482 ((u32 *) dest)[0] = SWAP32 ((video_font_draw_table32 [bits >> 4][0] & eorx) ^ bgx); 483 ((u32 *) dest)[1] = SWAP32 ((video_font_draw_table32 [bits >> 4][1] & eorx) ^ bgx); 484 ((u32 *) dest)[2] = SWAP32 ((video_font_draw_table32 [bits >> 4][2] & eorx) ^ bgx); 485 ((u32 *) dest)[3] = SWAP32 ((video_font_draw_table32 [bits >> 4][3] & eorx) ^ bgx); 486 ((u32 *) dest)[4] = SWAP32 ((video_font_draw_table32 [bits & 15][0] & eorx) ^ bgx); 487 ((u32 *) dest)[5] = SWAP32 ((video_font_draw_table32 [bits & 15][1] & eorx) ^ bgx); 488 ((u32 *) dest)[6] = SWAP32 ((video_font_draw_table32 [bits & 15][2] & eorx) ^ bgx); 489 ((u32 *) dest)[7] = SWAP32 ((video_font_draw_table32 [bits & 15][3] & eorx) ^ bgx); 490 } 491 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE; 492 s++; 493 } 494 break; 495 496 case GDF_24BIT_888RGB: 497 while (count--) { 498 c = *s; 499 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT; 500 for (rows = VIDEO_FONT_HEIGHT, dest = dest0; 501 rows--; 502 dest += VIDEO_LINE_LEN) { 503 u8 bits = *cdat++; 504 505 ((u32 *) dest)[0] = (video_font_draw_table24[bits >> 4][0] & eorx) ^ bgx; 506 ((u32 *) dest)[1] = (video_font_draw_table24[bits >> 4][1] & eorx) ^ bgx; 507 ((u32 *) dest)[2] = (video_font_draw_table24[bits >> 4][2] & eorx) ^ bgx; 508 ((u32 *) dest)[3] = (video_font_draw_table24[bits & 15][0] & eorx) ^ bgx; 509 ((u32 *) dest)[4] = (video_font_draw_table24[bits & 15][1] & eorx) ^ bgx; 510 ((u32 *) dest)[5] = (video_font_draw_table24[bits & 15][2] & eorx) ^ bgx; 511 } 512 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE; 513 s++; 514 } 515 break; 516 } 517 } 518 519 /*****************************************************************************/ 520 521 static inline void video_drawstring (int xx, int yy, unsigned char *s) 522 { 523 video_drawchars (xx, yy, s, strlen ((char *)s)); 524 } 525 526 /*****************************************************************************/ 527 528 static void video_putchar (int xx, int yy, unsigned char c) 529 { 530 video_drawchars (xx, yy + VIDEO_LOGO_HEIGHT, &c, 1); 531 } 532 533 /*****************************************************************************/ 534 #if defined(CONFIG_CONSOLE_CURSOR) || defined(CONFIG_VIDEO_SW_CURSOR) 535 static void video_set_cursor (void) 536 { 537 /* swap drawing colors */ 538 eorx = fgx; 539 fgx = bgx; 540 bgx = eorx; 541 eorx = fgx ^ bgx; 542 /* draw cursor */ 543 video_putchar (console_col * VIDEO_FONT_WIDTH, 544 console_row * VIDEO_FONT_HEIGHT, 545 ' '); 546 /* restore drawing colors */ 547 eorx = fgx; 548 fgx = bgx; 549 bgx = eorx; 550 eorx = fgx ^ bgx; 551 } 552 #endif 553 /*****************************************************************************/ 554 #ifdef CONFIG_CONSOLE_CURSOR 555 void console_cursor (int state) 556 { 557 static int last_state = 0; 558 559 #ifdef CONFIG_CONSOLE_TIME 560 struct rtc_time tm; 561 char info[16]; 562 563 /* time update only if cursor is on (faster scroll) */ 564 if (state) { 565 rtc_get (&tm); 566 567 sprintf (info, " %02d:%02d:%02d ", tm.tm_hour, tm.tm_min, 568 tm.tm_sec); 569 video_drawstring (VIDEO_VISIBLE_COLS - 10 * VIDEO_FONT_WIDTH, 570 VIDEO_INFO_Y, (uchar *)info); 571 572 sprintf (info, "%02d.%02d.%04d", tm.tm_mday, tm.tm_mon, 573 tm.tm_year); 574 video_drawstring (VIDEO_VISIBLE_COLS - 10 * VIDEO_FONT_WIDTH, 575 VIDEO_INFO_Y + 1 * VIDEO_FONT_HEIGHT, (uchar *)info); 576 } 577 #endif 578 579 if (state && (last_state != state)) { 580 video_set_cursor (); 581 } 582 583 if (!state && (last_state != state)) { 584 /* clear cursor */ 585 video_putchar (console_col * VIDEO_FONT_WIDTH, 586 console_row * VIDEO_FONT_HEIGHT, 587 ' '); 588 } 589 590 last_state = state; 591 } 592 #endif 593 594 /*****************************************************************************/ 595 596 #ifndef VIDEO_HW_RECTFILL 597 static void memsetl (int *p, int c, int v) 598 { 599 while (c--) 600 *(p++) = v; 601 } 602 #endif 603 604 /*****************************************************************************/ 605 606 #ifndef VIDEO_HW_BITBLT 607 static void memcpyl (int *d, int *s, int c) 608 { 609 while (c--) 610 *(d++) = *(s++); 611 } 612 #endif 613 614 /*****************************************************************************/ 615 616 static void console_scrollup (void) 617 { 618 /* copy up rows ignoring the first one */ 619 620 #ifdef VIDEO_HW_BITBLT 621 video_hw_bitblt (VIDEO_PIXEL_SIZE, /* bytes per pixel */ 622 0, /* source pos x */ 623 VIDEO_LOGO_HEIGHT + VIDEO_FONT_HEIGHT, /* source pos y */ 624 0, /* dest pos x */ 625 VIDEO_LOGO_HEIGHT, /* dest pos y */ 626 VIDEO_VISIBLE_COLS, /* frame width */ 627 VIDEO_VISIBLE_ROWS - VIDEO_LOGO_HEIGHT - VIDEO_FONT_HEIGHT /* frame height */ 628 ); 629 #else 630 memcpyl (CONSOLE_ROW_FIRST, CONSOLE_ROW_SECOND, 631 CONSOLE_SCROLL_SIZE >> 2); 632 #endif 633 634 /* clear the last one */ 635 #ifdef VIDEO_HW_RECTFILL 636 video_hw_rectfill (VIDEO_PIXEL_SIZE, /* bytes per pixel */ 637 0, /* dest pos x */ 638 VIDEO_VISIBLE_ROWS - VIDEO_FONT_HEIGHT, /* dest pos y */ 639 VIDEO_VISIBLE_COLS, /* frame width */ 640 VIDEO_FONT_HEIGHT, /* frame height */ 641 CONSOLE_BG_COL /* fill color */ 642 ); 643 #else 644 memsetl (CONSOLE_ROW_LAST, CONSOLE_ROW_SIZE >> 2, CONSOLE_BG_COL); 645 #endif 646 } 647 648 /*****************************************************************************/ 649 650 static void console_back (void) 651 { 652 CURSOR_OFF console_col--; 653 654 if (console_col < 0) { 655 console_col = CONSOLE_COLS - 1; 656 console_row--; 657 if (console_row < 0) 658 console_row = 0; 659 } 660 video_putchar (console_col * VIDEO_FONT_WIDTH, 661 console_row * VIDEO_FONT_HEIGHT, 662 ' '); 663 } 664 665 /*****************************************************************************/ 666 667 static void console_newline (void) 668 { 669 /* Check if last character in the line was just drawn. If so, cursor was 670 overwriten and need not to be cleared. Cursor clearing without this 671 check causes overwriting the 1st character of the line if line lenght 672 is >= CONSOLE_COLS 673 */ 674 if (console_col < CONSOLE_COLS) 675 CURSOR_OFF 676 console_row++; 677 console_col = 0; 678 679 /* Check if we need to scroll the terminal */ 680 if (console_row >= CONSOLE_ROWS) { 681 /* Scroll everything up */ 682 console_scrollup (); 683 684 /* Decrement row number */ 685 console_row--; 686 } 687 } 688 689 static void console_cr (void) 690 { 691 CURSOR_OFF console_col = 0; 692 } 693 694 /*****************************************************************************/ 695 696 void video_putc (const char c) 697 { 698 static int nl = 1; 699 700 switch (c) { 701 case 13: /* back to first column */ 702 console_cr (); 703 break; 704 705 case '\n': /* next line */ 706 if (console_col || (!console_col && nl)) 707 console_newline (); 708 nl = 1; 709 break; 710 711 case 9: /* tab 8 */ 712 CURSOR_OFF console_col |= 0x0008; 713 console_col &= ~0x0007; 714 715 if (console_col >= CONSOLE_COLS) 716 console_newline (); 717 break; 718 719 case 8: /* backspace */ 720 console_back (); 721 break; 722 723 default: /* draw the char */ 724 video_putchar (console_col * VIDEO_FONT_WIDTH, 725 console_row * VIDEO_FONT_HEIGHT, 726 c); 727 console_col++; 728 729 /* check for newline */ 730 if (console_col >= CONSOLE_COLS) { 731 console_newline (); 732 nl = 0; 733 } 734 } 735 CURSOR_SET} 736 737 738 /*****************************************************************************/ 739 740 void video_puts (const char *s) 741 { 742 int count = strlen (s); 743 744 while (count--) 745 video_putc (*s++); 746 } 747 748 /*****************************************************************************/ 749 750 #if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN) 751 752 #define FILL_8BIT_332RGB(r,g,b) { \ 753 *fb = ((r>>5)<<5) | ((g>>5)<<2) | (b>>6); \ 754 fb ++; \ 755 } 756 757 #define FILL_15BIT_555RGB(r,g,b) { \ 758 *(unsigned short *)fb = SWAP16((unsigned short)(((r>>3)<<10) | ((g>>3)<<5) | (b>>3))); \ 759 fb += 2; \ 760 } 761 762 #define FILL_16BIT_565RGB(r,g,b) { \ 763 *(unsigned short *)fb = SWAP16((unsigned short)((((r)>>3)<<11) | (((g)>>2)<<5) | ((b)>>3))); \ 764 fb += 2; \ 765 } 766 767 #define FILL_32BIT_X888RGB(r,g,b) { \ 768 *(unsigned long *)fb = SWAP32((unsigned long)(((r<<16) | (g<<8) | b))); \ 769 fb += 4; \ 770 } 771 772 #ifdef VIDEO_FB_LITTLE_ENDIAN 773 #define FILL_24BIT_888RGB(r,g,b) { \ 774 fb[0] = b; \ 775 fb[1] = g; \ 776 fb[2] = r; \ 777 fb += 3; \ 778 } 779 #else 780 #define FILL_24BIT_888RGB(r,g,b) { \ 781 fb[0] = r; \ 782 fb[1] = g; \ 783 fb[2] = b; \ 784 fb += 3; \ 785 } 786 #endif 787 788 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 789 static void inline fill_555rgb_pswap(uchar *fb, int x, 790 u8 r, u8 g, u8 b) 791 { 792 ushort *dst = (ushort *)fb; 793 ushort color = (ushort)(((r >> 3) << 10) | 794 ((g >> 3) << 5) | 795 (b >> 3)); 796 if (x & 1) 797 *(--dst) = color; 798 else 799 *(++dst) = color; 800 } 801 #endif 802 803 /* 804 * Display the BMP file located at address bmp_image. 805 * Only uncompressed 806 */ 807 int video_display_bitmap (ulong bmp_image, int x, int y) 808 { 809 ushort xcount, ycount; 810 uchar *fb; 811 bmp_image_t *bmp = (bmp_image_t *) bmp_image; 812 uchar *bmap; 813 ushort padded_line; 814 unsigned long width, height, bpp; 815 unsigned colors; 816 unsigned long compression; 817 bmp_color_table_entry_t cte; 818 #ifdef CONFIG_VIDEO_BMP_GZIP 819 unsigned char *dst = NULL; 820 ulong len; 821 #endif 822 823 WATCHDOG_RESET (); 824 825 if (!((bmp->header.signature[0] == 'B') && 826 (bmp->header.signature[1] == 'M'))) { 827 828 #ifdef CONFIG_VIDEO_BMP_GZIP 829 /* 830 * Could be a gzipped bmp image, try to decrompress... 831 */ 832 len = CONFIG_SYS_VIDEO_LOGO_MAX_SIZE; 833 dst = malloc(CONFIG_SYS_VIDEO_LOGO_MAX_SIZE); 834 if (dst == NULL) { 835 printf("Error: malloc in gunzip failed!\n"); 836 return(1); 837 } 838 if (gunzip(dst, CONFIG_SYS_VIDEO_LOGO_MAX_SIZE, (uchar *)bmp_image, &len) != 0) { 839 printf ("Error: no valid bmp or bmp.gz image at %lx\n", bmp_image); 840 free(dst); 841 return 1; 842 } 843 if (len == CONFIG_SYS_VIDEO_LOGO_MAX_SIZE) { 844 printf("Image could be truncated (increase CONFIG_SYS_VIDEO_LOGO_MAX_SIZE)!\n"); 845 } 846 847 /* 848 * Set addr to decompressed image 849 */ 850 bmp = (bmp_image_t *)dst; 851 852 if (!((bmp->header.signature[0] == 'B') && 853 (bmp->header.signature[1] == 'M'))) { 854 printf ("Error: no valid bmp.gz image at %lx\n", bmp_image); 855 free(dst); 856 return 1; 857 } 858 #else 859 printf ("Error: no valid bmp image at %lx\n", bmp_image); 860 return 1; 861 #endif /* CONFIG_VIDEO_BMP_GZIP */ 862 } 863 864 width = le32_to_cpu (bmp->header.width); 865 height = le32_to_cpu (bmp->header.height); 866 bpp = le16_to_cpu (bmp->header.bit_count); 867 colors = le32_to_cpu (bmp->header.colors_used); 868 compression = le32_to_cpu (bmp->header.compression); 869 870 debug ("Display-bmp: %d x %d with %d colors\n", 871 width, height, colors); 872 873 if (compression != BMP_BI_RGB) { 874 printf ("Error: compression type %ld not supported\n", 875 compression); 876 #ifdef CONFIG_VIDEO_BMP_GZIP 877 if (dst) 878 free(dst); 879 #endif 880 return 1; 881 } 882 883 padded_line = (((width * bpp + 7) / 8) + 3) & ~0x3; 884 885 #ifdef CONFIG_SPLASH_SCREEN_ALIGN 886 if (x == BMP_ALIGN_CENTER) 887 x = max(0, (VIDEO_VISIBLE_COLS - width) / 2); 888 else if (x < 0) 889 x = max(0, VIDEO_VISIBLE_COLS - width + x + 1); 890 891 if (y == BMP_ALIGN_CENTER) 892 y = max(0, (VIDEO_VISIBLE_ROWS - height) / 2); 893 else if (y < 0) 894 y = max(0, VIDEO_VISIBLE_ROWS - height + y + 1); 895 #endif /* CONFIG_SPLASH_SCREEN_ALIGN */ 896 897 if ((x + width) > VIDEO_VISIBLE_COLS) 898 width = VIDEO_VISIBLE_COLS - x; 899 if ((y + height) > VIDEO_VISIBLE_ROWS) 900 height = VIDEO_VISIBLE_ROWS - y; 901 902 bmap = (uchar *) bmp + le32_to_cpu (bmp->header.data_offset); 903 fb = (uchar *) (video_fb_address + 904 ((y + height - 1) * VIDEO_COLS * VIDEO_PIXEL_SIZE) + 905 x * VIDEO_PIXEL_SIZE); 906 907 /* We handle only 8bpp or 24 bpp bitmap */ 908 switch (le16_to_cpu (bmp->header.bit_count)) { 909 case 8: 910 padded_line -= width; 911 if (VIDEO_DATA_FORMAT == GDF__8BIT_INDEX) { 912 /* Copy colormap */ 913 for (xcount = 0; xcount < colors; ++xcount) { 914 cte = bmp->color_table[xcount]; 915 video_set_lut (xcount, cte.red, cte.green, cte.blue); 916 } 917 } 918 ycount = height; 919 switch (VIDEO_DATA_FORMAT) { 920 case GDF__8BIT_INDEX: 921 while (ycount--) { 922 WATCHDOG_RESET (); 923 xcount = width; 924 while (xcount--) { 925 *fb++ = *bmap++; 926 } 927 bmap += padded_line; 928 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE; 929 } 930 break; 931 case GDF__8BIT_332RGB: 932 while (ycount--) { 933 WATCHDOG_RESET (); 934 xcount = width; 935 while (xcount--) { 936 cte = bmp->color_table[*bmap++]; 937 FILL_8BIT_332RGB (cte.red, cte.green, cte.blue); 938 } 939 bmap += padded_line; 940 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE; 941 } 942 break; 943 case GDF_15BIT_555RGB: 944 while (ycount--) { 945 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 946 int xpos = x; 947 #endif 948 WATCHDOG_RESET (); 949 xcount = width; 950 while (xcount--) { 951 cte = bmp->color_table[*bmap++]; 952 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 953 fill_555rgb_pswap (fb, xpos++, cte.red, 954 cte.green, cte.blue); 955 fb += 2; 956 #else 957 FILL_15BIT_555RGB (cte.red, cte.green, cte.blue); 958 #endif 959 } 960 bmap += padded_line; 961 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE; 962 } 963 break; 964 case GDF_16BIT_565RGB: 965 while (ycount--) { 966 WATCHDOG_RESET (); 967 xcount = width; 968 while (xcount--) { 969 cte = bmp->color_table[*bmap++]; 970 FILL_16BIT_565RGB (cte.red, cte.green, cte.blue); 971 } 972 bmap += padded_line; 973 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE; 974 } 975 break; 976 case GDF_32BIT_X888RGB: 977 while (ycount--) { 978 WATCHDOG_RESET (); 979 xcount = width; 980 while (xcount--) { 981 cte = bmp->color_table[*bmap++]; 982 FILL_32BIT_X888RGB (cte.red, cte.green, cte.blue); 983 } 984 bmap += padded_line; 985 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE; 986 } 987 break; 988 case GDF_24BIT_888RGB: 989 while (ycount--) { 990 WATCHDOG_RESET (); 991 xcount = width; 992 while (xcount--) { 993 cte = bmp->color_table[*bmap++]; 994 FILL_24BIT_888RGB (cte.red, cte.green, cte.blue); 995 } 996 bmap += padded_line; 997 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE; 998 } 999 break; 1000 } 1001 break; 1002 case 24: 1003 padded_line -= 3 * width; 1004 ycount = height; 1005 switch (VIDEO_DATA_FORMAT) { 1006 case GDF__8BIT_332RGB: 1007 while (ycount--) { 1008 WATCHDOG_RESET (); 1009 xcount = width; 1010 while (xcount--) { 1011 FILL_8BIT_332RGB (bmap[2], bmap[1], bmap[0]); 1012 bmap += 3; 1013 } 1014 bmap += padded_line; 1015 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE; 1016 } 1017 break; 1018 case GDF_15BIT_555RGB: 1019 while (ycount--) { 1020 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 1021 int xpos = x; 1022 #endif 1023 WATCHDOG_RESET (); 1024 xcount = width; 1025 while (xcount--) { 1026 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 1027 fill_555rgb_pswap (fb, xpos++, bmap[2], 1028 bmap[1], bmap[0]); 1029 fb += 2; 1030 #else 1031 FILL_15BIT_555RGB (bmap[2], bmap[1], bmap[0]); 1032 #endif 1033 bmap += 3; 1034 } 1035 bmap += padded_line; 1036 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE; 1037 } 1038 break; 1039 case GDF_16BIT_565RGB: 1040 while (ycount--) { 1041 WATCHDOG_RESET (); 1042 xcount = width; 1043 while (xcount--) { 1044 FILL_16BIT_565RGB (bmap[2], bmap[1], bmap[0]); 1045 bmap += 3; 1046 } 1047 bmap += padded_line; 1048 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE; 1049 } 1050 break; 1051 case GDF_32BIT_X888RGB: 1052 while (ycount--) { 1053 WATCHDOG_RESET (); 1054 xcount = width; 1055 while (xcount--) { 1056 FILL_32BIT_X888RGB (bmap[2], bmap[1], bmap[0]); 1057 bmap += 3; 1058 } 1059 bmap += padded_line; 1060 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE; 1061 } 1062 break; 1063 case GDF_24BIT_888RGB: 1064 while (ycount--) { 1065 WATCHDOG_RESET (); 1066 xcount = width; 1067 while (xcount--) { 1068 FILL_24BIT_888RGB (bmap[2], bmap[1], bmap[0]); 1069 bmap += 3; 1070 } 1071 bmap += padded_line; 1072 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE; 1073 } 1074 break; 1075 default: 1076 printf ("Error: 24 bits/pixel bitmap incompatible with current video mode\n"); 1077 break; 1078 } 1079 break; 1080 default: 1081 printf ("Error: %d bit/pixel bitmaps not supported by U-Boot\n", 1082 le16_to_cpu (bmp->header.bit_count)); 1083 break; 1084 } 1085 1086 #ifdef CONFIG_VIDEO_BMP_GZIP 1087 if (dst) { 1088 free(dst); 1089 } 1090 #endif 1091 1092 return (0); 1093 } 1094 #endif 1095 1096 /*****************************************************************************/ 1097 1098 #ifdef CONFIG_VIDEO_LOGO 1099 void logo_plot (void *screen, int width, int x, int y) 1100 { 1101 1102 int xcount, i; 1103 int skip = (width - VIDEO_LOGO_WIDTH) * VIDEO_PIXEL_SIZE; 1104 int ycount = VIDEO_LOGO_HEIGHT; 1105 unsigned char r, g, b, *logo_red, *logo_blue, *logo_green; 1106 unsigned char *source; 1107 unsigned char *dest = (unsigned char *)screen + 1108 ((y * width * VIDEO_PIXEL_SIZE) + 1109 x * VIDEO_PIXEL_SIZE); 1110 1111 #ifdef CONFIG_VIDEO_BMP_LOGO 1112 source = bmp_logo_bitmap; 1113 1114 /* Allocate temporary space for computing colormap */ 1115 logo_red = malloc (BMP_LOGO_COLORS); 1116 logo_green = malloc (BMP_LOGO_COLORS); 1117 logo_blue = malloc (BMP_LOGO_COLORS); 1118 /* Compute color map */ 1119 for (i = 0; i < VIDEO_LOGO_COLORS; i++) { 1120 logo_red[i] = (bmp_logo_palette[i] & 0x0f00) >> 4; 1121 logo_green[i] = (bmp_logo_palette[i] & 0x00f0); 1122 logo_blue[i] = (bmp_logo_palette[i] & 0x000f) << 4; 1123 } 1124 #else 1125 source = linux_logo; 1126 logo_red = linux_logo_red; 1127 logo_green = linux_logo_green; 1128 logo_blue = linux_logo_blue; 1129 #endif 1130 1131 if (VIDEO_DATA_FORMAT == GDF__8BIT_INDEX) { 1132 for (i = 0; i < VIDEO_LOGO_COLORS; i++) { 1133 video_set_lut (i + VIDEO_LOGO_LUT_OFFSET, 1134 logo_red[i], logo_green[i], logo_blue[i]); 1135 } 1136 } 1137 1138 while (ycount--) { 1139 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 1140 int xpos = x; 1141 #endif 1142 xcount = VIDEO_LOGO_WIDTH; 1143 while (xcount--) { 1144 r = logo_red[*source - VIDEO_LOGO_LUT_OFFSET]; 1145 g = logo_green[*source - VIDEO_LOGO_LUT_OFFSET]; 1146 b = logo_blue[*source - VIDEO_LOGO_LUT_OFFSET]; 1147 1148 switch (VIDEO_DATA_FORMAT) { 1149 case GDF__8BIT_INDEX: 1150 *dest = *source; 1151 break; 1152 case GDF__8BIT_332RGB: 1153 *dest = ((r >> 5) << 5) | ((g >> 5) << 2) | (b >> 6); 1154 break; 1155 case GDF_15BIT_555RGB: 1156 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP) 1157 fill_555rgb_pswap (dest, xpos++, r, g, b); 1158 #else 1159 *(unsigned short *) dest = 1160 SWAP16 ((unsigned short) (((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3))); 1161 #endif 1162 break; 1163 case GDF_16BIT_565RGB: 1164 *(unsigned short *) dest = 1165 SWAP16 ((unsigned short) (((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3))); 1166 break; 1167 case GDF_32BIT_X888RGB: 1168 *(unsigned long *) dest = 1169 SWAP32 ((unsigned long) ((r << 16) | (g << 8) | b)); 1170 break; 1171 case GDF_24BIT_888RGB: 1172 #ifdef VIDEO_FB_LITTLE_ENDIAN 1173 dest[0] = b; 1174 dest[1] = g; 1175 dest[2] = r; 1176 #else 1177 dest[0] = r; 1178 dest[1] = g; 1179 dest[2] = b; 1180 #endif 1181 break; 1182 } 1183 source++; 1184 dest += VIDEO_PIXEL_SIZE; 1185 } 1186 dest += skip; 1187 } 1188 #ifdef CONFIG_VIDEO_BMP_LOGO 1189 free (logo_red); 1190 free (logo_green); 1191 free (logo_blue); 1192 #endif 1193 } 1194 1195 /*****************************************************************************/ 1196 1197 static void *video_logo (void) 1198 { 1199 char info[128]; 1200 extern char version_string; 1201 int space, len, y_off = 0; 1202 1203 #ifdef CONFIG_SPLASH_SCREEN 1204 char *s; 1205 ulong addr; 1206 1207 if ((s = getenv ("splashimage")) != NULL) { 1208 int x = 0, y = 0; 1209 1210 addr = simple_strtoul (s, NULL, 16); 1211 #ifdef CONFIG_SPLASH_SCREEN_ALIGN 1212 if ((s = getenv ("splashpos")) != NULL) { 1213 if (s[0] == 'm') 1214 x = BMP_ALIGN_CENTER; 1215 else 1216 x = simple_strtol (s, NULL, 0); 1217 1218 if ((s = strchr (s + 1, ',')) != NULL) { 1219 if (s[1] == 'm') 1220 y = BMP_ALIGN_CENTER; 1221 else 1222 y = simple_strtol (s + 1, NULL, 0); 1223 } 1224 } 1225 #endif /* CONFIG_SPLASH_SCREEN_ALIGN */ 1226 1227 if (video_display_bitmap (addr, x, y) == 0) { 1228 return ((void *) (video_fb_address)); 1229 } 1230 } 1231 #endif /* CONFIG_SPLASH_SCREEN */ 1232 1233 logo_plot (video_fb_address, VIDEO_COLS, 0, 0); 1234 1235 sprintf (info, " %s", &version_string); 1236 1237 space = (VIDEO_LINE_LEN / 2 - VIDEO_INFO_X) / VIDEO_FONT_WIDTH; 1238 len = strlen(info); 1239 1240 if (len > space) { 1241 video_drawchars (VIDEO_INFO_X, VIDEO_INFO_Y, 1242 (uchar *)info, space); 1243 video_drawchars (VIDEO_INFO_X + VIDEO_FONT_WIDTH, 1244 VIDEO_INFO_Y + VIDEO_FONT_HEIGHT, 1245 (uchar *)info + space, len - space); 1246 y_off = 1; 1247 } else 1248 video_drawstring (VIDEO_INFO_X, VIDEO_INFO_Y, (uchar *)info); 1249 1250 #ifdef CONFIG_CONSOLE_EXTRA_INFO 1251 { 1252 int i, n = ((VIDEO_LOGO_HEIGHT - VIDEO_FONT_HEIGHT) / VIDEO_FONT_HEIGHT); 1253 1254 for (i = 1; i < n; i++) { 1255 video_get_info_str (i, info); 1256 if (!*info) 1257 continue; 1258 1259 len = strlen(info); 1260 if (len > space) { 1261 video_drawchars (VIDEO_INFO_X, 1262 VIDEO_INFO_Y + 1263 (i + y_off) * VIDEO_FONT_HEIGHT, 1264 (uchar *)info, space); 1265 y_off++; 1266 video_drawchars (VIDEO_INFO_X + VIDEO_FONT_WIDTH, 1267 VIDEO_INFO_Y + 1268 (i + y_off) * VIDEO_FONT_HEIGHT, 1269 (uchar *)info + space, 1270 len - space); 1271 } else { 1272 video_drawstring (VIDEO_INFO_X, 1273 VIDEO_INFO_Y + 1274 (i + y_off) * VIDEO_FONT_HEIGHT, 1275 (uchar *)info); 1276 } 1277 } 1278 } 1279 #endif 1280 1281 return (video_fb_address + VIDEO_LOGO_HEIGHT * VIDEO_LINE_LEN); 1282 } 1283 #endif 1284 1285 1286 /*****************************************************************************/ 1287 1288 static int video_init (void) 1289 { 1290 unsigned char color8; 1291 1292 if ((pGD = video_hw_init ()) == NULL) 1293 return -1; 1294 1295 video_fb_address = (void *) VIDEO_FB_ADRS; 1296 #ifdef CONFIG_VIDEO_HW_CURSOR 1297 video_init_hw_cursor (VIDEO_FONT_WIDTH, VIDEO_FONT_HEIGHT); 1298 #endif 1299 1300 /* Init drawing pats */ 1301 switch (VIDEO_DATA_FORMAT) { 1302 case GDF__8BIT_INDEX: 1303 video_set_lut (0x01, CONSOLE_FG_COL, CONSOLE_FG_COL, CONSOLE_FG_COL); 1304 video_set_lut (0x00, CONSOLE_BG_COL, CONSOLE_BG_COL, CONSOLE_BG_COL); 1305 fgx = 0x01010101; 1306 bgx = 0x00000000; 1307 break; 1308 case GDF__8BIT_332RGB: 1309 color8 = ((CONSOLE_FG_COL & 0xe0) | 1310 ((CONSOLE_FG_COL >> 3) & 0x1c) | CONSOLE_FG_COL >> 6); 1311 fgx = (color8 << 24) | (color8 << 16) | (color8 << 8) | color8; 1312 color8 = ((CONSOLE_BG_COL & 0xe0) | 1313 ((CONSOLE_BG_COL >> 3) & 0x1c) | CONSOLE_BG_COL >> 6); 1314 bgx = (color8 << 24) | (color8 << 16) | (color8 << 8) | color8; 1315 break; 1316 case GDF_15BIT_555RGB: 1317 fgx = (((CONSOLE_FG_COL >> 3) << 26) | 1318 ((CONSOLE_FG_COL >> 3) << 21) | ((CONSOLE_FG_COL >> 3) << 16) | 1319 ((CONSOLE_FG_COL >> 3) << 10) | ((CONSOLE_FG_COL >> 3) << 5) | 1320 (CONSOLE_FG_COL >> 3)); 1321 bgx = (((CONSOLE_BG_COL >> 3) << 26) | 1322 ((CONSOLE_BG_COL >> 3) << 21) | ((CONSOLE_BG_COL >> 3) << 16) | 1323 ((CONSOLE_BG_COL >> 3) << 10) | ((CONSOLE_BG_COL >> 3) << 5) | 1324 (CONSOLE_BG_COL >> 3)); 1325 break; 1326 case GDF_16BIT_565RGB: 1327 fgx = (((CONSOLE_FG_COL >> 3) << 27) | 1328 ((CONSOLE_FG_COL >> 2) << 21) | ((CONSOLE_FG_COL >> 3) << 16) | 1329 ((CONSOLE_FG_COL >> 3) << 11) | ((CONSOLE_FG_COL >> 2) << 5) | 1330 (CONSOLE_FG_COL >> 3)); 1331 bgx = (((CONSOLE_BG_COL >> 3) << 27) | 1332 ((CONSOLE_BG_COL >> 2) << 21) | ((CONSOLE_BG_COL >> 3) << 16) | 1333 ((CONSOLE_BG_COL >> 3) << 11) | ((CONSOLE_BG_COL >> 2) << 5) | 1334 (CONSOLE_BG_COL >> 3)); 1335 break; 1336 case GDF_32BIT_X888RGB: 1337 fgx = (CONSOLE_FG_COL << 16) | (CONSOLE_FG_COL << 8) | CONSOLE_FG_COL; 1338 bgx = (CONSOLE_BG_COL << 16) | (CONSOLE_BG_COL << 8) | CONSOLE_BG_COL; 1339 break; 1340 case GDF_24BIT_888RGB: 1341 fgx = (CONSOLE_FG_COL << 24) | (CONSOLE_FG_COL << 16) | 1342 (CONSOLE_FG_COL << 8) | CONSOLE_FG_COL; 1343 bgx = (CONSOLE_BG_COL << 24) | (CONSOLE_BG_COL << 16) | 1344 (CONSOLE_BG_COL << 8) | CONSOLE_BG_COL; 1345 break; 1346 } 1347 eorx = fgx ^ bgx; 1348 1349 #ifdef CONFIG_VIDEO_LOGO 1350 /* Plot the logo and get start point of console */ 1351 PRINTD ("Video: Drawing the logo ...\n"); 1352 video_console_address = video_logo (); 1353 #else 1354 video_console_address = video_fb_address; 1355 #endif 1356 1357 /* Initialize the console */ 1358 console_col = 0; 1359 console_row = 0; 1360 1361 return 0; 1362 } 1363 1364 1365 /*****************************************************************************/ 1366 1367 /* 1368 * Implement a weak default function for boards that optionally 1369 * need to skip the video initialization. 1370 */ 1371 int __board_video_skip(void) 1372 { 1373 /* As default, don't skip test */ 1374 return 0; 1375 } 1376 int board_video_skip(void) __attribute__((weak, alias("__board_video_skip"))); 1377 1378 int drv_video_init (void) 1379 { 1380 int skip_dev_init; 1381 struct stdio_dev console_dev; 1382 1383 /* Check if video initialization should be skipped */ 1384 if (board_video_skip()) 1385 return 0; 1386 1387 /* Init video chip - returns with framebuffer cleared */ 1388 skip_dev_init = (video_init () == -1); 1389 1390 #if !defined(CONFIG_VGA_AS_SINGLE_DEVICE) 1391 PRINTD ("KBD: Keyboard init ...\n"); 1392 skip_dev_init |= (VIDEO_KBD_INIT_FCT == -1); 1393 #endif 1394 1395 if (skip_dev_init) 1396 return 0; 1397 1398 /* Init vga device */ 1399 memset (&console_dev, 0, sizeof (console_dev)); 1400 strcpy (console_dev.name, "vga"); 1401 console_dev.ext = DEV_EXT_VIDEO; /* Video extensions */ 1402 console_dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_SYSTEM; 1403 console_dev.putc = video_putc; /* 'putc' function */ 1404 console_dev.puts = video_puts; /* 'puts' function */ 1405 console_dev.tstc = NULL; /* 'tstc' function */ 1406 console_dev.getc = NULL; /* 'getc' function */ 1407 1408 #if !defined(CONFIG_VGA_AS_SINGLE_DEVICE) 1409 /* Also init console device */ 1410 console_dev.flags |= DEV_FLAGS_INPUT; 1411 console_dev.tstc = VIDEO_TSTC_FCT; /* 'tstc' function */ 1412 console_dev.getc = VIDEO_GETC_FCT; /* 'getc' function */ 1413 #endif /* CONFIG_VGA_AS_SINGLE_DEVICE */ 1414 1415 if (stdio_register (&console_dev) != 0) 1416 return 0; 1417 1418 /* Return success */ 1419 return 1; 1420 } 1421