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 normally goes to serial port) can be drawn.
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
63 * delay loop in VIDEO_TSTC_FCT (i8042)
65 * CONFIG_SYS_CONSOLE_BLINK_COUNT - value for delay loop - blink rate
66 * CONFIG_CONSOLE_TIME - display time/date in upper right
67 * corner, needs CONFIG_CMD_DATE and
68 * CONFIG_CONSOLE_CURSOR
69 * CONFIG_VIDEO_LOGO - display Linux Logo in upper left corner
70 * CONFIG_VIDEO_BMP_LOGO - use bmp_logo instead of linux_logo
71 * CONFIG_CONSOLE_EXTRA_INFO - display additional board information
72 * strings that normaly goes to serial
73 * port. This define requires a board
75 * video_drawstring (VIDEO_INFO_X,
76 * VIDEO_INFO_Y + i*VIDEO_FONT_HEIGHT,
78 * that fills a info buffer at i=row.
79 * s.a: board/eltec/bab7xx.
80 * CONFIG_VGA_AS_SINGLE_DEVICE - If set the framebuffer device will be
81 * initialized as an output only device.
82 * The Keyboard driver will not be
83 * set-up. This may be used, if you have
84 * no or more than one Keyboard devices
85 * (USB Keyboard, AT Keyboard).
87 * CONFIG_VIDEO_SW_CURSOR: - Draws a cursor after the last
88 * character. No blinking is provided.
89 * Uses the macros CURSOR_SET and
92 * CONFIG_VIDEO_HW_CURSOR: - Uses the hardware cursor capability
93 * of the graphic chip. Uses the macro
94 * CURSOR_SET. ATTENTION: If booting an
95 * OS, the display driver must disable
96 * the hardware register of the graphic
97 * chip. Otherwise a blinking field is
104 #include <linux/compiler.h>
107 * Console device defines with SMI graphic
108 * Any other graphic must change this section
111 #ifdef CONFIG_VIDEO_SMI_LYNXEM
113 #define VIDEO_FB_LITTLE_ENDIAN
114 #define VIDEO_HW_RECTFILL
115 #define VIDEO_HW_BITBLT
119 * Defines for the CT69000 driver
121 #ifdef CONFIG_VIDEO_CT69000
123 #define VIDEO_FB_LITTLE_ENDIAN
124 #define VIDEO_HW_RECTFILL
125 #define VIDEO_HW_BITBLT
129 * Defines for the SED13806 driver
131 #ifdef CONFIG_VIDEO_SED13806
133 #ifndef CONFIG_TOTAL5200
134 #define VIDEO_FB_LITTLE_ENDIAN
136 #define VIDEO_HW_RECTFILL
137 #define VIDEO_HW_BITBLT
141 * Defines for the SED13806 driver
143 #ifdef CONFIG_VIDEO_SM501
146 #define VIDEO_FB_LITTLE_ENDIAN
151 * Defines for the MB862xx driver
153 #ifdef CONFIG_VIDEO_MB862xx
155 #ifdef CONFIG_VIDEO_CORALP
156 #define VIDEO_FB_LITTLE_ENDIAN
158 #ifdef CONFIG_VIDEO_MB862xx_ACCEL
159 #define VIDEO_HW_RECTFILL
160 #define VIDEO_HW_BITBLT
165 * Defines for the i.MX31 driver (mx3fb.c)
167 #if defined(CONFIG_VIDEO_MX3) || defined(CONFIG_VIDEO_MX5)
168 #define VIDEO_FB_16BPP_WORD_SWAP
172 * Include video_fb.h after definitions of VIDEO_HW_RECTFILL etc.
174 #include <video_fb.h>
179 #define VIDEO_VISIBLE_COLS (pGD->winSizeX)
180 #define VIDEO_VISIBLE_ROWS (pGD->winSizeY)
181 #define VIDEO_PIXEL_SIZE (pGD->gdfBytesPP)
182 #define VIDEO_DATA_FORMAT (pGD->gdfIndex)
183 #define VIDEO_FB_ADRS (pGD->frameAdrs)
186 * Console device defines with i8042 keyboard controller
187 * Any other keyboard controller must change this section
190 #ifdef CONFIG_I8042_KBD
193 #define VIDEO_KBD_INIT_FCT i8042_kbd_init()
194 #define VIDEO_TSTC_FCT i8042_tstc
195 #define VIDEO_GETC_FCT i8042_getc
203 #include <linux/types.h>
204 #include <stdio_dev.h>
205 #include <video_font.h>
206 #include <video_font_data.h>
208 #if defined(CONFIG_CMD_DATE)
212 #if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN)
213 #include <watchdog.h>
214 #include <bmp_layout.h>
216 #ifdef CONFIG_SPLASH_SCREEN_ALIGN
217 #define BMP_ALIGN_CENTER 0x7FFF
224 * CONFIG_CONSOLE_CURSOR: Uses a timer function (see drivers/input/i8042.c)
225 * to let the cursor blink. Uses the macros
226 * CURSOR_OFF and CURSOR_ON.
227 * CONFIG_VIDEO_SW_CURSOR: Draws a cursor after the last character. No
228 * blinking is provided. Uses the macros CURSOR_SET
230 * CONFIG_VIDEO_HW_CURSOR: Uses the hardware cursor capability of the
231 * graphic chip. Uses the macro CURSOR_SET.
232 * ATTENTION: If booting an OS, the display driver
233 * must disable the hardware register of the graphic
234 * chip. Otherwise a blinking field is displayed
236 #if !defined(CONFIG_CONSOLE_CURSOR) && \
237 !defined(CONFIG_VIDEO_SW_CURSOR) && \
238 !defined(CONFIG_VIDEO_HW_CURSOR)
239 /* no Cursor defined */
245 #ifdef CONFIG_CONSOLE_CURSOR
247 #error only one of CONFIG_CONSOLE_CURSOR, CONFIG_VIDEO_SW_CURSOR, \
248 or CONFIG_VIDEO_HW_CURSOR can be defined
250 void console_cursor(int state);
252 #define CURSOR_ON console_cursor(1)
253 #define CURSOR_OFF console_cursor(0)
255 #ifndef CONFIG_I8042_KBD
256 #warning Cursor drawing on/off needs timer function s.a. drivers/input/i8042.c
259 #ifdef CONFIG_CONSOLE_TIME
260 #error CONFIG_CONSOLE_CURSOR must be defined for CONFIG_CONSOLE_TIME
262 #endif /* CONFIG_CONSOLE_CURSOR */
264 #ifdef CONFIG_VIDEO_SW_CURSOR
266 #error only one of CONFIG_CONSOLE_CURSOR, CONFIG_VIDEO_SW_CURSOR, \
267 or CONFIG_VIDEO_HW_CURSOR can be defined
270 #define CURSOR_OFF video_putchar(console_col * VIDEO_FONT_WIDTH,\
271 console_row * VIDEO_FONT_HEIGHT, ' ')
272 #define CURSOR_SET video_set_cursor()
273 #endif /* CONFIG_VIDEO_SW_CURSOR */
276 #ifdef CONFIG_VIDEO_HW_CURSOR
278 #error only one of CONFIG_CONSOLE_CURSOR, CONFIG_VIDEO_SW_CURSOR, \
279 or CONFIG_VIDEO_HW_CURSOR can be defined
283 #define CURSOR_SET video_set_hw_cursor(console_col * VIDEO_FONT_WIDTH, \
284 (console_row * VIDEO_FONT_HEIGHT) + video_logo_height)
285 #endif /* CONFIG_VIDEO_HW_CURSOR */
287 #ifdef CONFIG_VIDEO_LOGO
288 #ifdef CONFIG_VIDEO_BMP_LOGO
289 #include <bmp_logo.h>
290 #include <bmp_logo_data.h>
291 #define VIDEO_LOGO_WIDTH BMP_LOGO_WIDTH
292 #define VIDEO_LOGO_HEIGHT BMP_LOGO_HEIGHT
293 #define VIDEO_LOGO_LUT_OFFSET BMP_LOGO_OFFSET
294 #define VIDEO_LOGO_COLORS BMP_LOGO_COLORS
296 #else /* CONFIG_VIDEO_BMP_LOGO */
297 #define LINUX_LOGO_WIDTH 80
298 #define LINUX_LOGO_HEIGHT 80
299 #define LINUX_LOGO_COLORS 214
300 #define LINUX_LOGO_LUT_OFFSET 0x20
302 #include <linux_logo.h>
303 #define VIDEO_LOGO_WIDTH LINUX_LOGO_WIDTH
304 #define VIDEO_LOGO_HEIGHT LINUX_LOGO_HEIGHT
305 #define VIDEO_LOGO_LUT_OFFSET LINUX_LOGO_LUT_OFFSET
306 #define VIDEO_LOGO_COLORS LINUX_LOGO_COLORS
307 #endif /* CONFIG_VIDEO_BMP_LOGO */
308 #define VIDEO_INFO_X (VIDEO_LOGO_WIDTH)
309 #define VIDEO_INFO_Y (VIDEO_FONT_HEIGHT/2)
310 #else /* CONFIG_VIDEO_LOGO */
311 #define VIDEO_LOGO_WIDTH 0
312 #define VIDEO_LOGO_HEIGHT 0
313 #endif /* CONFIG_VIDEO_LOGO */
315 #define VIDEO_COLS VIDEO_VISIBLE_COLS
316 #define VIDEO_ROWS VIDEO_VISIBLE_ROWS
317 #define VIDEO_SIZE (VIDEO_ROWS*VIDEO_COLS*VIDEO_PIXEL_SIZE)
318 #define VIDEO_PIX_BLOCKS (VIDEO_SIZE >> 2)
319 #define VIDEO_LINE_LEN (VIDEO_COLS*VIDEO_PIXEL_SIZE)
320 #define VIDEO_BURST_LEN (VIDEO_COLS/8)
322 #ifdef CONFIG_VIDEO_LOGO
323 #define CONSOLE_ROWS ((VIDEO_ROWS - video_logo_height) / VIDEO_FONT_HEIGHT)
325 #define CONSOLE_ROWS (VIDEO_ROWS / VIDEO_FONT_HEIGHT)
328 #define CONSOLE_COLS (VIDEO_COLS / VIDEO_FONT_WIDTH)
329 #define CONSOLE_ROW_SIZE (VIDEO_FONT_HEIGHT * VIDEO_LINE_LEN)
330 #define CONSOLE_ROW_FIRST (video_console_address)
331 #define CONSOLE_ROW_SECOND (video_console_address + CONSOLE_ROW_SIZE)
332 #define CONSOLE_ROW_LAST (video_console_address + CONSOLE_SIZE - CONSOLE_ROW_SIZE)
333 #define CONSOLE_SIZE (CONSOLE_ROW_SIZE * CONSOLE_ROWS)
334 #define CONSOLE_SCROLL_SIZE (CONSOLE_SIZE - CONSOLE_ROW_SIZE)
337 #ifdef VIDEO_FB_LITTLE_ENDIAN
338 #define SWAP16(x) ((((x) & 0x00ff) << 8) | \
341 #define SWAP32(x) ((((x) & 0x000000ff) << 24) | \
342 (((x) & 0x0000ff00) << 8) | \
343 (((x) & 0x00ff0000) >> 8) | \
344 (((x) & 0xff000000) >> 24) \
346 #define SHORTSWAP32(x) ((((x) & 0x000000ff) << 8) | \
347 (((x) & 0x0000ff00) >> 8) | \
348 (((x) & 0x00ff0000) << 8) | \
349 (((x) & 0xff000000) >> 8) \
352 #define SWAP16(x) (x)
353 #define SWAP32(x) (x)
354 #if defined(VIDEO_FB_16BPP_WORD_SWAP)
355 #define SHORTSWAP32(x) (((x) >> 16) | ((x) << 16))
357 #define SHORTSWAP32(x) (x)
361 #ifdef CONFIG_CONSOLE_EXTRA_INFO
363 * setup a board string: type, speed, etc.
365 * line_number: location to place info string beside logo
366 * info: buffer for info string
368 extern void video_get_info_str(int line_number, char *info);
372 static GraphicDevice *pGD; /* Pointer to Graphic array */
374 static void *video_fb_address; /* frame buffer address */
375 static void *video_console_address; /* console buffer start address */
377 static int video_logo_height = VIDEO_LOGO_HEIGHT;
379 static int console_col; /* cursor col */
380 static int console_row; /* cursor row */
382 static u32 eorx, fgx, bgx; /* color pats */
384 static const int video_font_draw_table8[] = {
385 0x00000000, 0x000000ff, 0x0000ff00, 0x0000ffff,
386 0x00ff0000, 0x00ff00ff, 0x00ffff00, 0x00ffffff,
387 0xff000000, 0xff0000ff, 0xff00ff00, 0xff00ffff,
388 0xffff0000, 0xffff00ff, 0xffffff00, 0xffffffff
391 static const int video_font_draw_table15[] = {
392 0x00000000, 0x00007fff, 0x7fff0000, 0x7fff7fff
395 static const int video_font_draw_table16[] = {
396 0x00000000, 0x0000ffff, 0xffff0000, 0xffffffff
399 static const int video_font_draw_table24[16][3] = {
400 {0x00000000, 0x00000000, 0x00000000},
401 {0x00000000, 0x00000000, 0x00ffffff},
402 {0x00000000, 0x0000ffff, 0xff000000},
403 {0x00000000, 0x0000ffff, 0xffffffff},
404 {0x000000ff, 0xffff0000, 0x00000000},
405 {0x000000ff, 0xffff0000, 0x00ffffff},
406 {0x000000ff, 0xffffffff, 0xff000000},
407 {0x000000ff, 0xffffffff, 0xffffffff},
408 {0xffffff00, 0x00000000, 0x00000000},
409 {0xffffff00, 0x00000000, 0x00ffffff},
410 {0xffffff00, 0x0000ffff, 0xff000000},
411 {0xffffff00, 0x0000ffff, 0xffffffff},
412 {0xffffffff, 0xffff0000, 0x00000000},
413 {0xffffffff, 0xffff0000, 0x00ffffff},
414 {0xffffffff, 0xffffffff, 0xff000000},
415 {0xffffffff, 0xffffffff, 0xffffffff}
418 static const int video_font_draw_table32[16][4] = {
419 {0x00000000, 0x00000000, 0x00000000, 0x00000000},
420 {0x00000000, 0x00000000, 0x00000000, 0x00ffffff},
421 {0x00000000, 0x00000000, 0x00ffffff, 0x00000000},
422 {0x00000000, 0x00000000, 0x00ffffff, 0x00ffffff},
423 {0x00000000, 0x00ffffff, 0x00000000, 0x00000000},
424 {0x00000000, 0x00ffffff, 0x00000000, 0x00ffffff},
425 {0x00000000, 0x00ffffff, 0x00ffffff, 0x00000000},
426 {0x00000000, 0x00ffffff, 0x00ffffff, 0x00ffffff},
427 {0x00ffffff, 0x00000000, 0x00000000, 0x00000000},
428 {0x00ffffff, 0x00000000, 0x00000000, 0x00ffffff},
429 {0x00ffffff, 0x00000000, 0x00ffffff, 0x00000000},
430 {0x00ffffff, 0x00000000, 0x00ffffff, 0x00ffffff},
431 {0x00ffffff, 0x00ffffff, 0x00000000, 0x00000000},
432 {0x00ffffff, 0x00ffffff, 0x00000000, 0x00ffffff},
433 {0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00000000},
434 {0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00ffffff}
438 static void video_drawchars(int xx, int yy, unsigned char *s, int count)
440 u8 *cdat, *dest, *dest0;
443 offset = yy * VIDEO_LINE_LEN + xx * VIDEO_PIXEL_SIZE;
444 dest0 = video_fb_address + offset;
446 switch (VIDEO_DATA_FORMAT) {
447 case GDF__8BIT_INDEX:
448 case GDF__8BIT_332RGB:
451 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
452 for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
453 rows--; dest += VIDEO_LINE_LEN) {
457 (video_font_draw_table8[bits >> 4] &
460 (video_font_draw_table8[bits & 15] &
463 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
468 case GDF_15BIT_555RGB:
471 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
472 for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
473 rows--; dest += VIDEO_LINE_LEN) {
477 SHORTSWAP32((video_font_draw_table15
478 [bits >> 6] & eorx) ^
481 SHORTSWAP32((video_font_draw_table15
482 [bits >> 4 & 3] & eorx) ^
485 SHORTSWAP32((video_font_draw_table15
486 [bits >> 2 & 3] & eorx) ^
489 SHORTSWAP32((video_font_draw_table15
493 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
498 case GDF_16BIT_565RGB:
501 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
502 for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
503 rows--; dest += VIDEO_LINE_LEN) {
507 SHORTSWAP32((video_font_draw_table16
508 [bits >> 6] & eorx) ^
511 SHORTSWAP32((video_font_draw_table16
512 [bits >> 4 & 3] & eorx) ^
515 SHORTSWAP32((video_font_draw_table16
516 [bits >> 2 & 3] & eorx) ^
519 SHORTSWAP32((video_font_draw_table16
523 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
528 case GDF_32BIT_X888RGB:
531 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
532 for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
533 rows--; dest += VIDEO_LINE_LEN) {
537 SWAP32((video_font_draw_table32
538 [bits >> 4][0] & eorx) ^ bgx);
540 SWAP32((video_font_draw_table32
541 [bits >> 4][1] & eorx) ^ bgx);
543 SWAP32((video_font_draw_table32
544 [bits >> 4][2] & eorx) ^ bgx);
546 SWAP32((video_font_draw_table32
547 [bits >> 4][3] & eorx) ^ bgx);
549 SWAP32((video_font_draw_table32
550 [bits & 15][0] & eorx) ^ bgx);
552 SWAP32((video_font_draw_table32
553 [bits & 15][1] & eorx) ^ bgx);
555 SWAP32((video_font_draw_table32
556 [bits & 15][2] & eorx) ^ bgx);
558 SWAP32((video_font_draw_table32
559 [bits & 15][3] & eorx) ^ bgx);
561 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
566 case GDF_24BIT_888RGB:
569 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
570 for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
571 rows--; dest += VIDEO_LINE_LEN) {
575 (video_font_draw_table24[bits >> 4][0]
578 (video_font_draw_table24[bits >> 4][1]
581 (video_font_draw_table24[bits >> 4][2]
584 (video_font_draw_table24[bits & 15][0]
587 (video_font_draw_table24[bits & 15][1]
590 (video_font_draw_table24[bits & 15][2]
593 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
600 static inline void video_drawstring(int xx, int yy, unsigned char *s)
602 video_drawchars(xx, yy, s, strlen((char *) s));
605 static void video_putchar(int xx, int yy, unsigned char c)
607 video_drawchars(xx, yy + video_logo_height, &c, 1);
610 #if defined(CONFIG_CONSOLE_CURSOR) || defined(CONFIG_VIDEO_SW_CURSOR)
611 static void video_set_cursor(void)
613 /* swap drawing colors */
619 video_putchar(console_col * VIDEO_FONT_WIDTH,
620 console_row * VIDEO_FONT_HEIGHT, ' ');
621 /* restore drawing colors */
629 #ifdef CONFIG_CONSOLE_CURSOR
630 void console_cursor(int state)
632 static int last_state = 0;
634 #ifdef CONFIG_CONSOLE_TIME
638 /* time update only if cursor is on (faster scroll) */
642 sprintf(info, " %02d:%02d:%02d ", tm.tm_hour, tm.tm_min,
644 video_drawstring(VIDEO_VISIBLE_COLS - 10 * VIDEO_FONT_WIDTH,
645 VIDEO_INFO_Y, (uchar *) info);
647 sprintf(info, "%02d.%02d.%04d", tm.tm_mday, tm.tm_mon,
649 video_drawstring(VIDEO_VISIBLE_COLS - 10 * VIDEO_FONT_WIDTH,
650 VIDEO_INFO_Y + 1 * VIDEO_FONT_HEIGHT,
655 if (state && (last_state != state)) {
659 if (!state && (last_state != state)) {
661 video_putchar(console_col * VIDEO_FONT_WIDTH,
662 console_row * VIDEO_FONT_HEIGHT, ' ');
669 #ifndef VIDEO_HW_RECTFILL
670 static void memsetl(int *p, int c, int v)
677 #ifndef VIDEO_HW_BITBLT
678 static void memcpyl(int *d, int *s, int c)
685 static void console_scrollup(void)
687 /* copy up rows ignoring the first one */
689 #ifdef VIDEO_HW_BITBLT
690 video_hw_bitblt(VIDEO_PIXEL_SIZE, /* bytes per pixel */
691 0, /* source pos x */
693 VIDEO_FONT_HEIGHT, /* source pos y */
695 video_logo_height, /* dest pos y */
696 VIDEO_VISIBLE_COLS, /* frame width */
699 - VIDEO_FONT_HEIGHT /* frame height */
702 memcpyl(CONSOLE_ROW_FIRST, CONSOLE_ROW_SECOND,
703 CONSOLE_SCROLL_SIZE >> 2);
706 /* clear the last one */
707 #ifdef VIDEO_HW_RECTFILL
708 video_hw_rectfill(VIDEO_PIXEL_SIZE, /* bytes per pixel */
711 - VIDEO_FONT_HEIGHT, /* dest pos y */
712 VIDEO_VISIBLE_COLS, /* frame width */
713 VIDEO_FONT_HEIGHT, /* frame height */
714 CONSOLE_BG_COL /* fill color */
717 memsetl(CONSOLE_ROW_LAST, CONSOLE_ROW_SIZE >> 2, CONSOLE_BG_COL);
721 static void console_back(void)
726 if (console_col < 0) {
727 console_col = CONSOLE_COLS - 1;
732 video_putchar(console_col * VIDEO_FONT_WIDTH,
733 console_row * VIDEO_FONT_HEIGHT, ' ');
736 static void console_newline(void)
738 /* Check if last character in the line was just drawn. If so, cursor was
739 overwriten and need not to be cleared. Cursor clearing without this
740 check causes overwriting the 1st character of the line if line lenght
743 if (console_col < CONSOLE_COLS)
748 /* Check if we need to scroll the terminal */
749 if (console_row >= CONSOLE_ROWS) {
750 /* Scroll everything up */
753 /* Decrement row number */
758 static void console_cr(void)
764 void video_putc(const char c)
769 case 13: /* back to first column */
773 case '\n': /* next line */
774 if (console_col || (!console_col && nl))
781 console_col |= 0x0008;
782 console_col &= ~0x0007;
784 if (console_col >= CONSOLE_COLS)
788 case 8: /* backspace */
792 default: /* draw the char */
793 video_putchar(console_col * VIDEO_FONT_WIDTH,
794 console_row * VIDEO_FONT_HEIGHT, c);
797 /* check for newline */
798 if (console_col >= CONSOLE_COLS) {
806 void video_puts(const char *s)
808 int count = strlen(s);
815 * Do not enforce drivers (or board code) to provide empty
816 * video_set_lut() if they do not support 8 bpp format.
817 * Implement weak default function instead.
819 void __video_set_lut(unsigned int index, unsigned char r,
820 unsigned char g, unsigned char b)
824 void video_set_lut(unsigned int, unsigned char, unsigned char, unsigned char)
825 __attribute__ ((weak, alias("__video_set_lut")));
827 #if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN)
829 #define FILL_8BIT_332RGB(r,g,b) { \
830 *fb = ((r>>5)<<5) | ((g>>5)<<2) | (b>>6); \
834 #define FILL_15BIT_555RGB(r,g,b) { \
835 *(unsigned short *)fb = \
836 SWAP16((unsigned short)(((r>>3)<<10) | \
842 #define FILL_16BIT_565RGB(r,g,b) { \
843 *(unsigned short *)fb = \
844 SWAP16((unsigned short)((((r)>>3)<<11)| \
850 #define FILL_32BIT_X888RGB(r,g,b) { \
851 *(unsigned long *)fb = \
852 SWAP32((unsigned long)(((r<<16) | \
858 #ifdef VIDEO_FB_LITTLE_ENDIAN
859 #define FILL_24BIT_888RGB(r,g,b) { \
866 #define FILL_24BIT_888RGB(r,g,b) { \
874 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
875 static inline void fill_555rgb_pswap(uchar *fb, int x, u8 r, u8 g, u8 b)
877 ushort *dst = (ushort *) fb;
878 ushort color = (ushort) (((r >> 3) << 10) |
889 * RLE8 bitmap support
892 #ifdef CONFIG_VIDEO_BMP_RLE8
893 /* Pre-calculated color table entry */
896 unsigned short w; /* word */
897 unsigned int dw; /* double word */
898 } ce; /* color entry */
902 * Helper to draw encoded/unencoded run.
904 static void draw_bitmap(uchar **fb, uchar *bm, struct palette *p,
907 ulong addr = (ulong) *fb;
913 * Setup offset of the color index in the bitmap.
914 * Color index of encoded run is at offset 1.
916 off = enc ? &enc_off : &i;
918 switch (VIDEO_DATA_FORMAT) {
919 case GDF__8BIT_INDEX:
920 for (i = 0; i < cnt; i++)
921 *(unsigned char *) addr++ = bm[*off];
923 case GDF_15BIT_555RGB:
924 case GDF_16BIT_565RGB:
925 /* differences handled while pre-calculating palette */
926 for (i = 0; i < cnt; i++) {
927 *(unsigned short *) addr = p[bm[*off]].ce.w;
931 case GDF_32BIT_X888RGB:
932 for (i = 0; i < cnt; i++) {
933 *(unsigned long *) addr = p[bm[*off]].ce.dw;
938 *fb = (uchar *) addr; /* return modified address */
941 static int display_rle8_bitmap(bmp_image_t *img, int xoff, int yoff,
942 int width, int height)
946 unsigned int cnt, runlen;
948 int x, y, bpp, i, ncolors;
949 struct palette p[256];
950 bmp_color_table_entry_t cte;
951 int green_shift, red_off;
952 int limit = VIDEO_COLS * VIDEO_ROWS;
956 y = __le32_to_cpu(img->header.height) - 1;
957 ncolors = __le32_to_cpu(img->header.colors_used);
958 bpp = VIDEO_PIXEL_SIZE;
959 fbp = (unsigned char *) ((unsigned int) video_fb_address +
960 (((y + yoff) * VIDEO_COLS) + xoff) * bpp);
962 bm = (uchar *) img + __le32_to_cpu(img->header.data_offset);
964 /* pre-calculate and setup palette */
965 switch (VIDEO_DATA_FORMAT) {
966 case GDF__8BIT_INDEX:
967 for (i = 0; i < ncolors; i++) {
968 cte = img->color_table[i];
969 video_set_lut(i, cte.red, cte.green, cte.blue);
972 case GDF_15BIT_555RGB:
973 case GDF_16BIT_565RGB:
974 if (VIDEO_DATA_FORMAT == GDF_15BIT_555RGB) {
981 for (i = 0; i < ncolors; i++) {
982 cte = img->color_table[i];
983 p[i].ce.w = SWAP16((unsigned short)
984 (((cte.red >> 3) << red_off) |
985 ((cte.green >> green_shift) << 5) |
989 case GDF_32BIT_X888RGB:
990 for (i = 0; i < ncolors; i++) {
991 cte = img->color_table[i];
992 p[i].ce.dw = SWAP32((cte.red << 16) |
998 printf("RLE Bitmap unsupported in video mode 0x%x\n",
1008 /* scan line end marker */
1012 fbp = (unsigned char *)
1013 ((unsigned int) video_fb_address +
1014 (((y + yoff) * VIDEO_COLS) +
1018 /* end of bitmap data marker */
1022 /* run offset marker */
1025 fbp = (unsigned char *)
1026 ((unsigned int) video_fb_address +
1027 (((y + yoff) * VIDEO_COLS) +
1045 if (x + runlen > width)
1047 draw_bitmap(&fbp, bm, p, cnt, 0);
1053 bm++; /* 0 padding if length is odd */
1064 if (y < height) { /* only draw into visible area */
1070 if (x + runlen > width)
1072 draw_bitmap(&fbp, bm, p, cnt, 1);
1081 printf("Error: Too much encoded pixel data, validate your bitmap\n");
1087 * Display the BMP file located at address bmp_image.
1089 int video_display_bitmap(ulong bmp_image, int x, int y)
1091 ushort xcount, ycount;
1093 bmp_image_t *bmp = (bmp_image_t *) bmp_image;
1096 unsigned long width, height, bpp;
1098 unsigned long compression;
1099 bmp_color_table_entry_t cte;
1101 #ifdef CONFIG_VIDEO_BMP_GZIP
1102 unsigned char *dst = NULL;
1108 if (!((bmp->header.signature[0] == 'B') &&
1109 (bmp->header.signature[1] == 'M'))) {
1111 #ifdef CONFIG_VIDEO_BMP_GZIP
1113 * Could be a gzipped bmp image, try to decrompress...
1115 len = CONFIG_SYS_VIDEO_LOGO_MAX_SIZE;
1116 dst = malloc(CONFIG_SYS_VIDEO_LOGO_MAX_SIZE);
1118 printf("Error: malloc in gunzip failed!\n");
1121 if (gunzip(dst, CONFIG_SYS_VIDEO_LOGO_MAX_SIZE,
1122 (uchar *) bmp_image,
1124 printf("Error: no valid bmp or bmp.gz image at %lx\n",
1129 if (len == CONFIG_SYS_VIDEO_LOGO_MAX_SIZE) {
1130 printf("Image could be truncated "
1131 "(increase CONFIG_SYS_VIDEO_LOGO_MAX_SIZE)!\n");
1135 * Set addr to decompressed image
1137 bmp = (bmp_image_t *) dst;
1139 if (!((bmp->header.signature[0] == 'B') &&
1140 (bmp->header.signature[1] == 'M'))) {
1141 printf("Error: no valid bmp.gz image at %lx\n",
1147 printf("Error: no valid bmp image at %lx\n", bmp_image);
1149 #endif /* CONFIG_VIDEO_BMP_GZIP */
1152 width = le32_to_cpu(bmp->header.width);
1153 height = le32_to_cpu(bmp->header.height);
1154 bpp = le16_to_cpu(bmp->header.bit_count);
1155 colors = le32_to_cpu(bmp->header.colors_used);
1156 compression = le32_to_cpu(bmp->header.compression);
1158 debug("Display-bmp: %ld x %ld with %d colors\n",
1159 width, height, colors);
1161 if (compression != BMP_BI_RGB
1162 #ifdef CONFIG_VIDEO_BMP_RLE8
1163 && compression != BMP_BI_RLE8
1166 printf("Error: compression type %ld not supported\n",
1168 #ifdef CONFIG_VIDEO_BMP_GZIP
1175 padded_line = (((width * bpp + 7) / 8) + 3) & ~0x3;
1177 #ifdef CONFIG_SPLASH_SCREEN_ALIGN
1178 if (x == BMP_ALIGN_CENTER)
1179 x = max(0, (VIDEO_VISIBLE_COLS - width) / 2);
1181 x = max(0, VIDEO_VISIBLE_COLS - width + x + 1);
1183 if (y == BMP_ALIGN_CENTER)
1184 y = max(0, (VIDEO_VISIBLE_ROWS - height) / 2);
1186 y = max(0, VIDEO_VISIBLE_ROWS - height + y + 1);
1187 #endif /* CONFIG_SPLASH_SCREEN_ALIGN */
1189 if ((x + width) > VIDEO_VISIBLE_COLS)
1190 width = VIDEO_VISIBLE_COLS - x;
1191 if ((y + height) > VIDEO_VISIBLE_ROWS)
1192 height = VIDEO_VISIBLE_ROWS - y;
1194 bmap = (uchar *) bmp + le32_to_cpu(bmp->header.data_offset);
1195 fb = (uchar *) (video_fb_address +
1196 ((y + height - 1) * VIDEO_COLS * VIDEO_PIXEL_SIZE) +
1197 x * VIDEO_PIXEL_SIZE);
1199 #ifdef CONFIG_VIDEO_BMP_RLE8
1200 if (compression == BMP_BI_RLE8) {
1201 return display_rle8_bitmap(bmp, x, y, width, height);
1205 /* We handle only 4, 8, or 24 bpp bitmaps */
1206 switch (le16_to_cpu(bmp->header.bit_count)) {
1208 padded_line -= width / 2;
1211 switch (VIDEO_DATA_FORMAT) {
1212 case GDF_32BIT_X888RGB:
1216 * Don't assume that 'width' is an
1219 for (xcount = 0; xcount < width; xcount++) {
1227 cte = bmp->color_table[idx];
1228 FILL_32BIT_X888RGB(cte.red, cte.green,
1231 bmap += padded_line;
1232 fb -= (VIDEO_VISIBLE_COLS + width) *
1237 puts("4bpp bitmap unsupported with current "
1244 padded_line -= width;
1245 if (VIDEO_DATA_FORMAT == GDF__8BIT_INDEX) {
1247 for (xcount = 0; xcount < colors; ++xcount) {
1248 cte = bmp->color_table[xcount];
1249 video_set_lut(xcount, cte.red, cte.green,
1254 switch (VIDEO_DATA_FORMAT) {
1255 case GDF__8BIT_INDEX:
1262 bmap += padded_line;
1263 fb -= (VIDEO_VISIBLE_COLS + width) *
1267 case GDF__8BIT_332RGB:
1272 cte = bmp->color_table[*bmap++];
1273 FILL_8BIT_332RGB(cte.red, cte.green,
1276 bmap += padded_line;
1277 fb -= (VIDEO_VISIBLE_COLS + width) *
1281 case GDF_15BIT_555RGB:
1283 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1289 cte = bmp->color_table[*bmap++];
1290 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1291 fill_555rgb_pswap(fb, xpos++, cte.red,
1296 FILL_15BIT_555RGB(cte.red, cte.green,
1300 bmap += padded_line;
1301 fb -= (VIDEO_VISIBLE_COLS + width) *
1305 case GDF_16BIT_565RGB:
1310 cte = bmp->color_table[*bmap++];
1311 FILL_16BIT_565RGB(cte.red, cte.green,
1314 bmap += padded_line;
1315 fb -= (VIDEO_VISIBLE_COLS + width) *
1319 case GDF_32BIT_X888RGB:
1324 cte = bmp->color_table[*bmap++];
1325 FILL_32BIT_X888RGB(cte.red, cte.green,
1328 bmap += padded_line;
1329 fb -= (VIDEO_VISIBLE_COLS + width) *
1333 case GDF_24BIT_888RGB:
1338 cte = bmp->color_table[*bmap++];
1339 FILL_24BIT_888RGB(cte.red, cte.green,
1342 bmap += padded_line;
1343 fb -= (VIDEO_VISIBLE_COLS + width) *
1350 padded_line -= 3 * width;
1352 switch (VIDEO_DATA_FORMAT) {
1353 case GDF__8BIT_332RGB:
1358 FILL_8BIT_332RGB(bmap[2], bmap[1],
1362 bmap += padded_line;
1363 fb -= (VIDEO_VISIBLE_COLS + width) *
1367 case GDF_15BIT_555RGB:
1369 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1375 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1376 fill_555rgb_pswap(fb, xpos++, bmap[2],
1380 FILL_15BIT_555RGB(bmap[2], bmap[1],
1385 bmap += padded_line;
1386 fb -= (VIDEO_VISIBLE_COLS + width) *
1390 case GDF_16BIT_565RGB:
1395 FILL_16BIT_565RGB(bmap[2], bmap[1],
1399 bmap += padded_line;
1400 fb -= (VIDEO_VISIBLE_COLS + width) *
1404 case GDF_32BIT_X888RGB:
1409 FILL_32BIT_X888RGB(bmap[2], bmap[1],
1413 bmap += padded_line;
1414 fb -= (VIDEO_VISIBLE_COLS + width) *
1418 case GDF_24BIT_888RGB:
1423 FILL_24BIT_888RGB(bmap[2], bmap[1],
1427 bmap += padded_line;
1428 fb -= (VIDEO_VISIBLE_COLS + width) *
1433 printf("Error: 24 bits/pixel bitmap incompatible "
1434 "with current video mode\n");
1439 printf("Error: %d bit/pixel bitmaps not supported by U-Boot\n",
1440 le16_to_cpu(bmp->header.bit_count));
1444 #ifdef CONFIG_VIDEO_BMP_GZIP
1455 #ifdef CONFIG_VIDEO_LOGO
1456 void logo_plot(void *screen, int width, int x, int y)
1460 int skip = (width - VIDEO_LOGO_WIDTH) * VIDEO_PIXEL_SIZE;
1461 int ycount = video_logo_height;
1462 unsigned char r, g, b, *logo_red, *logo_blue, *logo_green;
1463 unsigned char *source;
1464 unsigned char *dest = (unsigned char *) screen +
1465 ((y * width * VIDEO_PIXEL_SIZE) + x * VIDEO_PIXEL_SIZE);
1467 #ifdef CONFIG_VIDEO_BMP_LOGO
1468 source = bmp_logo_bitmap;
1470 /* Allocate temporary space for computing colormap */
1471 logo_red = malloc(BMP_LOGO_COLORS);
1472 logo_green = malloc(BMP_LOGO_COLORS);
1473 logo_blue = malloc(BMP_LOGO_COLORS);
1474 /* Compute color map */
1475 for (i = 0; i < VIDEO_LOGO_COLORS; i++) {
1476 logo_red[i] = (bmp_logo_palette[i] & 0x0f00) >> 4;
1477 logo_green[i] = (bmp_logo_palette[i] & 0x00f0);
1478 logo_blue[i] = (bmp_logo_palette[i] & 0x000f) << 4;
1481 source = linux_logo;
1482 logo_red = linux_logo_red;
1483 logo_green = linux_logo_green;
1484 logo_blue = linux_logo_blue;
1487 if (VIDEO_DATA_FORMAT == GDF__8BIT_INDEX) {
1488 for (i = 0; i < VIDEO_LOGO_COLORS; i++) {
1489 video_set_lut(i + VIDEO_LOGO_LUT_OFFSET,
1490 logo_red[i], logo_green[i],
1496 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1499 xcount = VIDEO_LOGO_WIDTH;
1501 r = logo_red[*source - VIDEO_LOGO_LUT_OFFSET];
1502 g = logo_green[*source - VIDEO_LOGO_LUT_OFFSET];
1503 b = logo_blue[*source - VIDEO_LOGO_LUT_OFFSET];
1505 switch (VIDEO_DATA_FORMAT) {
1506 case GDF__8BIT_INDEX:
1509 case GDF__8BIT_332RGB:
1510 *dest = ((r >> 5) << 5) |
1514 case GDF_15BIT_555RGB:
1515 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1516 fill_555rgb_pswap(dest, xpos++, r, g, b);
1518 *(unsigned short *) dest =
1519 SWAP16((unsigned short) (
1525 case GDF_16BIT_565RGB:
1526 *(unsigned short *) dest =
1527 SWAP16((unsigned short) (
1532 case GDF_32BIT_X888RGB:
1533 *(unsigned long *) dest =
1534 SWAP32((unsigned long) (
1539 case GDF_24BIT_888RGB:
1540 #ifdef VIDEO_FB_LITTLE_ENDIAN
1552 dest += VIDEO_PIXEL_SIZE;
1556 #ifdef CONFIG_VIDEO_BMP_LOGO
1563 static void *video_logo(void)
1567 __maybe_unused int y_off = 0;
1569 #ifdef CONFIG_SPLASH_SCREEN
1573 s = getenv("splashimage");
1577 addr = simple_strtoul(s, NULL, 16);
1578 #ifdef CONFIG_SPLASH_SCREEN_ALIGN
1579 s = getenv("splashpos");
1582 x = BMP_ALIGN_CENTER;
1584 x = simple_strtol(s, NULL, 0);
1586 s = strchr(s + 1, ',');
1589 y = BMP_ALIGN_CENTER;
1591 y = simple_strtol(s + 1, NULL, 0);
1594 #endif /* CONFIG_SPLASH_SCREEN_ALIGN */
1596 if (video_display_bitmap(addr, x, y) == 0) {
1597 video_logo_height = 0;
1598 return ((void *) (video_fb_address));
1601 #endif /* CONFIG_SPLASH_SCREEN */
1603 logo_plot(video_fb_address, VIDEO_COLS, 0, 0);
1605 sprintf(info, " %s", version_string);
1607 space = (VIDEO_LINE_LEN / 2 - VIDEO_INFO_X) / VIDEO_FONT_WIDTH;
1611 video_drawchars(VIDEO_INFO_X, VIDEO_INFO_Y,
1612 (uchar *) info, space);
1613 video_drawchars(VIDEO_INFO_X + VIDEO_FONT_WIDTH,
1614 VIDEO_INFO_Y + VIDEO_FONT_HEIGHT,
1615 (uchar *) info + space, len - space);
1618 video_drawstring(VIDEO_INFO_X, VIDEO_INFO_Y, (uchar *) info);
1620 #ifdef CONFIG_CONSOLE_EXTRA_INFO
1623 ((video_logo_height -
1624 VIDEO_FONT_HEIGHT) / VIDEO_FONT_HEIGHT);
1626 for (i = 1; i < n; i++) {
1627 video_get_info_str(i, info);
1633 video_drawchars(VIDEO_INFO_X,
1637 (uchar *) info, space);
1639 video_drawchars(VIDEO_INFO_X +
1644 (uchar *) info + space,
1647 video_drawstring(VIDEO_INFO_X,
1657 return (video_fb_address + video_logo_height * VIDEO_LINE_LEN);
1661 static int video_init(void)
1663 unsigned char color8;
1665 pGD = video_hw_init();
1669 video_fb_address = (void *) VIDEO_FB_ADRS;
1670 #ifdef CONFIG_VIDEO_HW_CURSOR
1671 video_init_hw_cursor(VIDEO_FONT_WIDTH, VIDEO_FONT_HEIGHT);
1674 /* Init drawing pats */
1675 switch (VIDEO_DATA_FORMAT) {
1676 case GDF__8BIT_INDEX:
1677 video_set_lut(0x01, CONSOLE_FG_COL, CONSOLE_FG_COL,
1679 video_set_lut(0x00, CONSOLE_BG_COL, CONSOLE_BG_COL,
1684 case GDF__8BIT_332RGB:
1685 color8 = ((CONSOLE_FG_COL & 0xe0) |
1686 ((CONSOLE_FG_COL >> 3) & 0x1c) |
1687 CONSOLE_FG_COL >> 6);
1688 fgx = (color8 << 24) | (color8 << 16) | (color8 << 8) |
1690 color8 = ((CONSOLE_BG_COL & 0xe0) |
1691 ((CONSOLE_BG_COL >> 3) & 0x1c) |
1692 CONSOLE_BG_COL >> 6);
1693 bgx = (color8 << 24) | (color8 << 16) | (color8 << 8) |
1696 case GDF_15BIT_555RGB:
1697 fgx = (((CONSOLE_FG_COL >> 3) << 26) |
1698 ((CONSOLE_FG_COL >> 3) << 21) |
1699 ((CONSOLE_FG_COL >> 3) << 16) |
1700 ((CONSOLE_FG_COL >> 3) << 10) |
1701 ((CONSOLE_FG_COL >> 3) << 5) |
1702 (CONSOLE_FG_COL >> 3));
1703 bgx = (((CONSOLE_BG_COL >> 3) << 26) |
1704 ((CONSOLE_BG_COL >> 3) << 21) |
1705 ((CONSOLE_BG_COL >> 3) << 16) |
1706 ((CONSOLE_BG_COL >> 3) << 10) |
1707 ((CONSOLE_BG_COL >> 3) << 5) |
1708 (CONSOLE_BG_COL >> 3));
1710 case GDF_16BIT_565RGB:
1711 fgx = (((CONSOLE_FG_COL >> 3) << 27) |
1712 ((CONSOLE_FG_COL >> 2) << 21) |
1713 ((CONSOLE_FG_COL >> 3) << 16) |
1714 ((CONSOLE_FG_COL >> 3) << 11) |
1715 ((CONSOLE_FG_COL >> 2) << 5) |
1716 (CONSOLE_FG_COL >> 3));
1717 bgx = (((CONSOLE_BG_COL >> 3) << 27) |
1718 ((CONSOLE_BG_COL >> 2) << 21) |
1719 ((CONSOLE_BG_COL >> 3) << 16) |
1720 ((CONSOLE_BG_COL >> 3) << 11) |
1721 ((CONSOLE_BG_COL >> 2) << 5) |
1722 (CONSOLE_BG_COL >> 3));
1724 case GDF_32BIT_X888RGB:
1725 fgx = (CONSOLE_FG_COL << 16) |
1726 (CONSOLE_FG_COL << 8) |
1728 bgx = (CONSOLE_BG_COL << 16) |
1729 (CONSOLE_BG_COL << 8) |
1732 case GDF_24BIT_888RGB:
1733 fgx = (CONSOLE_FG_COL << 24) |
1734 (CONSOLE_FG_COL << 16) |
1735 (CONSOLE_FG_COL << 8) |
1737 bgx = (CONSOLE_BG_COL << 24) |
1738 (CONSOLE_BG_COL << 16) |
1739 (CONSOLE_BG_COL << 8) |
1745 #ifdef CONFIG_VIDEO_LOGO
1746 /* Plot the logo and get start point of console */
1747 debug("Video: Drawing the logo ...\n");
1748 video_console_address = video_logo();
1750 video_console_address = video_fb_address;
1753 /* Initialize the console */
1761 * Implement a weak default function for boards that optionally
1762 * need to skip the video initialization.
1764 int __board_video_skip(void)
1766 /* As default, don't skip test */
1770 int board_video_skip(void)
1771 __attribute__ ((weak, alias("__board_video_skip")));
1773 int drv_video_init(void)
1776 struct stdio_dev console_dev;
1778 /* Check if video initialization should be skipped */
1779 if (board_video_skip())
1782 /* Init video chip - returns with framebuffer cleared */
1783 skip_dev_init = (video_init() == -1);
1785 #if !defined(CONFIG_VGA_AS_SINGLE_DEVICE)
1786 debug("KBD: Keyboard init ...\n");
1787 skip_dev_init |= (VIDEO_KBD_INIT_FCT == -1);
1793 /* Init vga device */
1794 memset(&console_dev, 0, sizeof(console_dev));
1795 strcpy(console_dev.name, "vga");
1796 console_dev.ext = DEV_EXT_VIDEO; /* Video extensions */
1797 console_dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_SYSTEM;
1798 console_dev.putc = video_putc; /* 'putc' function */
1799 console_dev.puts = video_puts; /* 'puts' function */
1800 console_dev.tstc = NULL; /* 'tstc' function */
1801 console_dev.getc = NULL; /* 'getc' function */
1803 #if !defined(CONFIG_VGA_AS_SINGLE_DEVICE)
1804 /* Also init console device */
1805 console_dev.flags |= DEV_FLAGS_INPUT;
1806 console_dev.tstc = VIDEO_TSTC_FCT; /* 'tstc' function */
1807 console_dev.getc = VIDEO_GETC_FCT; /* 'getc' function */
1808 #endif /* CONFIG_VGA_AS_SINGLE_DEVICE */
1810 if (stdio_register(&console_dev) != 0)
1813 /* Return success */