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 #ifdef CONFIG_VIDEO_MX3
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>
207 #if defined(CONFIG_CMD_DATE)
211 #if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN)
212 #include <watchdog.h>
213 #include <bmp_layout.h>
215 #ifdef CONFIG_SPLASH_SCREEN_ALIGN
216 #define BMP_ALIGN_CENTER 0x7FFF
223 * CONFIG_CONSOLE_CURSOR: Uses a timer function (see drivers/input/i8042.c)
224 * to let the cursor blink. Uses the macros
225 * CURSOR_OFF and CURSOR_ON.
226 * CONFIG_VIDEO_SW_CURSOR: Draws a cursor after the last character. No
227 * blinking is provided. Uses the macros CURSOR_SET
229 * CONFIG_VIDEO_HW_CURSOR: Uses the hardware cursor capability of the
230 * graphic chip. Uses the macro CURSOR_SET.
231 * ATTENTION: If booting an OS, the display driver
232 * must disable the hardware register of the graphic
233 * chip. Otherwise a blinking field is displayed
235 #if !defined(CONFIG_CONSOLE_CURSOR) && \
236 !defined(CONFIG_VIDEO_SW_CURSOR) && \
237 !defined(CONFIG_VIDEO_HW_CURSOR)
238 /* no Cursor defined */
244 #ifdef CONFIG_CONSOLE_CURSOR
246 #error only one of CONFIG_CONSOLE_CURSOR, CONFIG_VIDEO_SW_CURSOR, \
247 or CONFIG_VIDEO_HW_CURSOR can be defined
249 void console_cursor(int state);
251 #define CURSOR_ON console_cursor(1)
252 #define CURSOR_OFF console_cursor(0)
254 #ifndef CONFIG_I8042_KBD
255 #warning Cursor drawing on/off needs timer function s.a. drivers/input/i8042.c
258 #ifdef CONFIG_CONSOLE_TIME
259 #error CONFIG_CONSOLE_CURSOR must be defined for CONFIG_CONSOLE_TIME
261 #endif /* CONFIG_CONSOLE_CURSOR */
263 #ifdef CONFIG_VIDEO_SW_CURSOR
265 #error only one of CONFIG_CONSOLE_CURSOR, CONFIG_VIDEO_SW_CURSOR, \
266 or CONFIG_VIDEO_HW_CURSOR can be defined
269 #define CURSOR_OFF video_putchar(console_col * VIDEO_FONT_WIDTH,\
270 console_row * VIDEO_FONT_HEIGHT, ' ')
271 #define CURSOR_SET video_set_cursor()
272 #endif /* CONFIG_VIDEO_SW_CURSOR */
275 #ifdef CONFIG_VIDEO_HW_CURSOR
277 #error only one of CONFIG_CONSOLE_CURSOR, CONFIG_VIDEO_SW_CURSOR, \
278 or CONFIG_VIDEO_HW_CURSOR can be defined
282 #define CURSOR_SET video_set_hw_cursor(console_col * VIDEO_FONT_WIDTH, \
283 (console_row * VIDEO_FONT_HEIGHT) + video_logo_height)
284 #endif /* CONFIG_VIDEO_HW_CURSOR */
286 #ifdef CONFIG_VIDEO_LOGO
287 #ifdef CONFIG_VIDEO_BMP_LOGO
288 #include <bmp_logo.h>
289 #define VIDEO_LOGO_WIDTH BMP_LOGO_WIDTH
290 #define VIDEO_LOGO_HEIGHT BMP_LOGO_HEIGHT
291 #define VIDEO_LOGO_LUT_OFFSET BMP_LOGO_OFFSET
292 #define VIDEO_LOGO_COLORS BMP_LOGO_COLORS
294 #else /* CONFIG_VIDEO_BMP_LOGO */
295 #define LINUX_LOGO_WIDTH 80
296 #define LINUX_LOGO_HEIGHT 80
297 #define LINUX_LOGO_COLORS 214
298 #define LINUX_LOGO_LUT_OFFSET 0x20
300 #include <linux_logo.h>
301 #define VIDEO_LOGO_WIDTH LINUX_LOGO_WIDTH
302 #define VIDEO_LOGO_HEIGHT LINUX_LOGO_HEIGHT
303 #define VIDEO_LOGO_LUT_OFFSET LINUX_LOGO_LUT_OFFSET
304 #define VIDEO_LOGO_COLORS LINUX_LOGO_COLORS
305 #endif /* CONFIG_VIDEO_BMP_LOGO */
306 #define VIDEO_INFO_X (VIDEO_LOGO_WIDTH)
307 #define VIDEO_INFO_Y (VIDEO_FONT_HEIGHT/2)
308 #else /* CONFIG_VIDEO_LOGO */
309 #define VIDEO_LOGO_WIDTH 0
310 #define VIDEO_LOGO_HEIGHT 0
311 #endif /* CONFIG_VIDEO_LOGO */
313 #define VIDEO_COLS VIDEO_VISIBLE_COLS
314 #define VIDEO_ROWS VIDEO_VISIBLE_ROWS
315 #define VIDEO_SIZE (VIDEO_ROWS*VIDEO_COLS*VIDEO_PIXEL_SIZE)
316 #define VIDEO_PIX_BLOCKS (VIDEO_SIZE >> 2)
317 #define VIDEO_LINE_LEN (VIDEO_COLS*VIDEO_PIXEL_SIZE)
318 #define VIDEO_BURST_LEN (VIDEO_COLS/8)
320 #ifdef CONFIG_VIDEO_LOGO
321 #define CONSOLE_ROWS ((VIDEO_ROWS - video_logo_height) / VIDEO_FONT_HEIGHT)
323 #define CONSOLE_ROWS (VIDEO_ROWS / VIDEO_FONT_HEIGHT)
326 #define CONSOLE_COLS (VIDEO_COLS / VIDEO_FONT_WIDTH)
327 #define CONSOLE_ROW_SIZE (VIDEO_FONT_HEIGHT * VIDEO_LINE_LEN)
328 #define CONSOLE_ROW_FIRST (video_console_address)
329 #define CONSOLE_ROW_SECOND (video_console_address + CONSOLE_ROW_SIZE)
330 #define CONSOLE_ROW_LAST (video_console_address + CONSOLE_SIZE - CONSOLE_ROW_SIZE)
331 #define CONSOLE_SIZE (CONSOLE_ROW_SIZE * CONSOLE_ROWS)
332 #define CONSOLE_SCROLL_SIZE (CONSOLE_SIZE - CONSOLE_ROW_SIZE)
335 #ifdef VIDEO_FB_LITTLE_ENDIAN
336 #define SWAP16(x) ((((x) & 0x00ff) << 8) | \
339 #define SWAP32(x) ((((x) & 0x000000ff) << 24) | \
340 (((x) & 0x0000ff00) << 8) | \
341 (((x) & 0x00ff0000) >> 8) | \
342 (((x) & 0xff000000) >> 24) \
344 #define SHORTSWAP32(x) ((((x) & 0x000000ff) << 8) | \
345 (((x) & 0x0000ff00) >> 8) | \
346 (((x) & 0x00ff0000) << 8) | \
347 (((x) & 0xff000000) >> 8) \
350 #define SWAP16(x) (x)
351 #define SWAP32(x) (x)
352 #if defined(VIDEO_FB_16BPP_WORD_SWAP)
353 #define SHORTSWAP32(x) (((x) >> 16) | ((x) << 16))
355 #define SHORTSWAP32(x) (x)
359 #ifdef CONFIG_CONSOLE_EXTRA_INFO
361 * setup a board string: type, speed, etc.
363 * line_number: location to place info string beside logo
364 * info: buffer for info string
366 extern void video_get_info_str(int line_number, char *info);
370 static GraphicDevice *pGD; /* Pointer to Graphic array */
372 static void *video_fb_address; /* frame buffer address */
373 static void *video_console_address; /* console buffer start address */
375 static int video_logo_height = VIDEO_LOGO_HEIGHT;
377 static int console_col; /* cursor col */
378 static int console_row; /* cursor row */
380 static u32 eorx, fgx, bgx; /* color pats */
382 static const int video_font_draw_table8[] = {
383 0x00000000, 0x000000ff, 0x0000ff00, 0x0000ffff,
384 0x00ff0000, 0x00ff00ff, 0x00ffff00, 0x00ffffff,
385 0xff000000, 0xff0000ff, 0xff00ff00, 0xff00ffff,
386 0xffff0000, 0xffff00ff, 0xffffff00, 0xffffffff
389 static const int video_font_draw_table15[] = {
390 0x00000000, 0x00007fff, 0x7fff0000, 0x7fff7fff
393 static const int video_font_draw_table16[] = {
394 0x00000000, 0x0000ffff, 0xffff0000, 0xffffffff
397 static const int video_font_draw_table24[16][3] = {
398 {0x00000000, 0x00000000, 0x00000000},
399 {0x00000000, 0x00000000, 0x00ffffff},
400 {0x00000000, 0x0000ffff, 0xff000000},
401 {0x00000000, 0x0000ffff, 0xffffffff},
402 {0x000000ff, 0xffff0000, 0x00000000},
403 {0x000000ff, 0xffff0000, 0x00ffffff},
404 {0x000000ff, 0xffffffff, 0xff000000},
405 {0x000000ff, 0xffffffff, 0xffffffff},
406 {0xffffff00, 0x00000000, 0x00000000},
407 {0xffffff00, 0x00000000, 0x00ffffff},
408 {0xffffff00, 0x0000ffff, 0xff000000},
409 {0xffffff00, 0x0000ffff, 0xffffffff},
410 {0xffffffff, 0xffff0000, 0x00000000},
411 {0xffffffff, 0xffff0000, 0x00ffffff},
412 {0xffffffff, 0xffffffff, 0xff000000},
413 {0xffffffff, 0xffffffff, 0xffffffff}
416 static const int video_font_draw_table32[16][4] = {
417 {0x00000000, 0x00000000, 0x00000000, 0x00000000},
418 {0x00000000, 0x00000000, 0x00000000, 0x00ffffff},
419 {0x00000000, 0x00000000, 0x00ffffff, 0x00000000},
420 {0x00000000, 0x00000000, 0x00ffffff, 0x00ffffff},
421 {0x00000000, 0x00ffffff, 0x00000000, 0x00000000},
422 {0x00000000, 0x00ffffff, 0x00000000, 0x00ffffff},
423 {0x00000000, 0x00ffffff, 0x00ffffff, 0x00000000},
424 {0x00000000, 0x00ffffff, 0x00ffffff, 0x00ffffff},
425 {0x00ffffff, 0x00000000, 0x00000000, 0x00000000},
426 {0x00ffffff, 0x00000000, 0x00000000, 0x00ffffff},
427 {0x00ffffff, 0x00000000, 0x00ffffff, 0x00000000},
428 {0x00ffffff, 0x00000000, 0x00ffffff, 0x00ffffff},
429 {0x00ffffff, 0x00ffffff, 0x00000000, 0x00000000},
430 {0x00ffffff, 0x00ffffff, 0x00000000, 0x00ffffff},
431 {0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00000000},
432 {0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00ffffff}
436 static void video_drawchars(int xx, int yy, unsigned char *s, int count)
438 u8 *cdat, *dest, *dest0;
441 offset = yy * VIDEO_LINE_LEN + xx * VIDEO_PIXEL_SIZE;
442 dest0 = video_fb_address + offset;
444 switch (VIDEO_DATA_FORMAT) {
445 case GDF__8BIT_INDEX:
446 case GDF__8BIT_332RGB:
449 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
450 for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
451 rows--; dest += VIDEO_LINE_LEN) {
455 (video_font_draw_table8[bits >> 4] &
458 (video_font_draw_table8[bits & 15] &
461 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
466 case GDF_15BIT_555RGB:
469 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
470 for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
471 rows--; dest += VIDEO_LINE_LEN) {
475 SHORTSWAP32((video_font_draw_table15
476 [bits >> 6] & eorx) ^
479 SHORTSWAP32((video_font_draw_table15
480 [bits >> 4 & 3] & eorx) ^
483 SHORTSWAP32((video_font_draw_table15
484 [bits >> 2 & 3] & eorx) ^
487 SHORTSWAP32((video_font_draw_table15
491 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
496 case GDF_16BIT_565RGB:
499 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
500 for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
501 rows--; dest += VIDEO_LINE_LEN) {
505 SHORTSWAP32((video_font_draw_table16
506 [bits >> 6] & eorx) ^
509 SHORTSWAP32((video_font_draw_table16
510 [bits >> 4 & 3] & eorx) ^
513 SHORTSWAP32((video_font_draw_table16
514 [bits >> 2 & 3] & eorx) ^
517 SHORTSWAP32((video_font_draw_table16
521 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
526 case GDF_32BIT_X888RGB:
529 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
530 for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
531 rows--; dest += VIDEO_LINE_LEN) {
535 SWAP32((video_font_draw_table32
536 [bits >> 4][0] & eorx) ^ bgx);
538 SWAP32((video_font_draw_table32
539 [bits >> 4][1] & eorx) ^ bgx);
541 SWAP32((video_font_draw_table32
542 [bits >> 4][2] & eorx) ^ bgx);
544 SWAP32((video_font_draw_table32
545 [bits >> 4][3] & eorx) ^ bgx);
547 SWAP32((video_font_draw_table32
548 [bits & 15][0] & eorx) ^ bgx);
550 SWAP32((video_font_draw_table32
551 [bits & 15][1] & eorx) ^ bgx);
553 SWAP32((video_font_draw_table32
554 [bits & 15][2] & eorx) ^ bgx);
556 SWAP32((video_font_draw_table32
557 [bits & 15][3] & eorx) ^ bgx);
559 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
564 case GDF_24BIT_888RGB:
567 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
568 for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
569 rows--; dest += VIDEO_LINE_LEN) {
573 (video_font_draw_table24[bits >> 4][0]
576 (video_font_draw_table24[bits >> 4][1]
579 (video_font_draw_table24[bits >> 4][2]
582 (video_font_draw_table24[bits & 15][0]
585 (video_font_draw_table24[bits & 15][1]
588 (video_font_draw_table24[bits & 15][2]
591 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
598 static inline void video_drawstring(int xx, int yy, unsigned char *s)
600 video_drawchars(xx, yy, s, strlen((char *) s));
603 static void video_putchar(int xx, int yy, unsigned char c)
605 video_drawchars(xx, yy + video_logo_height, &c, 1);
608 #if defined(CONFIG_CONSOLE_CURSOR) || defined(CONFIG_VIDEO_SW_CURSOR)
609 static void video_set_cursor(void)
611 /* swap drawing colors */
617 video_putchar(console_col * VIDEO_FONT_WIDTH,
618 console_row * VIDEO_FONT_HEIGHT, ' ');
619 /* restore drawing colors */
627 #ifdef CONFIG_CONSOLE_CURSOR
628 void console_cursor(int state)
630 static int last_state = 0;
632 #ifdef CONFIG_CONSOLE_TIME
636 /* time update only if cursor is on (faster scroll) */
640 sprintf(info, " %02d:%02d:%02d ", tm.tm_hour, tm.tm_min,
642 video_drawstring(VIDEO_VISIBLE_COLS - 10 * VIDEO_FONT_WIDTH,
643 VIDEO_INFO_Y, (uchar *) info);
645 sprintf(info, "%02d.%02d.%04d", tm.tm_mday, tm.tm_mon,
647 video_drawstring(VIDEO_VISIBLE_COLS - 10 * VIDEO_FONT_WIDTH,
648 VIDEO_INFO_Y + 1 * VIDEO_FONT_HEIGHT,
653 if (state && (last_state != state)) {
657 if (!state && (last_state != state)) {
659 video_putchar(console_col * VIDEO_FONT_WIDTH,
660 console_row * VIDEO_FONT_HEIGHT, ' ');
667 #ifndef VIDEO_HW_RECTFILL
668 static void memsetl(int *p, int c, int v)
675 #ifndef VIDEO_HW_BITBLT
676 static void memcpyl(int *d, int *s, int c)
683 static void console_scrollup(void)
685 /* copy up rows ignoring the first one */
687 #ifdef VIDEO_HW_BITBLT
688 video_hw_bitblt(VIDEO_PIXEL_SIZE, /* bytes per pixel */
689 0, /* source pos x */
691 VIDEO_FONT_HEIGHT, /* source pos y */
693 video_logo_height, /* dest pos y */
694 VIDEO_VISIBLE_COLS, /* frame width */
697 - VIDEO_FONT_HEIGHT /* frame height */
700 memcpyl(CONSOLE_ROW_FIRST, CONSOLE_ROW_SECOND,
701 CONSOLE_SCROLL_SIZE >> 2);
704 /* clear the last one */
705 #ifdef VIDEO_HW_RECTFILL
706 video_hw_rectfill(VIDEO_PIXEL_SIZE, /* bytes per pixel */
709 - VIDEO_FONT_HEIGHT, /* dest pos y */
710 VIDEO_VISIBLE_COLS, /* frame width */
711 VIDEO_FONT_HEIGHT, /* frame height */
712 CONSOLE_BG_COL /* fill color */
715 memsetl(CONSOLE_ROW_LAST, CONSOLE_ROW_SIZE >> 2, CONSOLE_BG_COL);
719 static void console_back(void)
724 if (console_col < 0) {
725 console_col = CONSOLE_COLS - 1;
730 video_putchar(console_col * VIDEO_FONT_WIDTH,
731 console_row * VIDEO_FONT_HEIGHT, ' ');
734 static void console_newline(void)
736 /* Check if last character in the line was just drawn. If so, cursor was
737 overwriten and need not to be cleared. Cursor clearing without this
738 check causes overwriting the 1st character of the line if line lenght
741 if (console_col < CONSOLE_COLS)
746 /* Check if we need to scroll the terminal */
747 if (console_row >= CONSOLE_ROWS) {
748 /* Scroll everything up */
751 /* Decrement row number */
756 static void console_cr(void)
762 void video_putc(const char c)
767 case 13: /* back to first column */
771 case '\n': /* next line */
772 if (console_col || (!console_col && nl))
779 console_col |= 0x0008;
780 console_col &= ~0x0007;
782 if (console_col >= CONSOLE_COLS)
786 case 8: /* backspace */
790 default: /* draw the char */
791 video_putchar(console_col * VIDEO_FONT_WIDTH,
792 console_row * VIDEO_FONT_HEIGHT, c);
795 /* check for newline */
796 if (console_col >= CONSOLE_COLS) {
804 void video_puts(const char *s)
806 int count = strlen(s);
813 * Do not enforce drivers (or board code) to provide empty
814 * video_set_lut() if they do not support 8 bpp format.
815 * Implement weak default function instead.
817 void __video_set_lut(unsigned int index, unsigned char r,
818 unsigned char g, unsigned char b)
822 void video_set_lut(unsigned int, unsigned char, unsigned char, unsigned char)
823 __attribute__ ((weak, alias("__video_set_lut")));
825 #if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN)
827 #define FILL_8BIT_332RGB(r,g,b) { \
828 *fb = ((r>>5)<<5) | ((g>>5)<<2) | (b>>6); \
832 #define FILL_15BIT_555RGB(r,g,b) { \
833 *(unsigned short *)fb = \
834 SWAP16((unsigned short)(((r>>3)<<10) | \
840 #define FILL_16BIT_565RGB(r,g,b) { \
841 *(unsigned short *)fb = \
842 SWAP16((unsigned short)((((r)>>3)<<11)| \
848 #define FILL_32BIT_X888RGB(r,g,b) { \
849 *(unsigned long *)fb = \
850 SWAP32((unsigned long)(((r<<16) | \
856 #ifdef VIDEO_FB_LITTLE_ENDIAN
857 #define FILL_24BIT_888RGB(r,g,b) { \
864 #define FILL_24BIT_888RGB(r,g,b) { \
872 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
873 static inline void fill_555rgb_pswap(uchar *fb, int x, u8 r, u8 g, u8 b)
875 ushort *dst = (ushort *) fb;
876 ushort color = (ushort) (((r >> 3) << 10) |
887 * RLE8 bitmap support
890 #ifdef CONFIG_VIDEO_BMP_RLE8
891 /* Pre-calculated color table entry */
894 unsigned short w; /* word */
895 unsigned int dw; /* double word */
896 } ce; /* color entry */
900 * Helper to draw encoded/unencoded run.
902 static void draw_bitmap(uchar **fb, uchar *bm, struct palette *p,
905 ulong addr = (ulong) *fb;
911 * Setup offset of the color index in the bitmap.
912 * Color index of encoded run is at offset 1.
914 off = enc ? &enc_off : &i;
916 switch (VIDEO_DATA_FORMAT) {
917 case GDF__8BIT_INDEX:
918 for (i = 0; i < cnt; i++)
919 *(unsigned char *) addr++ = bm[*off];
921 case GDF_15BIT_555RGB:
922 case GDF_16BIT_565RGB:
923 /* differences handled while pre-calculating palette */
924 for (i = 0; i < cnt; i++) {
925 *(unsigned short *) addr = p[bm[*off]].ce.w;
929 case GDF_32BIT_X888RGB:
930 for (i = 0; i < cnt; i++) {
931 *(unsigned long *) addr = p[bm[*off]].ce.dw;
936 *fb = (uchar *) addr; /* return modified address */
939 static int display_rle8_bitmap(bmp_image_t *img, int xoff, int yoff,
940 int width, int height)
944 unsigned int cnt, runlen;
946 int x, y, bpp, i, ncolors;
947 struct palette p[256];
948 bmp_color_table_entry_t cte;
949 int green_shift, red_off;
950 int limit = VIDEO_COLS * VIDEO_ROWS;
954 y = __le32_to_cpu(img->header.height) - 1;
955 ncolors = __le32_to_cpu(img->header.colors_used);
956 bpp = VIDEO_PIXEL_SIZE;
957 fbp = (unsigned char *) ((unsigned int) video_fb_address +
958 (((y + yoff) * VIDEO_COLS) + xoff) * bpp);
960 bm = (uchar *) img + __le32_to_cpu(img->header.data_offset);
962 /* pre-calculate and setup palette */
963 switch (VIDEO_DATA_FORMAT) {
964 case GDF__8BIT_INDEX:
965 for (i = 0; i < ncolors; i++) {
966 cte = img->color_table[i];
967 video_set_lut(i, cte.red, cte.green, cte.blue);
970 case GDF_15BIT_555RGB:
971 case GDF_16BIT_565RGB:
972 if (VIDEO_DATA_FORMAT == GDF_15BIT_555RGB) {
979 for (i = 0; i < ncolors; i++) {
980 cte = img->color_table[i];
981 p[i].ce.w = SWAP16((unsigned short)
982 (((cte.red >> 3) << red_off) |
983 ((cte.green >> green_shift) << 5) |
987 case GDF_32BIT_X888RGB:
988 for (i = 0; i < ncolors; i++) {
989 cte = img->color_table[i];
990 p[i].ce.dw = SWAP32((cte.red << 16) |
996 printf("RLE Bitmap unsupported in video mode 0x%x\n",
1006 /* scan line end marker */
1010 fbp = (unsigned char *)
1011 ((unsigned int) video_fb_address +
1012 (((y + yoff) * VIDEO_COLS) +
1016 /* end of bitmap data marker */
1020 /* run offset marker */
1023 fbp = (unsigned char *)
1024 ((unsigned int) video_fb_address +
1025 (((y + yoff) * VIDEO_COLS) +
1043 if (x + runlen > width)
1045 draw_bitmap(&fbp, bm, p, cnt, 0);
1051 bm++; /* 0 padding if length is odd */
1062 if (y < height) { /* only draw into visible area */
1068 if (x + runlen > width)
1070 draw_bitmap(&fbp, bm, p, cnt, 1);
1079 printf("Error: Too much encoded pixel data, validate your bitmap\n");
1085 * Display the BMP file located at address bmp_image.
1087 int video_display_bitmap(ulong bmp_image, int x, int y)
1089 ushort xcount, ycount;
1091 bmp_image_t *bmp = (bmp_image_t *) bmp_image;
1094 unsigned long width, height, bpp;
1096 unsigned long compression;
1097 bmp_color_table_entry_t cte;
1099 #ifdef CONFIG_VIDEO_BMP_GZIP
1100 unsigned char *dst = NULL;
1106 if (!((bmp->header.signature[0] == 'B') &&
1107 (bmp->header.signature[1] == 'M'))) {
1109 #ifdef CONFIG_VIDEO_BMP_GZIP
1111 * Could be a gzipped bmp image, try to decrompress...
1113 len = CONFIG_SYS_VIDEO_LOGO_MAX_SIZE;
1114 dst = malloc(CONFIG_SYS_VIDEO_LOGO_MAX_SIZE);
1116 printf("Error: malloc in gunzip failed!\n");
1119 if (gunzip(dst, CONFIG_SYS_VIDEO_LOGO_MAX_SIZE,
1120 (uchar *) bmp_image,
1122 printf("Error: no valid bmp or bmp.gz image at %lx\n",
1127 if (len == CONFIG_SYS_VIDEO_LOGO_MAX_SIZE) {
1128 printf("Image could be truncated "
1129 "(increase CONFIG_SYS_VIDEO_LOGO_MAX_SIZE)!\n");
1133 * Set addr to decompressed image
1135 bmp = (bmp_image_t *) dst;
1137 if (!((bmp->header.signature[0] == 'B') &&
1138 (bmp->header.signature[1] == 'M'))) {
1139 printf("Error: no valid bmp.gz image at %lx\n",
1145 printf("Error: no valid bmp image at %lx\n", bmp_image);
1147 #endif /* CONFIG_VIDEO_BMP_GZIP */
1150 width = le32_to_cpu(bmp->header.width);
1151 height = le32_to_cpu(bmp->header.height);
1152 bpp = le16_to_cpu(bmp->header.bit_count);
1153 colors = le32_to_cpu(bmp->header.colors_used);
1154 compression = le32_to_cpu(bmp->header.compression);
1156 debug("Display-bmp: %ld x %ld with %d colors\n",
1157 width, height, colors);
1159 if (compression != BMP_BI_RGB
1160 #ifdef CONFIG_VIDEO_BMP_RLE8
1161 && compression != BMP_BI_RLE8
1164 printf("Error: compression type %ld not supported\n",
1166 #ifdef CONFIG_VIDEO_BMP_GZIP
1173 padded_line = (((width * bpp + 7) / 8) + 3) & ~0x3;
1175 #ifdef CONFIG_SPLASH_SCREEN_ALIGN
1176 if (x == BMP_ALIGN_CENTER)
1177 x = max(0, (VIDEO_VISIBLE_COLS - width) / 2);
1179 x = max(0, VIDEO_VISIBLE_COLS - width + x + 1);
1181 if (y == BMP_ALIGN_CENTER)
1182 y = max(0, (VIDEO_VISIBLE_ROWS - height) / 2);
1184 y = max(0, VIDEO_VISIBLE_ROWS - height + y + 1);
1185 #endif /* CONFIG_SPLASH_SCREEN_ALIGN */
1187 if ((x + width) > VIDEO_VISIBLE_COLS)
1188 width = VIDEO_VISIBLE_COLS - x;
1189 if ((y + height) > VIDEO_VISIBLE_ROWS)
1190 height = VIDEO_VISIBLE_ROWS - y;
1192 bmap = (uchar *) bmp + le32_to_cpu(bmp->header.data_offset);
1193 fb = (uchar *) (video_fb_address +
1194 ((y + height - 1) * VIDEO_COLS * VIDEO_PIXEL_SIZE) +
1195 x * VIDEO_PIXEL_SIZE);
1197 #ifdef CONFIG_VIDEO_BMP_RLE8
1198 if (compression == BMP_BI_RLE8) {
1199 return display_rle8_bitmap(bmp, x, y, width, height);
1203 /* We handle only 4, 8, or 24 bpp bitmaps */
1204 switch (le16_to_cpu(bmp->header.bit_count)) {
1206 padded_line -= width / 2;
1209 switch (VIDEO_DATA_FORMAT) {
1210 case GDF_32BIT_X888RGB:
1214 * Don't assume that 'width' is an
1217 for (xcount = 0; xcount < width; xcount++) {
1225 cte = bmp->color_table[idx];
1226 FILL_32BIT_X888RGB(cte.red, cte.green,
1229 bmap += padded_line;
1230 fb -= (VIDEO_VISIBLE_COLS + width) *
1235 puts("4bpp bitmap unsupported with current "
1242 padded_line -= width;
1243 if (VIDEO_DATA_FORMAT == GDF__8BIT_INDEX) {
1245 for (xcount = 0; xcount < colors; ++xcount) {
1246 cte = bmp->color_table[xcount];
1247 video_set_lut(xcount, cte.red, cte.green,
1252 switch (VIDEO_DATA_FORMAT) {
1253 case GDF__8BIT_INDEX:
1260 bmap += padded_line;
1261 fb -= (VIDEO_VISIBLE_COLS + width) *
1265 case GDF__8BIT_332RGB:
1270 cte = bmp->color_table[*bmap++];
1271 FILL_8BIT_332RGB(cte.red, cte.green,
1274 bmap += padded_line;
1275 fb -= (VIDEO_VISIBLE_COLS + width) *
1279 case GDF_15BIT_555RGB:
1281 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1287 cte = bmp->color_table[*bmap++];
1288 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1289 fill_555rgb_pswap(fb, xpos++, cte.red,
1294 FILL_15BIT_555RGB(cte.red, cte.green,
1298 bmap += padded_line;
1299 fb -= (VIDEO_VISIBLE_COLS + width) *
1303 case GDF_16BIT_565RGB:
1308 cte = bmp->color_table[*bmap++];
1309 FILL_16BIT_565RGB(cte.red, cte.green,
1312 bmap += padded_line;
1313 fb -= (VIDEO_VISIBLE_COLS + width) *
1317 case GDF_32BIT_X888RGB:
1322 cte = bmp->color_table[*bmap++];
1323 FILL_32BIT_X888RGB(cte.red, cte.green,
1326 bmap += padded_line;
1327 fb -= (VIDEO_VISIBLE_COLS + width) *
1331 case GDF_24BIT_888RGB:
1336 cte = bmp->color_table[*bmap++];
1337 FILL_24BIT_888RGB(cte.red, cte.green,
1340 bmap += padded_line;
1341 fb -= (VIDEO_VISIBLE_COLS + width) *
1348 padded_line -= 3 * width;
1350 switch (VIDEO_DATA_FORMAT) {
1351 case GDF__8BIT_332RGB:
1356 FILL_8BIT_332RGB(bmap[2], bmap[1],
1360 bmap += padded_line;
1361 fb -= (VIDEO_VISIBLE_COLS + width) *
1365 case GDF_15BIT_555RGB:
1367 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1373 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1374 fill_555rgb_pswap(fb, xpos++, bmap[2],
1378 FILL_15BIT_555RGB(bmap[2], bmap[1],
1383 bmap += padded_line;
1384 fb -= (VIDEO_VISIBLE_COLS + width) *
1388 case GDF_16BIT_565RGB:
1393 FILL_16BIT_565RGB(bmap[2], bmap[1],
1397 bmap += padded_line;
1398 fb -= (VIDEO_VISIBLE_COLS + width) *
1402 case GDF_32BIT_X888RGB:
1407 FILL_32BIT_X888RGB(bmap[2], bmap[1],
1411 bmap += padded_line;
1412 fb -= (VIDEO_VISIBLE_COLS + width) *
1416 case GDF_24BIT_888RGB:
1421 FILL_24BIT_888RGB(bmap[2], bmap[1],
1425 bmap += padded_line;
1426 fb -= (VIDEO_VISIBLE_COLS + width) *
1431 printf("Error: 24 bits/pixel bitmap incompatible "
1432 "with current video mode\n");
1437 printf("Error: %d bit/pixel bitmaps not supported by U-Boot\n",
1438 le16_to_cpu(bmp->header.bit_count));
1442 #ifdef CONFIG_VIDEO_BMP_GZIP
1453 #ifdef CONFIG_VIDEO_LOGO
1454 void logo_plot(void *screen, int width, int x, int y)
1458 int skip = (width - VIDEO_LOGO_WIDTH) * VIDEO_PIXEL_SIZE;
1459 int ycount = video_logo_height;
1460 unsigned char r, g, b, *logo_red, *logo_blue, *logo_green;
1461 unsigned char *source;
1462 unsigned char *dest = (unsigned char *) screen +
1463 ((y * width * VIDEO_PIXEL_SIZE) + x * VIDEO_PIXEL_SIZE);
1465 #ifdef CONFIG_VIDEO_BMP_LOGO
1466 source = bmp_logo_bitmap;
1468 /* Allocate temporary space for computing colormap */
1469 logo_red = malloc(BMP_LOGO_COLORS);
1470 logo_green = malloc(BMP_LOGO_COLORS);
1471 logo_blue = malloc(BMP_LOGO_COLORS);
1472 /* Compute color map */
1473 for (i = 0; i < VIDEO_LOGO_COLORS; i++) {
1474 logo_red[i] = (bmp_logo_palette[i] & 0x0f00) >> 4;
1475 logo_green[i] = (bmp_logo_palette[i] & 0x00f0);
1476 logo_blue[i] = (bmp_logo_palette[i] & 0x000f) << 4;
1479 source = linux_logo;
1480 logo_red = linux_logo_red;
1481 logo_green = linux_logo_green;
1482 logo_blue = linux_logo_blue;
1485 if (VIDEO_DATA_FORMAT == GDF__8BIT_INDEX) {
1486 for (i = 0; i < VIDEO_LOGO_COLORS; i++) {
1487 video_set_lut(i + VIDEO_LOGO_LUT_OFFSET,
1488 logo_red[i], logo_green[i],
1494 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1497 xcount = VIDEO_LOGO_WIDTH;
1499 r = logo_red[*source - VIDEO_LOGO_LUT_OFFSET];
1500 g = logo_green[*source - VIDEO_LOGO_LUT_OFFSET];
1501 b = logo_blue[*source - VIDEO_LOGO_LUT_OFFSET];
1503 switch (VIDEO_DATA_FORMAT) {
1504 case GDF__8BIT_INDEX:
1507 case GDF__8BIT_332RGB:
1508 *dest = ((r >> 5) << 5) |
1512 case GDF_15BIT_555RGB:
1513 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1514 fill_555rgb_pswap(dest, xpos++, r, g, b);
1516 *(unsigned short *) dest =
1517 SWAP16((unsigned short) (
1523 case GDF_16BIT_565RGB:
1524 *(unsigned short *) dest =
1525 SWAP16((unsigned short) (
1530 case GDF_32BIT_X888RGB:
1531 *(unsigned long *) dest =
1532 SWAP32((unsigned long) (
1537 case GDF_24BIT_888RGB:
1538 #ifdef VIDEO_FB_LITTLE_ENDIAN
1550 dest += VIDEO_PIXEL_SIZE;
1554 #ifdef CONFIG_VIDEO_BMP_LOGO
1561 static void *video_logo(void)
1565 __maybe_unused int y_off = 0;
1567 #ifdef CONFIG_SPLASH_SCREEN
1571 s = getenv("splashimage");
1575 addr = simple_strtoul(s, NULL, 16);
1576 #ifdef CONFIG_SPLASH_SCREEN_ALIGN
1577 s = getenv("splashpos");
1580 x = BMP_ALIGN_CENTER;
1582 x = simple_strtol(s, NULL, 0);
1584 s = strchr(s + 1, ',');
1587 y = BMP_ALIGN_CENTER;
1589 y = simple_strtol(s + 1, NULL, 0);
1592 #endif /* CONFIG_SPLASH_SCREEN_ALIGN */
1594 if (video_display_bitmap(addr, x, y) == 0) {
1595 video_logo_height = 0;
1596 return ((void *) (video_fb_address));
1599 #endif /* CONFIG_SPLASH_SCREEN */
1601 logo_plot(video_fb_address, VIDEO_COLS, 0, 0);
1603 sprintf(info, " %s", version_string);
1605 space = (VIDEO_LINE_LEN / 2 - VIDEO_INFO_X) / VIDEO_FONT_WIDTH;
1609 video_drawchars(VIDEO_INFO_X, VIDEO_INFO_Y,
1610 (uchar *) info, space);
1611 video_drawchars(VIDEO_INFO_X + VIDEO_FONT_WIDTH,
1612 VIDEO_INFO_Y + VIDEO_FONT_HEIGHT,
1613 (uchar *) info + space, len - space);
1616 video_drawstring(VIDEO_INFO_X, VIDEO_INFO_Y, (uchar *) info);
1618 #ifdef CONFIG_CONSOLE_EXTRA_INFO
1621 ((video_logo_height -
1622 VIDEO_FONT_HEIGHT) / VIDEO_FONT_HEIGHT);
1624 for (i = 1; i < n; i++) {
1625 video_get_info_str(i, info);
1631 video_drawchars(VIDEO_INFO_X,
1635 (uchar *) info, space);
1637 video_drawchars(VIDEO_INFO_X +
1642 (uchar *) info + space,
1645 video_drawstring(VIDEO_INFO_X,
1655 return (video_fb_address + video_logo_height * VIDEO_LINE_LEN);
1659 static int video_init(void)
1661 unsigned char color8;
1663 pGD = video_hw_init();
1667 video_fb_address = (void *) VIDEO_FB_ADRS;
1668 #ifdef CONFIG_VIDEO_HW_CURSOR
1669 video_init_hw_cursor(VIDEO_FONT_WIDTH, VIDEO_FONT_HEIGHT);
1672 /* Init drawing pats */
1673 switch (VIDEO_DATA_FORMAT) {
1674 case GDF__8BIT_INDEX:
1675 video_set_lut(0x01, CONSOLE_FG_COL, CONSOLE_FG_COL,
1677 video_set_lut(0x00, CONSOLE_BG_COL, CONSOLE_BG_COL,
1682 case GDF__8BIT_332RGB:
1683 color8 = ((CONSOLE_FG_COL & 0xe0) |
1684 ((CONSOLE_FG_COL >> 3) & 0x1c) |
1685 CONSOLE_FG_COL >> 6);
1686 fgx = (color8 << 24) | (color8 << 16) | (color8 << 8) |
1688 color8 = ((CONSOLE_BG_COL & 0xe0) |
1689 ((CONSOLE_BG_COL >> 3) & 0x1c) |
1690 CONSOLE_BG_COL >> 6);
1691 bgx = (color8 << 24) | (color8 << 16) | (color8 << 8) |
1694 case GDF_15BIT_555RGB:
1695 fgx = (((CONSOLE_FG_COL >> 3) << 26) |
1696 ((CONSOLE_FG_COL >> 3) << 21) |
1697 ((CONSOLE_FG_COL >> 3) << 16) |
1698 ((CONSOLE_FG_COL >> 3) << 10) |
1699 ((CONSOLE_FG_COL >> 3) << 5) |
1700 (CONSOLE_FG_COL >> 3));
1701 bgx = (((CONSOLE_BG_COL >> 3) << 26) |
1702 ((CONSOLE_BG_COL >> 3) << 21) |
1703 ((CONSOLE_BG_COL >> 3) << 16) |
1704 ((CONSOLE_BG_COL >> 3) << 10) |
1705 ((CONSOLE_BG_COL >> 3) << 5) |
1706 (CONSOLE_BG_COL >> 3));
1708 case GDF_16BIT_565RGB:
1709 fgx = (((CONSOLE_FG_COL >> 3) << 27) |
1710 ((CONSOLE_FG_COL >> 2) << 21) |
1711 ((CONSOLE_FG_COL >> 3) << 16) |
1712 ((CONSOLE_FG_COL >> 3) << 11) |
1713 ((CONSOLE_FG_COL >> 2) << 5) |
1714 (CONSOLE_FG_COL >> 3));
1715 bgx = (((CONSOLE_BG_COL >> 3) << 27) |
1716 ((CONSOLE_BG_COL >> 2) << 21) |
1717 ((CONSOLE_BG_COL >> 3) << 16) |
1718 ((CONSOLE_BG_COL >> 3) << 11) |
1719 ((CONSOLE_BG_COL >> 2) << 5) |
1720 (CONSOLE_BG_COL >> 3));
1722 case GDF_32BIT_X888RGB:
1723 fgx = (CONSOLE_FG_COL << 16) |
1724 (CONSOLE_FG_COL << 8) |
1726 bgx = (CONSOLE_BG_COL << 16) |
1727 (CONSOLE_BG_COL << 8) |
1730 case GDF_24BIT_888RGB:
1731 fgx = (CONSOLE_FG_COL << 24) |
1732 (CONSOLE_FG_COL << 16) |
1733 (CONSOLE_FG_COL << 8) |
1735 bgx = (CONSOLE_BG_COL << 24) |
1736 (CONSOLE_BG_COL << 16) |
1737 (CONSOLE_BG_COL << 8) |
1743 #ifdef CONFIG_VIDEO_LOGO
1744 /* Plot the logo and get start point of console */
1745 debug("Video: Drawing the logo ...\n");
1746 video_console_address = video_logo();
1748 video_console_address = video_fb_address;
1751 /* Initialize the console */
1759 * Implement a weak default function for boards that optionally
1760 * need to skip the video initialization.
1762 int __board_video_skip(void)
1764 /* As default, don't skip test */
1768 int board_video_skip(void)
1769 __attribute__ ((weak, alias("__board_video_skip")));
1771 int drv_video_init(void)
1774 struct stdio_dev console_dev;
1776 /* Check if video initialization should be skipped */
1777 if (board_video_skip())
1780 /* Init video chip - returns with framebuffer cleared */
1781 skip_dev_init = (video_init() == -1);
1783 #if !defined(CONFIG_VGA_AS_SINGLE_DEVICE)
1784 debug("KBD: Keyboard init ...\n");
1785 skip_dev_init |= (VIDEO_KBD_INIT_FCT == -1);
1791 /* Init vga device */
1792 memset(&console_dev, 0, sizeof(console_dev));
1793 strcpy(console_dev.name, "vga");
1794 console_dev.ext = DEV_EXT_VIDEO; /* Video extensions */
1795 console_dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_SYSTEM;
1796 console_dev.putc = video_putc; /* 'putc' function */
1797 console_dev.puts = video_puts; /* 'puts' function */
1798 console_dev.tstc = NULL; /* 'tstc' function */
1799 console_dev.getc = NULL; /* 'getc' function */
1801 #if !defined(CONFIG_VGA_AS_SINGLE_DEVICE)
1802 /* Also init console device */
1803 console_dev.flags |= DEV_FLAGS_INPUT;
1804 console_dev.tstc = VIDEO_TSTC_FCT; /* 'tstc' function */
1805 console_dev.getc = VIDEO_GETC_FCT; /* 'getc' function */
1806 #endif /* CONFIG_VGA_AS_SINGLE_DEVICE */
1808 if (stdio_register(&console_dev) != 0)
1811 /* Return success */