2 * (C) Copyright 2002 ELTEC Elektronik AG
3 * Frank Gottschling <fgottschling@eltec.de>
5 * See file CREDITS for list of people who contributed to this
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.
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.
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,
27 * Color Framebuffer Console driver for 8/15/16/24/32 bits per pixel.
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.
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.
40 The driver uses graphic specific defines/parameters/functions:
42 (for SMI LynxE graphic chip)
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
49 Console Parameters are set by graphic drivers global struct:
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
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
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,
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).
83 CONFIG_VIDEO_SW_CURSOR: - Draws a cursor after the last character. No
84 blinking is provided. Uses the macros CURSOR_SET
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
97 /*****************************************************************************/
98 /* Console device defines with SMI graphic */
99 /* Any other graphic must change this section */
100 /*****************************************************************************/
102 #ifdef CONFIG_VIDEO_SMI_LYNXEM
104 #define VIDEO_FB_LITTLE_ENDIAN
105 #define VIDEO_HW_RECTFILL
106 #define VIDEO_HW_BITBLT
109 /*****************************************************************************/
110 /* Defines for the CT69000 driver */
111 /*****************************************************************************/
112 #ifdef CONFIG_VIDEO_CT69000
114 #define VIDEO_FB_LITTLE_ENDIAN
115 #define VIDEO_HW_RECTFILL
116 #define VIDEO_HW_BITBLT
119 /*****************************************************************************/
120 /* Defines for the SED13806 driver */
121 /*****************************************************************************/
122 #ifdef CONFIG_VIDEO_SED13806
124 #ifndef CONFIG_TOTAL5200
125 #define VIDEO_FB_LITTLE_ENDIAN
127 #define VIDEO_HW_RECTFILL
128 #define VIDEO_HW_BITBLT
131 /*****************************************************************************/
132 /* Defines for the SED13806 driver */
133 /*****************************************************************************/
134 #ifdef CONFIG_VIDEO_SM501
137 #define VIDEO_FB_LITTLE_ENDIAN
141 /*****************************************************************************/
142 /* Defines for the MB862xx driver */
143 /*****************************************************************************/
144 #ifdef CONFIG_VIDEO_MB862xx
146 #ifdef CONFIG_VIDEO_CORALP
147 #define VIDEO_FB_LITTLE_ENDIAN
149 #ifdef CONFIG_VIDEO_MB862xx_ACCEL
150 #define VIDEO_HW_RECTFILL
151 #define VIDEO_HW_BITBLT
155 /*****************************************************************************/
156 /* Include video_fb.h after definitions of VIDEO_HW_RECTFILL etc */
157 /*****************************************************************************/
158 #include <video_fb.h>
160 /*****************************************************************************/
162 /*****************************************************************************/
163 #define VIDEO_VISIBLE_COLS (pGD->winSizeX)
164 #define VIDEO_VISIBLE_ROWS (pGD->winSizeY)
165 #define VIDEO_PIXEL_SIZE (pGD->gdfBytesPP)
166 #define VIDEO_DATA_FORMAT (pGD->gdfIndex)
167 #define VIDEO_FB_ADRS (pGD->frameAdrs)
169 /*****************************************************************************/
170 /* Console device defines with i8042 keyboard controller */
171 /* Any other keyboard controller must change this section */
172 /*****************************************************************************/
174 #ifdef CONFIG_I8042_KBD
177 #define VIDEO_KBD_INIT_FCT i8042_kbd_init()
178 #define VIDEO_TSTC_FCT i8042_tstc
179 #define VIDEO_GETC_FCT i8042_getc
182 /*****************************************************************************/
184 /*****************************************************************************/
187 #include <linux/types.h>
188 #include <stdio_dev.h>
189 #include <video_font.h>
191 #if defined(CONFIG_CMD_DATE)
195 #if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN)
196 #include <watchdog.h>
197 #include <bmp_layout.h>
199 #ifdef CONFIG_SPLASH_SCREEN_ALIGN
200 #define BMP_ALIGN_CENTER 0x7FFF
205 /*****************************************************************************/
206 /* Cursor definition: */
207 /* CONFIG_CONSOLE_CURSOR: Uses a timer function (see drivers/input/i8042.c) */
208 /* to let the cursor blink. Uses the macros */
209 /* CURSOR_OFF and CURSOR_ON. */
210 /* CONFIG_VIDEO_SW_CURSOR: Draws a cursor after the last character. No */
211 /* blinking is provided. Uses the macros CURSOR_SET */
212 /* and CURSOR_OFF. */
213 /* CONFIG_VIDEO_HW_CURSOR: Uses the hardware cursor capability of the */
214 /* graphic chip. Uses the macro CURSOR_SET. */
215 /* ATTENTION: If booting an OS, the display driver */
216 /* must disable the hardware register of the graphic */
217 /* chip. Otherwise a blinking field is displayed */
218 /*****************************************************************************/
219 #if !defined(CONFIG_CONSOLE_CURSOR) && \
220 !defined(CONFIG_VIDEO_SW_CURSOR) && \
221 !defined(CONFIG_VIDEO_HW_CURSOR)
222 /* no Cursor defined */
228 #ifdef CONFIG_CONSOLE_CURSOR
230 #error only one of CONFIG_CONSOLE_CURSOR,CONFIG_VIDEO_SW_CURSOR,CONFIG_VIDEO_HW_CURSOR can be defined
232 void console_cursor (int state);
233 #define CURSOR_ON console_cursor(1);
234 #define CURSOR_OFF console_cursor(0);
236 #ifndef CONFIG_I8042_KBD
237 #warning Cursor drawing on/off needs timer function s.a. drivers/input/i8042.c
240 #ifdef CONFIG_CONSOLE_TIME
241 #error CONFIG_CONSOLE_CURSOR must be defined for CONFIG_CONSOLE_TIME
243 #endif /* CONFIG_CONSOLE_CURSOR */
245 #ifdef CONFIG_VIDEO_SW_CURSOR
247 #error only one of CONFIG_CONSOLE_CURSOR,CONFIG_VIDEO_SW_CURSOR,CONFIG_VIDEO_HW_CURSOR can be defined
250 #define CURSOR_OFF video_putchar(console_col * VIDEO_FONT_WIDTH,\
251 console_row * VIDEO_FONT_HEIGHT, ' ');
252 #define CURSOR_SET video_set_cursor();
253 #endif /* CONFIG_VIDEO_SW_CURSOR */
256 #ifdef CONFIG_VIDEO_HW_CURSOR
258 #error only one of CONFIG_CONSOLE_CURSOR,CONFIG_VIDEO_SW_CURSOR,CONFIG_VIDEO_HW_CURSOR can be defined
262 #define CURSOR_SET video_set_hw_cursor(console_col * VIDEO_FONT_WIDTH, \
263 (console_row * VIDEO_FONT_HEIGHT) + video_logo_height);
264 #endif /* CONFIG_VIDEO_HW_CURSOR */
266 #ifdef CONFIG_VIDEO_LOGO
267 #ifdef CONFIG_VIDEO_BMP_LOGO
268 #include <bmp_logo.h>
269 #define VIDEO_LOGO_WIDTH BMP_LOGO_WIDTH
270 #define VIDEO_LOGO_HEIGHT BMP_LOGO_HEIGHT
271 #define VIDEO_LOGO_LUT_OFFSET BMP_LOGO_OFFSET
272 #define VIDEO_LOGO_COLORS BMP_LOGO_COLORS
274 #else /* CONFIG_VIDEO_BMP_LOGO */
275 #define LINUX_LOGO_WIDTH 80
276 #define LINUX_LOGO_HEIGHT 80
277 #define LINUX_LOGO_COLORS 214
278 #define LINUX_LOGO_LUT_OFFSET 0x20
280 #include <linux_logo.h>
281 #define VIDEO_LOGO_WIDTH LINUX_LOGO_WIDTH
282 #define VIDEO_LOGO_HEIGHT LINUX_LOGO_HEIGHT
283 #define VIDEO_LOGO_LUT_OFFSET LINUX_LOGO_LUT_OFFSET
284 #define VIDEO_LOGO_COLORS LINUX_LOGO_COLORS
285 #endif /* CONFIG_VIDEO_BMP_LOGO */
286 #define VIDEO_INFO_X (VIDEO_LOGO_WIDTH)
287 #define VIDEO_INFO_Y (VIDEO_FONT_HEIGHT/2)
288 #else /* CONFIG_VIDEO_LOGO */
289 #define VIDEO_LOGO_WIDTH 0
290 #define VIDEO_LOGO_HEIGHT 0
291 #endif /* CONFIG_VIDEO_LOGO */
293 #define VIDEO_COLS VIDEO_VISIBLE_COLS
294 #define VIDEO_ROWS VIDEO_VISIBLE_ROWS
295 #define VIDEO_SIZE (VIDEO_ROWS*VIDEO_COLS*VIDEO_PIXEL_SIZE)
296 #define VIDEO_PIX_BLOCKS (VIDEO_SIZE >> 2)
297 #define VIDEO_LINE_LEN (VIDEO_COLS*VIDEO_PIXEL_SIZE)
298 #define VIDEO_BURST_LEN (VIDEO_COLS/8)
300 #ifdef CONFIG_VIDEO_LOGO
301 #define CONSOLE_ROWS ((VIDEO_ROWS - video_logo_height) / VIDEO_FONT_HEIGHT)
303 #define CONSOLE_ROWS (VIDEO_ROWS / VIDEO_FONT_HEIGHT)
306 #define CONSOLE_COLS (VIDEO_COLS / VIDEO_FONT_WIDTH)
307 #define CONSOLE_ROW_SIZE (VIDEO_FONT_HEIGHT * VIDEO_LINE_LEN)
308 #define CONSOLE_ROW_FIRST (video_console_address)
309 #define CONSOLE_ROW_SECOND (video_console_address + CONSOLE_ROW_SIZE)
310 #define CONSOLE_ROW_LAST (video_console_address + CONSOLE_SIZE - CONSOLE_ROW_SIZE)
311 #define CONSOLE_SIZE (CONSOLE_ROW_SIZE * CONSOLE_ROWS)
312 #define CONSOLE_SCROLL_SIZE (CONSOLE_SIZE - CONSOLE_ROW_SIZE)
315 #ifdef VIDEO_FB_LITTLE_ENDIAN
316 #define SWAP16(x) ((((x) & 0x00ff) << 8) | ( (x) >> 8))
317 #define SWAP32(x) ((((x) & 0x000000ff) << 24) | (((x) & 0x0000ff00) << 8)|\
318 (((x) & 0x00ff0000) >> 8) | (((x) & 0xff000000) >> 24) )
319 #define SHORTSWAP32(x) ((((x) & 0x000000ff) << 8) | (((x) & 0x0000ff00) >> 8)|\
320 (((x) & 0x00ff0000) << 8) | (((x) & 0xff000000) >> 8) )
322 #define SWAP16(x) (x)
323 #define SWAP32(x) (x)
324 #if defined(VIDEO_FB_16BPP_WORD_SWAP)
325 #define SHORTSWAP32(x) ( ((x) >> 16) | ((x) << 16) )
327 #define SHORTSWAP32(x) (x)
331 #if defined(DEBUG) || defined(DEBUG_CFB_CONSOLE)
332 #define PRINTD(x) printf(x)
338 #ifdef CONFIG_CONSOLE_EXTRA_INFO
339 extern void video_get_info_str ( /* setup a board string: type, speed, etc. */
340 int line_number, /* location to place info string beside logo */
341 char *info /* buffer for info string */
347 static GraphicDevice *pGD; /* Pointer to Graphic array */
349 static void *video_fb_address; /* frame buffer address */
350 static void *video_console_address; /* console buffer start address */
352 static int video_logo_height = VIDEO_LOGO_HEIGHT;
354 static int console_col = 0; /* cursor col */
355 static int console_row = 0; /* cursor row */
357 static u32 eorx, fgx, bgx; /* color pats */
359 static const int video_font_draw_table8[] = {
360 0x00000000, 0x000000ff, 0x0000ff00, 0x0000ffff,
361 0x00ff0000, 0x00ff00ff, 0x00ffff00, 0x00ffffff,
362 0xff000000, 0xff0000ff, 0xff00ff00, 0xff00ffff,
363 0xffff0000, 0xffff00ff, 0xffffff00, 0xffffffff };
365 static const int video_font_draw_table15[] = {
366 0x00000000, 0x00007fff, 0x7fff0000, 0x7fff7fff };
368 static const int video_font_draw_table16[] = {
369 0x00000000, 0x0000ffff, 0xffff0000, 0xffffffff };
371 static const int video_font_draw_table24[16][3] = {
372 { 0x00000000, 0x00000000, 0x00000000 },
373 { 0x00000000, 0x00000000, 0x00ffffff },
374 { 0x00000000, 0x0000ffff, 0xff000000 },
375 { 0x00000000, 0x0000ffff, 0xffffffff },
376 { 0x000000ff, 0xffff0000, 0x00000000 },
377 { 0x000000ff, 0xffff0000, 0x00ffffff },
378 { 0x000000ff, 0xffffffff, 0xff000000 },
379 { 0x000000ff, 0xffffffff, 0xffffffff },
380 { 0xffffff00, 0x00000000, 0x00000000 },
381 { 0xffffff00, 0x00000000, 0x00ffffff },
382 { 0xffffff00, 0x0000ffff, 0xff000000 },
383 { 0xffffff00, 0x0000ffff, 0xffffffff },
384 { 0xffffffff, 0xffff0000, 0x00000000 },
385 { 0xffffffff, 0xffff0000, 0x00ffffff },
386 { 0xffffffff, 0xffffffff, 0xff000000 },
387 { 0xffffffff, 0xffffffff, 0xffffffff } };
389 static const int video_font_draw_table32[16][4] = {
390 { 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
391 { 0x00000000, 0x00000000, 0x00000000, 0x00ffffff },
392 { 0x00000000, 0x00000000, 0x00ffffff, 0x00000000 },
393 { 0x00000000, 0x00000000, 0x00ffffff, 0x00ffffff },
394 { 0x00000000, 0x00ffffff, 0x00000000, 0x00000000 },
395 { 0x00000000, 0x00ffffff, 0x00000000, 0x00ffffff },
396 { 0x00000000, 0x00ffffff, 0x00ffffff, 0x00000000 },
397 { 0x00000000, 0x00ffffff, 0x00ffffff, 0x00ffffff },
398 { 0x00ffffff, 0x00000000, 0x00000000, 0x00000000 },
399 { 0x00ffffff, 0x00000000, 0x00000000, 0x00ffffff },
400 { 0x00ffffff, 0x00000000, 0x00ffffff, 0x00000000 },
401 { 0x00ffffff, 0x00000000, 0x00ffffff, 0x00ffffff },
402 { 0x00ffffff, 0x00ffffff, 0x00000000, 0x00000000 },
403 { 0x00ffffff, 0x00ffffff, 0x00000000, 0x00ffffff },
404 { 0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00000000 },
405 { 0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00ffffff } };
408 /******************************************************************************/
410 static void video_drawchars (int xx, int yy, unsigned char *s, int count)
412 u8 *cdat, *dest, *dest0;
415 offset = yy * VIDEO_LINE_LEN + xx * VIDEO_PIXEL_SIZE;
416 dest0 = video_fb_address + offset;
418 switch (VIDEO_DATA_FORMAT) {
419 case GDF__8BIT_INDEX:
420 case GDF__8BIT_332RGB:
423 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
424 for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
426 dest += VIDEO_LINE_LEN) {
429 ((u32 *) dest)[0] = (video_font_draw_table8[bits >> 4] & eorx) ^ bgx;
430 ((u32 *) dest)[1] = (video_font_draw_table8[bits & 15] & eorx) ^ bgx;
432 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
437 case GDF_15BIT_555RGB:
440 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
441 for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
443 dest += VIDEO_LINE_LEN) {
446 ((u32 *) dest)[0] = SHORTSWAP32 ((video_font_draw_table15 [bits >> 6] & eorx) ^ bgx);
447 ((u32 *) dest)[1] = SHORTSWAP32 ((video_font_draw_table15 [bits >> 4 & 3] & eorx) ^ bgx);
448 ((u32 *) dest)[2] = SHORTSWAP32 ((video_font_draw_table15 [bits >> 2 & 3] & eorx) ^ bgx);
449 ((u32 *) dest)[3] = SHORTSWAP32 ((video_font_draw_table15 [bits & 3] & eorx) ^ bgx);
451 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
456 case GDF_16BIT_565RGB:
459 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
460 for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
462 dest += VIDEO_LINE_LEN) {
465 ((u32 *) dest)[0] = SHORTSWAP32 ((video_font_draw_table16 [bits >> 6] & eorx) ^ bgx);
466 ((u32 *) dest)[1] = SHORTSWAP32 ((video_font_draw_table16 [bits >> 4 & 3] & eorx) ^ bgx);
467 ((u32 *) dest)[2] = SHORTSWAP32 ((video_font_draw_table16 [bits >> 2 & 3] & eorx) ^ bgx);
468 ((u32 *) dest)[3] = SHORTSWAP32 ((video_font_draw_table16 [bits & 3] & eorx) ^ bgx);
470 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
475 case GDF_32BIT_X888RGB:
478 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
479 for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
481 dest += VIDEO_LINE_LEN) {
484 ((u32 *) dest)[0] = SWAP32 ((video_font_draw_table32 [bits >> 4][0] & eorx) ^ bgx);
485 ((u32 *) dest)[1] = SWAP32 ((video_font_draw_table32 [bits >> 4][1] & eorx) ^ bgx);
486 ((u32 *) dest)[2] = SWAP32 ((video_font_draw_table32 [bits >> 4][2] & eorx) ^ bgx);
487 ((u32 *) dest)[3] = SWAP32 ((video_font_draw_table32 [bits >> 4][3] & eorx) ^ bgx);
488 ((u32 *) dest)[4] = SWAP32 ((video_font_draw_table32 [bits & 15][0] & eorx) ^ bgx);
489 ((u32 *) dest)[5] = SWAP32 ((video_font_draw_table32 [bits & 15][1] & eorx) ^ bgx);
490 ((u32 *) dest)[6] = SWAP32 ((video_font_draw_table32 [bits & 15][2] & eorx) ^ bgx);
491 ((u32 *) dest)[7] = SWAP32 ((video_font_draw_table32 [bits & 15][3] & eorx) ^ bgx);
493 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
498 case GDF_24BIT_888RGB:
501 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
502 for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
504 dest += VIDEO_LINE_LEN) {
507 ((u32 *) dest)[0] = (video_font_draw_table24[bits >> 4][0] & eorx) ^ bgx;
508 ((u32 *) dest)[1] = (video_font_draw_table24[bits >> 4][1] & eorx) ^ bgx;
509 ((u32 *) dest)[2] = (video_font_draw_table24[bits >> 4][2] & eorx) ^ bgx;
510 ((u32 *) dest)[3] = (video_font_draw_table24[bits & 15][0] & eorx) ^ bgx;
511 ((u32 *) dest)[4] = (video_font_draw_table24[bits & 15][1] & eorx) ^ bgx;
512 ((u32 *) dest)[5] = (video_font_draw_table24[bits & 15][2] & eorx) ^ bgx;
514 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
521 /*****************************************************************************/
523 static inline void video_drawstring (int xx, int yy, unsigned char *s)
525 video_drawchars (xx, yy, s, strlen ((char *)s));
528 /*****************************************************************************/
530 static void video_putchar (int xx, int yy, unsigned char c)
532 video_drawchars (xx, yy + video_logo_height, &c, 1);
535 /*****************************************************************************/
536 #if defined(CONFIG_CONSOLE_CURSOR) || defined(CONFIG_VIDEO_SW_CURSOR)
537 static void video_set_cursor (void)
539 /* swap drawing colors */
545 video_putchar (console_col * VIDEO_FONT_WIDTH,
546 console_row * VIDEO_FONT_HEIGHT,
548 /* restore drawing colors */
555 /*****************************************************************************/
556 #ifdef CONFIG_CONSOLE_CURSOR
557 void console_cursor (int state)
559 static int last_state = 0;
561 #ifdef CONFIG_CONSOLE_TIME
565 /* time update only if cursor is on (faster scroll) */
569 sprintf (info, " %02d:%02d:%02d ", tm.tm_hour, tm.tm_min,
571 video_drawstring (VIDEO_VISIBLE_COLS - 10 * VIDEO_FONT_WIDTH,
572 VIDEO_INFO_Y, (uchar *)info);
574 sprintf (info, "%02d.%02d.%04d", tm.tm_mday, tm.tm_mon,
576 video_drawstring (VIDEO_VISIBLE_COLS - 10 * VIDEO_FONT_WIDTH,
577 VIDEO_INFO_Y + 1 * VIDEO_FONT_HEIGHT, (uchar *)info);
581 if (state && (last_state != state)) {
585 if (!state && (last_state != state)) {
587 video_putchar (console_col * VIDEO_FONT_WIDTH,
588 console_row * VIDEO_FONT_HEIGHT,
596 /*****************************************************************************/
598 #ifndef VIDEO_HW_RECTFILL
599 static void memsetl (int *p, int c, int v)
606 /*****************************************************************************/
608 #ifndef VIDEO_HW_BITBLT
609 static void memcpyl (int *d, int *s, int c)
616 /*****************************************************************************/
618 static void console_scrollup (void)
620 /* copy up rows ignoring the first one */
622 #ifdef VIDEO_HW_BITBLT
623 video_hw_bitblt (VIDEO_PIXEL_SIZE, /* bytes per pixel */
624 0, /* source pos x */
625 video_logo_height + VIDEO_FONT_HEIGHT, /* source pos y */
627 video_logo_height, /* dest pos y */
628 VIDEO_VISIBLE_COLS, /* frame width */
629 VIDEO_VISIBLE_ROWS - video_logo_height - VIDEO_FONT_HEIGHT /* frame height */
632 memcpyl (CONSOLE_ROW_FIRST, CONSOLE_ROW_SECOND,
633 CONSOLE_SCROLL_SIZE >> 2);
636 /* clear the last one */
637 #ifdef VIDEO_HW_RECTFILL
638 video_hw_rectfill (VIDEO_PIXEL_SIZE, /* bytes per pixel */
640 VIDEO_VISIBLE_ROWS - VIDEO_FONT_HEIGHT, /* dest pos y */
641 VIDEO_VISIBLE_COLS, /* frame width */
642 VIDEO_FONT_HEIGHT, /* frame height */
643 CONSOLE_BG_COL /* fill color */
646 memsetl (CONSOLE_ROW_LAST, CONSOLE_ROW_SIZE >> 2, CONSOLE_BG_COL);
650 /*****************************************************************************/
652 static void console_back (void)
654 CURSOR_OFF console_col--;
656 if (console_col < 0) {
657 console_col = CONSOLE_COLS - 1;
662 video_putchar (console_col * VIDEO_FONT_WIDTH,
663 console_row * VIDEO_FONT_HEIGHT,
667 /*****************************************************************************/
669 static void console_newline (void)
671 /* Check if last character in the line was just drawn. If so, cursor was
672 overwriten and need not to be cleared. Cursor clearing without this
673 check causes overwriting the 1st character of the line if line lenght
676 if (console_col < CONSOLE_COLS)
681 /* Check if we need to scroll the terminal */
682 if (console_row >= CONSOLE_ROWS) {
683 /* Scroll everything up */
686 /* Decrement row number */
691 static void console_cr (void)
693 CURSOR_OFF console_col = 0;
696 /*****************************************************************************/
698 void video_putc (const char c)
703 case 13: /* back to first column */
707 case '\n': /* next line */
708 if (console_col || (!console_col && nl))
714 CURSOR_OFF console_col |= 0x0008;
715 console_col &= ~0x0007;
717 if (console_col >= CONSOLE_COLS)
721 case 8: /* backspace */
725 default: /* draw the char */
726 video_putchar (console_col * VIDEO_FONT_WIDTH,
727 console_row * VIDEO_FONT_HEIGHT,
731 /* check for newline */
732 if (console_col >= CONSOLE_COLS) {
740 /*****************************************************************************/
742 void video_puts (const char *s)
744 int count = strlen (s);
750 /*****************************************************************************/
753 * Do not enforce drivers (or board code) to provide empty
754 * video_set_lut() if they do not support 8 bpp format.
755 * Implement weak default function instead.
757 void __video_set_lut (unsigned int index, unsigned char r,
758 unsigned char g, unsigned char b)
761 void video_set_lut (unsigned int, unsigned char, unsigned char, unsigned char)
762 __attribute__((weak, alias("__video_set_lut")));
764 #if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN)
766 #define FILL_8BIT_332RGB(r,g,b) { \
767 *fb = ((r>>5)<<5) | ((g>>5)<<2) | (b>>6); \
771 #define FILL_15BIT_555RGB(r,g,b) { \
772 *(unsigned short *)fb = SWAP16((unsigned short)(((r>>3)<<10) | ((g>>3)<<5) | (b>>3))); \
776 #define FILL_16BIT_565RGB(r,g,b) { \
777 *(unsigned short *)fb = SWAP16((unsigned short)((((r)>>3)<<11) | (((g)>>2)<<5) | ((b)>>3))); \
781 #define FILL_32BIT_X888RGB(r,g,b) { \
782 *(unsigned long *)fb = SWAP32((unsigned long)(((r<<16) | (g<<8) | b))); \
786 #ifdef VIDEO_FB_LITTLE_ENDIAN
787 #define FILL_24BIT_888RGB(r,g,b) { \
794 #define FILL_24BIT_888RGB(r,g,b) { \
802 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
803 static void inline fill_555rgb_pswap(uchar *fb, int x,
806 ushort *dst = (ushort *)fb;
807 ushort color = (ushort)(((r >> 3) << 10) |
818 * RLE8 bitmap support
821 #ifdef CONFIG_VIDEO_BMP_RLE8
822 /* Pre-calculated color table entry */
825 unsigned short w; /* word */
826 unsigned int dw; /* double word */
827 } ce; /* color entry */
831 * Helper to draw encoded/unencoded run.
833 static void draw_bitmap (uchar **fb, uchar *bm, struct palette *p,
836 ulong addr = (ulong)*fb;
842 * Setup offset of the color index in the bitmap.
843 * Color index of encoded run is at offset 1.
845 off = enc ? &enc_off : &i;
847 switch (VIDEO_DATA_FORMAT) {
848 case GDF__8BIT_INDEX:
849 for (i = 0; i < cnt; i++)
850 *(unsigned char *)addr++ = bm[*off];
852 case GDF_15BIT_555RGB:
853 case GDF_16BIT_565RGB:
854 /* differences handled while pre-calculating palette */
855 for (i = 0; i < cnt; i++) {
856 *(unsigned short *)addr = p[bm[*off]].ce.w;
860 case GDF_32BIT_X888RGB:
861 for (i = 0; i < cnt; i++) {
862 *(unsigned long *)addr = p[bm[*off]].ce.dw;
867 *fb = (uchar *)addr; /* return modified address */
870 static int display_rle8_bitmap (bmp_image_t *img, int xoff, int yoff,
871 int width, int height)
875 unsigned int cnt, runlen;
877 int x, y, bpp, i, ncolors;
878 struct palette p[256];
879 bmp_color_table_entry_t cte;
880 int green_shift, red_off;
883 y = __le32_to_cpu(img->header.height) - 1;
884 ncolors = __le32_to_cpu(img->header.colors_used);
885 bpp = VIDEO_PIXEL_SIZE;
886 fbp = (unsigned char *)((unsigned int)video_fb_address +
887 (((y + yoff) * VIDEO_COLS) + xoff) * bpp);
889 bm = (uchar *)img + __le32_to_cpu(img->header.data_offset);
891 /* pre-calculate and setup palette */
892 switch (VIDEO_DATA_FORMAT) {
893 case GDF__8BIT_INDEX:
894 for (i = 0; i < ncolors; i++) {
895 cte = img->color_table[i];
896 video_set_lut (i, cte.red, cte.green, cte.blue);
899 case GDF_15BIT_555RGB:
900 case GDF_16BIT_565RGB:
901 if (VIDEO_DATA_FORMAT == GDF_15BIT_555RGB) {
908 for (i = 0; i < ncolors; i++) {
909 cte = img->color_table[i];
910 p[i].ce.w = SWAP16((unsigned short)
911 (((cte.red >> 3) << red_off) |
912 ((cte.green >> green_shift) << 5) |
916 case GDF_32BIT_X888RGB:
917 for (i = 0; i < ncolors; i++) {
918 cte = img->color_table[i];
919 p[i].ce.dw = SWAP32((cte.red << 16) | (cte.green << 8) |
924 printf("RLE Bitmap unsupported in video mode 0x%x\n",
934 /* scan line end marker */
938 fbp = (unsigned char *)
939 ((unsigned int)video_fb_address +
940 (((y + yoff) * VIDEO_COLS) +
944 /* end of bitmap data marker */
948 /* run offset marker */
951 fbp = (unsigned char *)
952 ((unsigned int)video_fb_address +
953 (((y + yoff) * VIDEO_COLS) +
967 if (x + runlen > width)
970 draw_bitmap (&fbp, bm, p, cnt, 0);
976 bm++; /* 0 padding if length is odd */
981 if (y < height) { /* only draw into visible area */
989 if (x + runlen > width)
992 draw_bitmap (&fbp, bm, p, cnt, 1);
1004 * Display the BMP file located at address bmp_image.
1006 int video_display_bitmap (ulong bmp_image, int x, int y)
1008 ushort xcount, ycount;
1010 bmp_image_t *bmp = (bmp_image_t *) bmp_image;
1013 unsigned long width, height, bpp;
1015 unsigned long compression;
1016 bmp_color_table_entry_t cte;
1017 #ifdef CONFIG_VIDEO_BMP_GZIP
1018 unsigned char *dst = NULL;
1024 if (!((bmp->header.signature[0] == 'B') &&
1025 (bmp->header.signature[1] == 'M'))) {
1027 #ifdef CONFIG_VIDEO_BMP_GZIP
1029 * Could be a gzipped bmp image, try to decrompress...
1031 len = CONFIG_SYS_VIDEO_LOGO_MAX_SIZE;
1032 dst = malloc(CONFIG_SYS_VIDEO_LOGO_MAX_SIZE);
1034 printf("Error: malloc in gunzip failed!\n");
1037 if (gunzip(dst, CONFIG_SYS_VIDEO_LOGO_MAX_SIZE, (uchar *)bmp_image, &len) != 0) {
1038 printf ("Error: no valid bmp or bmp.gz image at %lx\n", bmp_image);
1042 if (len == CONFIG_SYS_VIDEO_LOGO_MAX_SIZE) {
1043 printf("Image could be truncated (increase CONFIG_SYS_VIDEO_LOGO_MAX_SIZE)!\n");
1047 * Set addr to decompressed image
1049 bmp = (bmp_image_t *)dst;
1051 if (!((bmp->header.signature[0] == 'B') &&
1052 (bmp->header.signature[1] == 'M'))) {
1053 printf ("Error: no valid bmp.gz image at %lx\n", bmp_image);
1058 printf ("Error: no valid bmp image at %lx\n", bmp_image);
1060 #endif /* CONFIG_VIDEO_BMP_GZIP */
1063 width = le32_to_cpu (bmp->header.width);
1064 height = le32_to_cpu (bmp->header.height);
1065 bpp = le16_to_cpu (bmp->header.bit_count);
1066 colors = le32_to_cpu (bmp->header.colors_used);
1067 compression = le32_to_cpu (bmp->header.compression);
1069 debug ("Display-bmp: %d x %d with %d colors\n",
1070 width, height, colors);
1072 if (compression != BMP_BI_RGB
1073 #ifdef CONFIG_VIDEO_BMP_RLE8
1074 && compression != BMP_BI_RLE8
1077 printf ("Error: compression type %ld not supported\n",
1079 #ifdef CONFIG_VIDEO_BMP_GZIP
1086 padded_line = (((width * bpp + 7) / 8) + 3) & ~0x3;
1088 #ifdef CONFIG_SPLASH_SCREEN_ALIGN
1089 if (x == BMP_ALIGN_CENTER)
1090 x = max(0, (VIDEO_VISIBLE_COLS - width) / 2);
1092 x = max(0, VIDEO_VISIBLE_COLS - width + x + 1);
1094 if (y == BMP_ALIGN_CENTER)
1095 y = max(0, (VIDEO_VISIBLE_ROWS - height) / 2);
1097 y = max(0, VIDEO_VISIBLE_ROWS - height + y + 1);
1098 #endif /* CONFIG_SPLASH_SCREEN_ALIGN */
1100 if ((x + width) > VIDEO_VISIBLE_COLS)
1101 width = VIDEO_VISIBLE_COLS - x;
1102 if ((y + height) > VIDEO_VISIBLE_ROWS)
1103 height = VIDEO_VISIBLE_ROWS - y;
1105 bmap = (uchar *) bmp + le32_to_cpu (bmp->header.data_offset);
1106 fb = (uchar *) (video_fb_address +
1107 ((y + height - 1) * VIDEO_COLS * VIDEO_PIXEL_SIZE) +
1108 x * VIDEO_PIXEL_SIZE);
1110 #ifdef CONFIG_VIDEO_BMP_RLE8
1111 if (compression == BMP_BI_RLE8) {
1112 return display_rle8_bitmap(bmp,
1113 x, y, width, height);
1117 /* We handle only 8bpp or 24 bpp bitmap */
1118 switch (le16_to_cpu (bmp->header.bit_count)) {
1120 padded_line -= width;
1121 if (VIDEO_DATA_FORMAT == GDF__8BIT_INDEX) {
1123 for (xcount = 0; xcount < colors; ++xcount) {
1124 cte = bmp->color_table[xcount];
1125 video_set_lut (xcount, cte.red, cte.green, cte.blue);
1129 switch (VIDEO_DATA_FORMAT) {
1130 case GDF__8BIT_INDEX:
1137 bmap += padded_line;
1138 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1141 case GDF__8BIT_332RGB:
1146 cte = bmp->color_table[*bmap++];
1147 FILL_8BIT_332RGB (cte.red, cte.green, cte.blue);
1149 bmap += padded_line;
1150 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1153 case GDF_15BIT_555RGB:
1155 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1161 cte = bmp->color_table[*bmap++];
1162 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1163 fill_555rgb_pswap (fb, xpos++, cte.red,
1164 cte.green, cte.blue);
1167 FILL_15BIT_555RGB (cte.red, cte.green, cte.blue);
1170 bmap += padded_line;
1171 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1174 case GDF_16BIT_565RGB:
1179 cte = bmp->color_table[*bmap++];
1180 FILL_16BIT_565RGB (cte.red, cte.green, cte.blue);
1182 bmap += padded_line;
1183 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1186 case GDF_32BIT_X888RGB:
1191 cte = bmp->color_table[*bmap++];
1192 FILL_32BIT_X888RGB (cte.red, cte.green, cte.blue);
1194 bmap += padded_line;
1195 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1198 case GDF_24BIT_888RGB:
1203 cte = bmp->color_table[*bmap++];
1204 FILL_24BIT_888RGB (cte.red, cte.green, cte.blue);
1206 bmap += padded_line;
1207 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1213 padded_line -= 3 * width;
1215 switch (VIDEO_DATA_FORMAT) {
1216 case GDF__8BIT_332RGB:
1221 FILL_8BIT_332RGB (bmap[2], bmap[1], bmap[0]);
1224 bmap += padded_line;
1225 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1228 case GDF_15BIT_555RGB:
1230 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1236 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1237 fill_555rgb_pswap (fb, xpos++, bmap[2],
1241 FILL_15BIT_555RGB (bmap[2], bmap[1], bmap[0]);
1245 bmap += padded_line;
1246 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1249 case GDF_16BIT_565RGB:
1254 FILL_16BIT_565RGB (bmap[2], bmap[1], bmap[0]);
1257 bmap += padded_line;
1258 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1261 case GDF_32BIT_X888RGB:
1266 FILL_32BIT_X888RGB (bmap[2], bmap[1], bmap[0]);
1269 bmap += padded_line;
1270 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1273 case GDF_24BIT_888RGB:
1278 FILL_24BIT_888RGB (bmap[2], bmap[1], bmap[0]);
1281 bmap += padded_line;
1282 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1286 printf ("Error: 24 bits/pixel bitmap incompatible with current video mode\n");
1291 printf ("Error: %d bit/pixel bitmaps not supported by U-Boot\n",
1292 le16_to_cpu (bmp->header.bit_count));
1296 #ifdef CONFIG_VIDEO_BMP_GZIP
1306 /*****************************************************************************/
1308 #ifdef CONFIG_VIDEO_LOGO
1309 void logo_plot (void *screen, int width, int x, int y)
1313 int skip = (width - VIDEO_LOGO_WIDTH) * VIDEO_PIXEL_SIZE;
1314 int ycount = video_logo_height;
1315 unsigned char r, g, b, *logo_red, *logo_blue, *logo_green;
1316 unsigned char *source;
1317 unsigned char *dest = (unsigned char *)screen +
1318 ((y * width * VIDEO_PIXEL_SIZE) +
1319 x * VIDEO_PIXEL_SIZE);
1321 #ifdef CONFIG_VIDEO_BMP_LOGO
1322 source = bmp_logo_bitmap;
1324 /* Allocate temporary space for computing colormap */
1325 logo_red = malloc (BMP_LOGO_COLORS);
1326 logo_green = malloc (BMP_LOGO_COLORS);
1327 logo_blue = malloc (BMP_LOGO_COLORS);
1328 /* Compute color map */
1329 for (i = 0; i < VIDEO_LOGO_COLORS; i++) {
1330 logo_red[i] = (bmp_logo_palette[i] & 0x0f00) >> 4;
1331 logo_green[i] = (bmp_logo_palette[i] & 0x00f0);
1332 logo_blue[i] = (bmp_logo_palette[i] & 0x000f) << 4;
1335 source = linux_logo;
1336 logo_red = linux_logo_red;
1337 logo_green = linux_logo_green;
1338 logo_blue = linux_logo_blue;
1341 if (VIDEO_DATA_FORMAT == GDF__8BIT_INDEX) {
1342 for (i = 0; i < VIDEO_LOGO_COLORS; i++) {
1343 video_set_lut (i + VIDEO_LOGO_LUT_OFFSET,
1344 logo_red[i], logo_green[i], logo_blue[i]);
1349 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1352 xcount = VIDEO_LOGO_WIDTH;
1354 r = logo_red[*source - VIDEO_LOGO_LUT_OFFSET];
1355 g = logo_green[*source - VIDEO_LOGO_LUT_OFFSET];
1356 b = logo_blue[*source - VIDEO_LOGO_LUT_OFFSET];
1358 switch (VIDEO_DATA_FORMAT) {
1359 case GDF__8BIT_INDEX:
1362 case GDF__8BIT_332RGB:
1363 *dest = ((r >> 5) << 5) | ((g >> 5) << 2) | (b >> 6);
1365 case GDF_15BIT_555RGB:
1366 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1367 fill_555rgb_pswap (dest, xpos++, r, g, b);
1369 *(unsigned short *) dest =
1370 SWAP16 ((unsigned short) (((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3)));
1373 case GDF_16BIT_565RGB:
1374 *(unsigned short *) dest =
1375 SWAP16 ((unsigned short) (((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3)));
1377 case GDF_32BIT_X888RGB:
1378 *(unsigned long *) dest =
1379 SWAP32 ((unsigned long) ((r << 16) | (g << 8) | b));
1381 case GDF_24BIT_888RGB:
1382 #ifdef VIDEO_FB_LITTLE_ENDIAN
1394 dest += VIDEO_PIXEL_SIZE;
1398 #ifdef CONFIG_VIDEO_BMP_LOGO
1405 /*****************************************************************************/
1407 static void *video_logo (void)
1410 extern char version_string;
1411 int space, len, y_off = 0;
1413 #ifdef CONFIG_SPLASH_SCREEN
1417 if ((s = getenv ("splashimage")) != NULL) {
1420 addr = simple_strtoul (s, NULL, 16);
1421 #ifdef CONFIG_SPLASH_SCREEN_ALIGN
1422 if ((s = getenv ("splashpos")) != NULL) {
1424 x = BMP_ALIGN_CENTER;
1426 x = simple_strtol (s, NULL, 0);
1428 if ((s = strchr (s + 1, ',')) != NULL) {
1430 y = BMP_ALIGN_CENTER;
1432 y = simple_strtol (s + 1, NULL, 0);
1435 #endif /* CONFIG_SPLASH_SCREEN_ALIGN */
1437 if (video_display_bitmap (addr, x, y) == 0) {
1438 video_logo_height = 0;
1439 return ((void *) (video_fb_address));
1442 #endif /* CONFIG_SPLASH_SCREEN */
1444 logo_plot (video_fb_address, VIDEO_COLS, 0, 0);
1446 sprintf (info, " %s", &version_string);
1448 space = (VIDEO_LINE_LEN / 2 - VIDEO_INFO_X) / VIDEO_FONT_WIDTH;
1452 video_drawchars (VIDEO_INFO_X, VIDEO_INFO_Y,
1453 (uchar *)info, space);
1454 video_drawchars (VIDEO_INFO_X + VIDEO_FONT_WIDTH,
1455 VIDEO_INFO_Y + VIDEO_FONT_HEIGHT,
1456 (uchar *)info + space, len - space);
1459 video_drawstring (VIDEO_INFO_X, VIDEO_INFO_Y, (uchar *)info);
1461 #ifdef CONFIG_CONSOLE_EXTRA_INFO
1463 int i, n = ((video_logo_height - VIDEO_FONT_HEIGHT) / VIDEO_FONT_HEIGHT);
1465 for (i = 1; i < n; i++) {
1466 video_get_info_str (i, info);
1472 video_drawchars (VIDEO_INFO_X,
1474 (i + y_off) * VIDEO_FONT_HEIGHT,
1475 (uchar *)info, space);
1477 video_drawchars (VIDEO_INFO_X + VIDEO_FONT_WIDTH,
1479 (i + y_off) * VIDEO_FONT_HEIGHT,
1480 (uchar *)info + space,
1483 video_drawstring (VIDEO_INFO_X,
1485 (i + y_off) * VIDEO_FONT_HEIGHT,
1492 return (video_fb_address + video_logo_height * VIDEO_LINE_LEN);
1497 /*****************************************************************************/
1499 static int video_init (void)
1501 unsigned char color8;
1503 if ((pGD = video_hw_init ()) == NULL)
1506 video_fb_address = (void *) VIDEO_FB_ADRS;
1507 #ifdef CONFIG_VIDEO_HW_CURSOR
1508 video_init_hw_cursor (VIDEO_FONT_WIDTH, VIDEO_FONT_HEIGHT);
1511 /* Init drawing pats */
1512 switch (VIDEO_DATA_FORMAT) {
1513 case GDF__8BIT_INDEX:
1514 video_set_lut (0x01, CONSOLE_FG_COL, CONSOLE_FG_COL, CONSOLE_FG_COL);
1515 video_set_lut (0x00, CONSOLE_BG_COL, CONSOLE_BG_COL, CONSOLE_BG_COL);
1519 case GDF__8BIT_332RGB:
1520 color8 = ((CONSOLE_FG_COL & 0xe0) |
1521 ((CONSOLE_FG_COL >> 3) & 0x1c) | CONSOLE_FG_COL >> 6);
1522 fgx = (color8 << 24) | (color8 << 16) | (color8 << 8) | color8;
1523 color8 = ((CONSOLE_BG_COL & 0xe0) |
1524 ((CONSOLE_BG_COL >> 3) & 0x1c) | CONSOLE_BG_COL >> 6);
1525 bgx = (color8 << 24) | (color8 << 16) | (color8 << 8) | color8;
1527 case GDF_15BIT_555RGB:
1528 fgx = (((CONSOLE_FG_COL >> 3) << 26) |
1529 ((CONSOLE_FG_COL >> 3) << 21) | ((CONSOLE_FG_COL >> 3) << 16) |
1530 ((CONSOLE_FG_COL >> 3) << 10) | ((CONSOLE_FG_COL >> 3) << 5) |
1531 (CONSOLE_FG_COL >> 3));
1532 bgx = (((CONSOLE_BG_COL >> 3) << 26) |
1533 ((CONSOLE_BG_COL >> 3) << 21) | ((CONSOLE_BG_COL >> 3) << 16) |
1534 ((CONSOLE_BG_COL >> 3) << 10) | ((CONSOLE_BG_COL >> 3) << 5) |
1535 (CONSOLE_BG_COL >> 3));
1537 case GDF_16BIT_565RGB:
1538 fgx = (((CONSOLE_FG_COL >> 3) << 27) |
1539 ((CONSOLE_FG_COL >> 2) << 21) | ((CONSOLE_FG_COL >> 3) << 16) |
1540 ((CONSOLE_FG_COL >> 3) << 11) | ((CONSOLE_FG_COL >> 2) << 5) |
1541 (CONSOLE_FG_COL >> 3));
1542 bgx = (((CONSOLE_BG_COL >> 3) << 27) |
1543 ((CONSOLE_BG_COL >> 2) << 21) | ((CONSOLE_BG_COL >> 3) << 16) |
1544 ((CONSOLE_BG_COL >> 3) << 11) | ((CONSOLE_BG_COL >> 2) << 5) |
1545 (CONSOLE_BG_COL >> 3));
1547 case GDF_32BIT_X888RGB:
1548 fgx = (CONSOLE_FG_COL << 16) | (CONSOLE_FG_COL << 8) | CONSOLE_FG_COL;
1549 bgx = (CONSOLE_BG_COL << 16) | (CONSOLE_BG_COL << 8) | CONSOLE_BG_COL;
1551 case GDF_24BIT_888RGB:
1552 fgx = (CONSOLE_FG_COL << 24) | (CONSOLE_FG_COL << 16) |
1553 (CONSOLE_FG_COL << 8) | CONSOLE_FG_COL;
1554 bgx = (CONSOLE_BG_COL << 24) | (CONSOLE_BG_COL << 16) |
1555 (CONSOLE_BG_COL << 8) | CONSOLE_BG_COL;
1560 #ifdef CONFIG_VIDEO_LOGO
1561 /* Plot the logo and get start point of console */
1562 PRINTD ("Video: Drawing the logo ...\n");
1563 video_console_address = video_logo ();
1565 video_console_address = video_fb_address;
1568 /* Initialize the console */
1576 /*****************************************************************************/
1579 * Implement a weak default function for boards that optionally
1580 * need to skip the video initialization.
1582 int __board_video_skip(void)
1584 /* As default, don't skip test */
1587 int board_video_skip(void) __attribute__((weak, alias("__board_video_skip")));
1589 int drv_video_init (void)
1592 struct stdio_dev console_dev;
1594 /* Check if video initialization should be skipped */
1595 if (board_video_skip())
1598 /* Init video chip - returns with framebuffer cleared */
1599 skip_dev_init = (video_init () == -1);
1601 #if !defined(CONFIG_VGA_AS_SINGLE_DEVICE)
1602 PRINTD ("KBD: Keyboard init ...\n");
1603 skip_dev_init |= (VIDEO_KBD_INIT_FCT == -1);
1609 /* Init vga device */
1610 memset (&console_dev, 0, sizeof (console_dev));
1611 strcpy (console_dev.name, "vga");
1612 console_dev.ext = DEV_EXT_VIDEO; /* Video extensions */
1613 console_dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_SYSTEM;
1614 console_dev.putc = video_putc; /* 'putc' function */
1615 console_dev.puts = video_puts; /* 'puts' function */
1616 console_dev.tstc = NULL; /* 'tstc' function */
1617 console_dev.getc = NULL; /* 'getc' function */
1619 #if !defined(CONFIG_VGA_AS_SINGLE_DEVICE)
1620 /* Also init console device */
1621 console_dev.flags |= DEV_FLAGS_INPUT;
1622 console_dev.tstc = VIDEO_TSTC_FCT; /* 'tstc' function */
1623 console_dev.getc = VIDEO_GETC_FCT; /* 'getc' function */
1624 #endif /* CONFIG_VGA_AS_SINGLE_DEVICE */
1626 if (stdio_register (&console_dev) != 0)
1629 /* Return success */