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