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 console_col = 0; /* cursor col */
353 static int console_row = 0; /* cursor row */
355 static u32 eorx, fgx, bgx; /* color pats */
357 static const int video_font_draw_table8[] = {
358 0x00000000, 0x000000ff, 0x0000ff00, 0x0000ffff,
359 0x00ff0000, 0x00ff00ff, 0x00ffff00, 0x00ffffff,
360 0xff000000, 0xff0000ff, 0xff00ff00, 0xff00ffff,
361 0xffff0000, 0xffff00ff, 0xffffff00, 0xffffffff };
363 static const int video_font_draw_table15[] = {
364 0x00000000, 0x00007fff, 0x7fff0000, 0x7fff7fff };
366 static const int video_font_draw_table16[] = {
367 0x00000000, 0x0000ffff, 0xffff0000, 0xffffffff };
369 static const int video_font_draw_table24[16][3] = {
370 { 0x00000000, 0x00000000, 0x00000000 },
371 { 0x00000000, 0x00000000, 0x00ffffff },
372 { 0x00000000, 0x0000ffff, 0xff000000 },
373 { 0x00000000, 0x0000ffff, 0xffffffff },
374 { 0x000000ff, 0xffff0000, 0x00000000 },
375 { 0x000000ff, 0xffff0000, 0x00ffffff },
376 { 0x000000ff, 0xffffffff, 0xff000000 },
377 { 0x000000ff, 0xffffffff, 0xffffffff },
378 { 0xffffff00, 0x00000000, 0x00000000 },
379 { 0xffffff00, 0x00000000, 0x00ffffff },
380 { 0xffffff00, 0x0000ffff, 0xff000000 },
381 { 0xffffff00, 0x0000ffff, 0xffffffff },
382 { 0xffffffff, 0xffff0000, 0x00000000 },
383 { 0xffffffff, 0xffff0000, 0x00ffffff },
384 { 0xffffffff, 0xffffffff, 0xff000000 },
385 { 0xffffffff, 0xffffffff, 0xffffffff } };
387 static const int video_font_draw_table32[16][4] = {
388 { 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
389 { 0x00000000, 0x00000000, 0x00000000, 0x00ffffff },
390 { 0x00000000, 0x00000000, 0x00ffffff, 0x00000000 },
391 { 0x00000000, 0x00000000, 0x00ffffff, 0x00ffffff },
392 { 0x00000000, 0x00ffffff, 0x00000000, 0x00000000 },
393 { 0x00000000, 0x00ffffff, 0x00000000, 0x00ffffff },
394 { 0x00000000, 0x00ffffff, 0x00ffffff, 0x00000000 },
395 { 0x00000000, 0x00ffffff, 0x00ffffff, 0x00ffffff },
396 { 0x00ffffff, 0x00000000, 0x00000000, 0x00000000 },
397 { 0x00ffffff, 0x00000000, 0x00000000, 0x00ffffff },
398 { 0x00ffffff, 0x00000000, 0x00ffffff, 0x00000000 },
399 { 0x00ffffff, 0x00000000, 0x00ffffff, 0x00ffffff },
400 { 0x00ffffff, 0x00ffffff, 0x00000000, 0x00000000 },
401 { 0x00ffffff, 0x00ffffff, 0x00000000, 0x00ffffff },
402 { 0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00000000 },
403 { 0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00ffffff } };
406 /******************************************************************************/
408 static void video_drawchars (int xx, int yy, unsigned char *s, int count)
410 u8 *cdat, *dest, *dest0;
413 offset = yy * VIDEO_LINE_LEN + xx * VIDEO_PIXEL_SIZE;
414 dest0 = video_fb_address + offset;
416 switch (VIDEO_DATA_FORMAT) {
417 case GDF__8BIT_INDEX:
418 case GDF__8BIT_332RGB:
421 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
422 for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
424 dest += VIDEO_LINE_LEN) {
427 ((u32 *) dest)[0] = (video_font_draw_table8[bits >> 4] & eorx) ^ bgx;
428 ((u32 *) dest)[1] = (video_font_draw_table8[bits & 15] & eorx) ^ bgx;
430 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
435 case GDF_15BIT_555RGB:
438 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
439 for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
441 dest += VIDEO_LINE_LEN) {
444 ((u32 *) dest)[0] = SHORTSWAP32 ((video_font_draw_table15 [bits >> 6] & eorx) ^ bgx);
445 ((u32 *) dest)[1] = SHORTSWAP32 ((video_font_draw_table15 [bits >> 4 & 3] & eorx) ^ bgx);
446 ((u32 *) dest)[2] = SHORTSWAP32 ((video_font_draw_table15 [bits >> 2 & 3] & eorx) ^ bgx);
447 ((u32 *) dest)[3] = SHORTSWAP32 ((video_font_draw_table15 [bits & 3] & eorx) ^ bgx);
449 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
454 case GDF_16BIT_565RGB:
457 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
458 for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
460 dest += VIDEO_LINE_LEN) {
463 ((u32 *) dest)[0] = SHORTSWAP32 ((video_font_draw_table16 [bits >> 6] & eorx) ^ bgx);
464 ((u32 *) dest)[1] = SHORTSWAP32 ((video_font_draw_table16 [bits >> 4 & 3] & eorx) ^ bgx);
465 ((u32 *) dest)[2] = SHORTSWAP32 ((video_font_draw_table16 [bits >> 2 & 3] & eorx) ^ bgx);
466 ((u32 *) dest)[3] = SHORTSWAP32 ((video_font_draw_table16 [bits & 3] & eorx) ^ bgx);
468 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
473 case GDF_32BIT_X888RGB:
476 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
477 for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
479 dest += VIDEO_LINE_LEN) {
482 ((u32 *) dest)[0] = SWAP32 ((video_font_draw_table32 [bits >> 4][0] & eorx) ^ bgx);
483 ((u32 *) dest)[1] = SWAP32 ((video_font_draw_table32 [bits >> 4][1] & eorx) ^ bgx);
484 ((u32 *) dest)[2] = SWAP32 ((video_font_draw_table32 [bits >> 4][2] & eorx) ^ bgx);
485 ((u32 *) dest)[3] = SWAP32 ((video_font_draw_table32 [bits >> 4][3] & eorx) ^ bgx);
486 ((u32 *) dest)[4] = SWAP32 ((video_font_draw_table32 [bits & 15][0] & eorx) ^ bgx);
487 ((u32 *) dest)[5] = SWAP32 ((video_font_draw_table32 [bits & 15][1] & eorx) ^ bgx);
488 ((u32 *) dest)[6] = SWAP32 ((video_font_draw_table32 [bits & 15][2] & eorx) ^ bgx);
489 ((u32 *) dest)[7] = SWAP32 ((video_font_draw_table32 [bits & 15][3] & eorx) ^ bgx);
491 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
496 case GDF_24BIT_888RGB:
499 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
500 for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
502 dest += VIDEO_LINE_LEN) {
505 ((u32 *) dest)[0] = (video_font_draw_table24[bits >> 4][0] & eorx) ^ bgx;
506 ((u32 *) dest)[1] = (video_font_draw_table24[bits >> 4][1] & eorx) ^ bgx;
507 ((u32 *) dest)[2] = (video_font_draw_table24[bits >> 4][2] & eorx) ^ bgx;
508 ((u32 *) dest)[3] = (video_font_draw_table24[bits & 15][0] & eorx) ^ bgx;
509 ((u32 *) dest)[4] = (video_font_draw_table24[bits & 15][1] & eorx) ^ bgx;
510 ((u32 *) dest)[5] = (video_font_draw_table24[bits & 15][2] & eorx) ^ bgx;
512 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
519 /*****************************************************************************/
521 static inline void video_drawstring (int xx, int yy, unsigned char *s)
523 video_drawchars (xx, yy, s, strlen ((char *)s));
526 /*****************************************************************************/
528 static void video_putchar (int xx, int yy, unsigned char c)
530 video_drawchars (xx, yy + VIDEO_LOGO_HEIGHT, &c, 1);
533 /*****************************************************************************/
534 #if defined(CONFIG_CONSOLE_CURSOR) || defined(CONFIG_VIDEO_SW_CURSOR)
535 static void video_set_cursor (void)
537 /* swap drawing colors */
543 video_putchar (console_col * VIDEO_FONT_WIDTH,
544 console_row * VIDEO_FONT_HEIGHT,
546 /* restore drawing colors */
553 /*****************************************************************************/
554 #ifdef CONFIG_CONSOLE_CURSOR
555 void console_cursor (int state)
557 static int last_state = 0;
559 #ifdef CONFIG_CONSOLE_TIME
563 /* time update only if cursor is on (faster scroll) */
567 sprintf (info, " %02d:%02d:%02d ", tm.tm_hour, tm.tm_min,
569 video_drawstring (VIDEO_VISIBLE_COLS - 10 * VIDEO_FONT_WIDTH,
570 VIDEO_INFO_Y, (uchar *)info);
572 sprintf (info, "%02d.%02d.%04d", tm.tm_mday, tm.tm_mon,
574 video_drawstring (VIDEO_VISIBLE_COLS - 10 * VIDEO_FONT_WIDTH,
575 VIDEO_INFO_Y + 1 * VIDEO_FONT_HEIGHT, (uchar *)info);
579 if (state && (last_state != state)) {
583 if (!state && (last_state != state)) {
585 video_putchar (console_col * VIDEO_FONT_WIDTH,
586 console_row * VIDEO_FONT_HEIGHT,
594 /*****************************************************************************/
596 #ifndef VIDEO_HW_RECTFILL
597 static void memsetl (int *p, int c, int v)
604 /*****************************************************************************/
606 #ifndef VIDEO_HW_BITBLT
607 static void memcpyl (int *d, int *s, int c)
614 /*****************************************************************************/
616 static void console_scrollup (void)
618 /* copy up rows ignoring the first one */
620 #ifdef VIDEO_HW_BITBLT
621 video_hw_bitblt (VIDEO_PIXEL_SIZE, /* bytes per pixel */
622 0, /* source pos x */
623 VIDEO_LOGO_HEIGHT + VIDEO_FONT_HEIGHT, /* source pos y */
625 VIDEO_LOGO_HEIGHT, /* dest pos y */
626 VIDEO_VISIBLE_COLS, /* frame width */
627 VIDEO_VISIBLE_ROWS - VIDEO_LOGO_HEIGHT - VIDEO_FONT_HEIGHT /* frame height */
630 memcpyl (CONSOLE_ROW_FIRST, CONSOLE_ROW_SECOND,
631 CONSOLE_SCROLL_SIZE >> 2);
634 /* clear the last one */
635 #ifdef VIDEO_HW_RECTFILL
636 video_hw_rectfill (VIDEO_PIXEL_SIZE, /* bytes per pixel */
638 VIDEO_VISIBLE_ROWS - VIDEO_FONT_HEIGHT, /* dest pos y */
639 VIDEO_VISIBLE_COLS, /* frame width */
640 VIDEO_FONT_HEIGHT, /* frame height */
641 CONSOLE_BG_COL /* fill color */
644 memsetl (CONSOLE_ROW_LAST, CONSOLE_ROW_SIZE >> 2, CONSOLE_BG_COL);
648 /*****************************************************************************/
650 static void console_back (void)
652 CURSOR_OFF console_col--;
654 if (console_col < 0) {
655 console_col = CONSOLE_COLS - 1;
660 video_putchar (console_col * VIDEO_FONT_WIDTH,
661 console_row * VIDEO_FONT_HEIGHT,
665 /*****************************************************************************/
667 static void console_newline (void)
669 /* Check if last character in the line was just drawn. If so, cursor was
670 overwriten and need not to be cleared. Cursor clearing without this
671 check causes overwriting the 1st character of the line if line lenght
674 if (console_col < CONSOLE_COLS)
679 /* Check if we need to scroll the terminal */
680 if (console_row >= CONSOLE_ROWS) {
681 /* Scroll everything up */
684 /* Decrement row number */
689 static void console_cr (void)
691 CURSOR_OFF console_col = 0;
694 /*****************************************************************************/
696 void video_putc (const char c)
701 case 13: /* back to first column */
705 case '\n': /* next line */
706 if (console_col || (!console_col && nl))
712 CURSOR_OFF console_col |= 0x0008;
713 console_col &= ~0x0007;
715 if (console_col >= CONSOLE_COLS)
719 case 8: /* backspace */
723 default: /* draw the char */
724 video_putchar (console_col * VIDEO_FONT_WIDTH,
725 console_row * VIDEO_FONT_HEIGHT,
729 /* check for newline */
730 if (console_col >= CONSOLE_COLS) {
738 /*****************************************************************************/
740 void video_puts (const char *s)
742 int count = strlen (s);
748 /*****************************************************************************/
750 #if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN)
752 #define FILL_8BIT_332RGB(r,g,b) { \
753 *fb = ((r>>5)<<5) | ((g>>5)<<2) | (b>>6); \
757 #define FILL_15BIT_555RGB(r,g,b) { \
758 *(unsigned short *)fb = SWAP16((unsigned short)(((r>>3)<<10) | ((g>>3)<<5) | (b>>3))); \
762 #define FILL_16BIT_565RGB(r,g,b) { \
763 *(unsigned short *)fb = SWAP16((unsigned short)((((r)>>3)<<11) | (((g)>>2)<<5) | ((b)>>3))); \
767 #define FILL_32BIT_X888RGB(r,g,b) { \
768 *(unsigned long *)fb = SWAP32((unsigned long)(((r<<16) | (g<<8) | b))); \
772 #ifdef VIDEO_FB_LITTLE_ENDIAN
773 #define FILL_24BIT_888RGB(r,g,b) { \
780 #define FILL_24BIT_888RGB(r,g,b) { \
788 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
789 static void inline fill_555rgb_pswap(uchar *fb, int x,
792 ushort *dst = (ushort *)fb;
793 ushort color = (ushort)(((r >> 3) << 10) |
804 * Display the BMP file located at address bmp_image.
807 int video_display_bitmap (ulong bmp_image, int x, int y)
809 ushort xcount, ycount;
811 bmp_image_t *bmp = (bmp_image_t *) bmp_image;
814 unsigned long width, height, bpp;
816 unsigned long compression;
817 bmp_color_table_entry_t cte;
818 #ifdef CONFIG_VIDEO_BMP_GZIP
819 unsigned char *dst = NULL;
825 if (!((bmp->header.signature[0] == 'B') &&
826 (bmp->header.signature[1] == 'M'))) {
828 #ifdef CONFIG_VIDEO_BMP_GZIP
830 * Could be a gzipped bmp image, try to decrompress...
832 len = CONFIG_SYS_VIDEO_LOGO_MAX_SIZE;
833 dst = malloc(CONFIG_SYS_VIDEO_LOGO_MAX_SIZE);
835 printf("Error: malloc in gunzip failed!\n");
838 if (gunzip(dst, CONFIG_SYS_VIDEO_LOGO_MAX_SIZE, (uchar *)bmp_image, &len) != 0) {
839 printf ("Error: no valid bmp or bmp.gz image at %lx\n", bmp_image);
843 if (len == CONFIG_SYS_VIDEO_LOGO_MAX_SIZE) {
844 printf("Image could be truncated (increase CONFIG_SYS_VIDEO_LOGO_MAX_SIZE)!\n");
848 * Set addr to decompressed image
850 bmp = (bmp_image_t *)dst;
852 if (!((bmp->header.signature[0] == 'B') &&
853 (bmp->header.signature[1] == 'M'))) {
854 printf ("Error: no valid bmp.gz image at %lx\n", bmp_image);
859 printf ("Error: no valid bmp image at %lx\n", bmp_image);
861 #endif /* CONFIG_VIDEO_BMP_GZIP */
864 width = le32_to_cpu (bmp->header.width);
865 height = le32_to_cpu (bmp->header.height);
866 bpp = le16_to_cpu (bmp->header.bit_count);
867 colors = le32_to_cpu (bmp->header.colors_used);
868 compression = le32_to_cpu (bmp->header.compression);
870 debug ("Display-bmp: %d x %d with %d colors\n",
871 width, height, colors);
873 if (compression != BMP_BI_RGB) {
874 printf ("Error: compression type %ld not supported\n",
876 #ifdef CONFIG_VIDEO_BMP_GZIP
883 padded_line = (((width * bpp + 7) / 8) + 3) & ~0x3;
885 #ifdef CONFIG_SPLASH_SCREEN_ALIGN
886 if (x == BMP_ALIGN_CENTER)
887 x = max(0, (VIDEO_VISIBLE_COLS - width) / 2);
889 x = max(0, VIDEO_VISIBLE_COLS - width + x + 1);
891 if (y == BMP_ALIGN_CENTER)
892 y = max(0, (VIDEO_VISIBLE_ROWS - height) / 2);
894 y = max(0, VIDEO_VISIBLE_ROWS - height + y + 1);
895 #endif /* CONFIG_SPLASH_SCREEN_ALIGN */
897 if ((x + width) > VIDEO_VISIBLE_COLS)
898 width = VIDEO_VISIBLE_COLS - x;
899 if ((y + height) > VIDEO_VISIBLE_ROWS)
900 height = VIDEO_VISIBLE_ROWS - y;
902 bmap = (uchar *) bmp + le32_to_cpu (bmp->header.data_offset);
903 fb = (uchar *) (video_fb_address +
904 ((y + height - 1) * VIDEO_COLS * VIDEO_PIXEL_SIZE) +
905 x * VIDEO_PIXEL_SIZE);
907 /* We handle only 8bpp or 24 bpp bitmap */
908 switch (le16_to_cpu (bmp->header.bit_count)) {
910 padded_line -= width;
911 if (VIDEO_DATA_FORMAT == GDF__8BIT_INDEX) {
913 for (xcount = 0; xcount < colors; ++xcount) {
914 cte = bmp->color_table[xcount];
915 video_set_lut (xcount, cte.red, cte.green, cte.blue);
919 switch (VIDEO_DATA_FORMAT) {
920 case GDF__8BIT_INDEX:
928 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
931 case GDF__8BIT_332RGB:
936 cte = bmp->color_table[*bmap++];
937 FILL_8BIT_332RGB (cte.red, cte.green, cte.blue);
940 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
943 case GDF_15BIT_555RGB:
945 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
951 cte = bmp->color_table[*bmap++];
952 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
953 fill_555rgb_pswap (fb, xpos++, cte.red,
954 cte.green, cte.blue);
957 FILL_15BIT_555RGB (cte.red, cte.green, cte.blue);
961 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
964 case GDF_16BIT_565RGB:
969 cte = bmp->color_table[*bmap++];
970 FILL_16BIT_565RGB (cte.red, cte.green, cte.blue);
973 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
976 case GDF_32BIT_X888RGB:
981 cte = bmp->color_table[*bmap++];
982 FILL_32BIT_X888RGB (cte.red, cte.green, cte.blue);
985 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
988 case GDF_24BIT_888RGB:
993 cte = bmp->color_table[*bmap++];
994 FILL_24BIT_888RGB (cte.red, cte.green, cte.blue);
997 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1003 padded_line -= 3 * width;
1005 switch (VIDEO_DATA_FORMAT) {
1006 case GDF__8BIT_332RGB:
1011 FILL_8BIT_332RGB (bmap[2], bmap[1], bmap[0]);
1014 bmap += padded_line;
1015 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1018 case GDF_15BIT_555RGB:
1020 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1026 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1027 fill_555rgb_pswap (fb, xpos++, bmap[2],
1031 FILL_15BIT_555RGB (bmap[2], bmap[1], bmap[0]);
1035 bmap += padded_line;
1036 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1039 case GDF_16BIT_565RGB:
1044 FILL_16BIT_565RGB (bmap[2], bmap[1], bmap[0]);
1047 bmap += padded_line;
1048 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1051 case GDF_32BIT_X888RGB:
1056 FILL_32BIT_X888RGB (bmap[2], bmap[1], bmap[0]);
1059 bmap += padded_line;
1060 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1063 case GDF_24BIT_888RGB:
1068 FILL_24BIT_888RGB (bmap[2], bmap[1], bmap[0]);
1071 bmap += padded_line;
1072 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1076 printf ("Error: 24 bits/pixel bitmap incompatible with current video mode\n");
1081 printf ("Error: %d bit/pixel bitmaps not supported by U-Boot\n",
1082 le16_to_cpu (bmp->header.bit_count));
1086 #ifdef CONFIG_VIDEO_BMP_GZIP
1096 /*****************************************************************************/
1098 #ifdef CONFIG_VIDEO_LOGO
1099 void logo_plot (void *screen, int width, int x, int y)
1103 int skip = (width - VIDEO_LOGO_WIDTH) * VIDEO_PIXEL_SIZE;
1104 int ycount = VIDEO_LOGO_HEIGHT;
1105 unsigned char r, g, b, *logo_red, *logo_blue, *logo_green;
1106 unsigned char *source;
1107 unsigned char *dest = (unsigned char *)screen +
1108 ((y * width * VIDEO_PIXEL_SIZE) +
1109 x * VIDEO_PIXEL_SIZE);
1111 #ifdef CONFIG_VIDEO_BMP_LOGO
1112 source = bmp_logo_bitmap;
1114 /* Allocate temporary space for computing colormap */
1115 logo_red = malloc (BMP_LOGO_COLORS);
1116 logo_green = malloc (BMP_LOGO_COLORS);
1117 logo_blue = malloc (BMP_LOGO_COLORS);
1118 /* Compute color map */
1119 for (i = 0; i < VIDEO_LOGO_COLORS; i++) {
1120 logo_red[i] = (bmp_logo_palette[i] & 0x0f00) >> 4;
1121 logo_green[i] = (bmp_logo_palette[i] & 0x00f0);
1122 logo_blue[i] = (bmp_logo_palette[i] & 0x000f) << 4;
1125 source = linux_logo;
1126 logo_red = linux_logo_red;
1127 logo_green = linux_logo_green;
1128 logo_blue = linux_logo_blue;
1131 if (VIDEO_DATA_FORMAT == GDF__8BIT_INDEX) {
1132 for (i = 0; i < VIDEO_LOGO_COLORS; i++) {
1133 video_set_lut (i + VIDEO_LOGO_LUT_OFFSET,
1134 logo_red[i], logo_green[i], logo_blue[i]);
1139 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1142 xcount = VIDEO_LOGO_WIDTH;
1144 r = logo_red[*source - VIDEO_LOGO_LUT_OFFSET];
1145 g = logo_green[*source - VIDEO_LOGO_LUT_OFFSET];
1146 b = logo_blue[*source - VIDEO_LOGO_LUT_OFFSET];
1148 switch (VIDEO_DATA_FORMAT) {
1149 case GDF__8BIT_INDEX:
1152 case GDF__8BIT_332RGB:
1153 *dest = ((r >> 5) << 5) | ((g >> 5) << 2) | (b >> 6);
1155 case GDF_15BIT_555RGB:
1156 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1157 fill_555rgb_pswap (dest, xpos++, r, g, b);
1159 *(unsigned short *) dest =
1160 SWAP16 ((unsigned short) (((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3)));
1163 case GDF_16BIT_565RGB:
1164 *(unsigned short *) dest =
1165 SWAP16 ((unsigned short) (((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3)));
1167 case GDF_32BIT_X888RGB:
1168 *(unsigned long *) dest =
1169 SWAP32 ((unsigned long) ((r << 16) | (g << 8) | b));
1171 case GDF_24BIT_888RGB:
1172 #ifdef VIDEO_FB_LITTLE_ENDIAN
1184 dest += VIDEO_PIXEL_SIZE;
1188 #ifdef CONFIG_VIDEO_BMP_LOGO
1195 /*****************************************************************************/
1197 static void *video_logo (void)
1200 extern char version_string;
1201 int space, len, y_off = 0;
1203 #ifdef CONFIG_SPLASH_SCREEN
1207 if ((s = getenv ("splashimage")) != NULL) {
1210 addr = simple_strtoul (s, NULL, 16);
1211 #ifdef CONFIG_SPLASH_SCREEN_ALIGN
1212 if ((s = getenv ("splashpos")) != NULL) {
1214 x = BMP_ALIGN_CENTER;
1216 x = simple_strtol (s, NULL, 0);
1218 if ((s = strchr (s + 1, ',')) != NULL) {
1220 y = BMP_ALIGN_CENTER;
1222 y = simple_strtol (s + 1, NULL, 0);
1225 #endif /* CONFIG_SPLASH_SCREEN_ALIGN */
1227 if (video_display_bitmap (addr, x, y) == 0) {
1228 return ((void *) (video_fb_address));
1231 #endif /* CONFIG_SPLASH_SCREEN */
1233 logo_plot (video_fb_address, VIDEO_COLS, 0, 0);
1235 sprintf (info, " %s", &version_string);
1237 space = (VIDEO_LINE_LEN / 2 - VIDEO_INFO_X) / VIDEO_FONT_WIDTH;
1241 video_drawchars (VIDEO_INFO_X, VIDEO_INFO_Y,
1242 (uchar *)info, space);
1243 video_drawchars (VIDEO_INFO_X + VIDEO_FONT_WIDTH,
1244 VIDEO_INFO_Y + VIDEO_FONT_HEIGHT,
1245 (uchar *)info + space, len - space);
1248 video_drawstring (VIDEO_INFO_X, VIDEO_INFO_Y, (uchar *)info);
1250 #ifdef CONFIG_CONSOLE_EXTRA_INFO
1252 int i, n = ((VIDEO_LOGO_HEIGHT - VIDEO_FONT_HEIGHT) / VIDEO_FONT_HEIGHT);
1254 for (i = 1; i < n; i++) {
1255 video_get_info_str (i, info);
1261 video_drawchars (VIDEO_INFO_X,
1263 (i + y_off) * VIDEO_FONT_HEIGHT,
1264 (uchar *)info, space);
1266 video_drawchars (VIDEO_INFO_X + VIDEO_FONT_WIDTH,
1268 (i + y_off) * VIDEO_FONT_HEIGHT,
1269 (uchar *)info + space,
1272 video_drawstring (VIDEO_INFO_X,
1274 (i + y_off) * VIDEO_FONT_HEIGHT,
1281 return (video_fb_address + VIDEO_LOGO_HEIGHT * VIDEO_LINE_LEN);
1286 /*****************************************************************************/
1288 static int video_init (void)
1290 unsigned char color8;
1292 if ((pGD = video_hw_init ()) == NULL)
1295 video_fb_address = (void *) VIDEO_FB_ADRS;
1296 #ifdef CONFIG_VIDEO_HW_CURSOR
1297 video_init_hw_cursor (VIDEO_FONT_WIDTH, VIDEO_FONT_HEIGHT);
1300 /* Init drawing pats */
1301 switch (VIDEO_DATA_FORMAT) {
1302 case GDF__8BIT_INDEX:
1303 video_set_lut (0x01, CONSOLE_FG_COL, CONSOLE_FG_COL, CONSOLE_FG_COL);
1304 video_set_lut (0x00, CONSOLE_BG_COL, CONSOLE_BG_COL, CONSOLE_BG_COL);
1308 case GDF__8BIT_332RGB:
1309 color8 = ((CONSOLE_FG_COL & 0xe0) |
1310 ((CONSOLE_FG_COL >> 3) & 0x1c) | CONSOLE_FG_COL >> 6);
1311 fgx = (color8 << 24) | (color8 << 16) | (color8 << 8) | color8;
1312 color8 = ((CONSOLE_BG_COL & 0xe0) |
1313 ((CONSOLE_BG_COL >> 3) & 0x1c) | CONSOLE_BG_COL >> 6);
1314 bgx = (color8 << 24) | (color8 << 16) | (color8 << 8) | color8;
1316 case GDF_15BIT_555RGB:
1317 fgx = (((CONSOLE_FG_COL >> 3) << 26) |
1318 ((CONSOLE_FG_COL >> 3) << 21) | ((CONSOLE_FG_COL >> 3) << 16) |
1319 ((CONSOLE_FG_COL >> 3) << 10) | ((CONSOLE_FG_COL >> 3) << 5) |
1320 (CONSOLE_FG_COL >> 3));
1321 bgx = (((CONSOLE_BG_COL >> 3) << 26) |
1322 ((CONSOLE_BG_COL >> 3) << 21) | ((CONSOLE_BG_COL >> 3) << 16) |
1323 ((CONSOLE_BG_COL >> 3) << 10) | ((CONSOLE_BG_COL >> 3) << 5) |
1324 (CONSOLE_BG_COL >> 3));
1326 case GDF_16BIT_565RGB:
1327 fgx = (((CONSOLE_FG_COL >> 3) << 27) |
1328 ((CONSOLE_FG_COL >> 2) << 21) | ((CONSOLE_FG_COL >> 3) << 16) |
1329 ((CONSOLE_FG_COL >> 3) << 11) | ((CONSOLE_FG_COL >> 2) << 5) |
1330 (CONSOLE_FG_COL >> 3));
1331 bgx = (((CONSOLE_BG_COL >> 3) << 27) |
1332 ((CONSOLE_BG_COL >> 2) << 21) | ((CONSOLE_BG_COL >> 3) << 16) |
1333 ((CONSOLE_BG_COL >> 3) << 11) | ((CONSOLE_BG_COL >> 2) << 5) |
1334 (CONSOLE_BG_COL >> 3));
1336 case GDF_32BIT_X888RGB:
1337 fgx = (CONSOLE_FG_COL << 16) | (CONSOLE_FG_COL << 8) | CONSOLE_FG_COL;
1338 bgx = (CONSOLE_BG_COL << 16) | (CONSOLE_BG_COL << 8) | CONSOLE_BG_COL;
1340 case GDF_24BIT_888RGB:
1341 fgx = (CONSOLE_FG_COL << 24) | (CONSOLE_FG_COL << 16) |
1342 (CONSOLE_FG_COL << 8) | CONSOLE_FG_COL;
1343 bgx = (CONSOLE_BG_COL << 24) | (CONSOLE_BG_COL << 16) |
1344 (CONSOLE_BG_COL << 8) | CONSOLE_BG_COL;
1349 #ifdef CONFIG_VIDEO_LOGO
1350 /* Plot the logo and get start point of console */
1351 PRINTD ("Video: Drawing the logo ...\n");
1352 video_console_address = video_logo ();
1354 video_console_address = video_fb_address;
1357 /* Initialize the console */
1365 /*****************************************************************************/
1368 * Implement a weak default function for boards that optionally
1369 * need to skip the video initialization.
1371 int __board_video_skip(void)
1373 /* As default, don't skip test */
1376 int board_video_skip(void) __attribute__((weak, alias("__board_video_skip")));
1378 int drv_video_init (void)
1381 struct stdio_dev console_dev;
1383 /* Check if video initialization should be skipped */
1384 if (board_video_skip())
1387 /* Init video chip - returns with framebuffer cleared */
1388 skip_dev_init = (video_init () == -1);
1390 #if !defined(CONFIG_VGA_AS_SINGLE_DEVICE)
1391 PRINTD ("KBD: Keyboard init ...\n");
1392 skip_dev_init |= (VIDEO_KBD_INIT_FCT == -1);
1398 /* Init vga device */
1399 memset (&console_dev, 0, sizeof (console_dev));
1400 strcpy (console_dev.name, "vga");
1401 console_dev.ext = DEV_EXT_VIDEO; /* Video extensions */
1402 console_dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_SYSTEM;
1403 console_dev.putc = video_putc; /* 'putc' function */
1404 console_dev.puts = video_puts; /* 'puts' function */
1405 console_dev.tstc = NULL; /* 'tstc' function */
1406 console_dev.getc = NULL; /* 'getc' function */
1408 #if !defined(CONFIG_VGA_AS_SINGLE_DEVICE)
1409 /* Also init console device */
1410 console_dev.flags |= DEV_FLAGS_INPUT;
1411 console_dev.tstc = VIDEO_TSTC_FCT; /* 'tstc' function */
1412 console_dev.getc = VIDEO_GETC_FCT; /* 'getc' function */
1413 #endif /* CONFIG_VGA_AS_SINGLE_DEVICE */
1415 if (stdio_register (&console_dev) != 0)
1418 /* Return success */