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 CFG_CONSOLE_BLINK_COUNT - value for delay loop - blink rate
65 CONFIG_CONSOLE_TIME - display time/date in upper right corner,
66 needs CONFIG_CMD_DATE and CONFIG_CONSOLE_CURSOR
67 CONFIG_VIDEO_LOGO - display Linux Logo in upper left corner
68 CONFIG_VIDEO_BMP_LOGO - use bmp_logo instead of linux_logo
69 CONFIG_CONSOLE_EXTRA_INFO - display additional board information strings
70 that normaly goes to serial port. This define
71 requires a board specific function:
72 video_drawstring (VIDEO_INFO_X,
73 VIDEO_INFO_Y + i*VIDEO_FONT_HEIGHT,
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
95 #ifdef CONFIG_CFB_CONSOLE
99 /*****************************************************************************/
100 /* Console device defines with SMI graphic */
101 /* Any other graphic must change this section */
102 /*****************************************************************************/
104 #ifdef CONFIG_VIDEO_SMI_LYNXEM
106 #define VIDEO_FB_LITTLE_ENDIAN
107 #define VIDEO_HW_RECTFILL
108 #define VIDEO_HW_BITBLT
111 /*****************************************************************************/
112 /* Defines for the CT69000 driver */
113 /*****************************************************************************/
114 #ifdef CONFIG_VIDEO_CT69000
116 #define VIDEO_FB_LITTLE_ENDIAN
117 #define VIDEO_HW_RECTFILL
118 #define VIDEO_HW_BITBLT
121 /*****************************************************************************/
122 /* Defines for the SED13806 driver */
123 /*****************************************************************************/
124 #ifdef CONFIG_VIDEO_SED13806
126 #ifndef CONFIG_TOTAL5200
127 #define VIDEO_FB_LITTLE_ENDIAN
129 #define VIDEO_HW_RECTFILL
130 #define VIDEO_HW_BITBLT
133 /*****************************************************************************/
134 /* Defines for the SED13806 driver */
135 /*****************************************************************************/
136 #ifdef CONFIG_VIDEO_SM501
139 #define VIDEO_FB_LITTLE_ENDIAN
143 /*****************************************************************************/
144 /* Include video_fb.h after definitions of VIDEO_HW_RECTFILL etc */
145 /*****************************************************************************/
146 #include <video_fb.h>
148 /*****************************************************************************/
150 /*****************************************************************************/
151 #define VIDEO_VISIBLE_COLS (pGD->winSizeX)
152 #define VIDEO_VISIBLE_ROWS (pGD->winSizeY)
153 #define VIDEO_PIXEL_SIZE (pGD->gdfBytesPP)
154 #define VIDEO_DATA_FORMAT (pGD->gdfIndex)
155 #define VIDEO_FB_ADRS (pGD->frameAdrs)
157 /*****************************************************************************/
158 /* Console device defines with i8042 keyboard controller */
159 /* Any other keyboard controller must change this section */
160 /*****************************************************************************/
162 #ifdef CONFIG_I8042_KBD
165 #define VIDEO_KBD_INIT_FCT i8042_kbd_init()
166 #define VIDEO_TSTC_FCT i8042_tstc
167 #define VIDEO_GETC_FCT i8042_getc
170 /*****************************************************************************/
172 /*****************************************************************************/
175 #include <linux/types.h>
177 #include <video_font.h>
179 #if defined(CONFIG_CMD_DATE)
183 #if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN)
184 #include <watchdog.h>
185 #include <bmp_layout.h>
188 /*****************************************************************************/
189 /* Cursor definition: */
190 /* CONFIG_CONSOLE_CURSOR: Uses a timer function (see drivers/input/i8042.c) */
191 /* to let the cursor blink. Uses the macros */
192 /* CURSOR_OFF and CURSOR_ON. */
193 /* CONFIG_VIDEO_SW_CURSOR: Draws a cursor after the last character. No */
194 /* blinking is provided. Uses the macros CURSOR_SET */
195 /* and CURSOR_OFF. */
196 /* CONFIG_VIDEO_HW_CURSOR: Uses the hardware cursor capability of the */
197 /* graphic chip. Uses the macro CURSOR_SET. */
198 /* ATTENTION: If booting an OS, the display driver */
199 /* must disable the hardware register of the graphic */
200 /* chip. Otherwise a blinking field is displayed */
201 /*****************************************************************************/
202 #if !defined(CONFIG_CONSOLE_CURSOR) && \
203 !defined(CONFIG_VIDEO_SW_CURSOR) && \
204 !defined(CONFIG_VIDEO_HW_CURSOR)
205 /* no Cursor defined */
211 #ifdef CONFIG_CONSOLE_CURSOR
213 #error only one of CONFIG_CONSOLE_CURSOR,CONFIG_VIDEO_SW_CURSOR,CONFIG_VIDEO_HW_CURSOR can be defined
215 void console_cursor (int state);
216 #define CURSOR_ON console_cursor(1);
217 #define CURSOR_OFF console_cursor(0);
219 #ifndef CONFIG_I8042_KBD
220 #warning Cursor drawing on/off needs timer function s.a. drivers/input/i8042.c
223 #ifdef CONFIG_CONSOLE_TIME
224 #error CONFIG_CONSOLE_CURSOR must be defined for CONFIG_CONSOLE_TIME
226 #endif /* CONFIG_CONSOLE_CURSOR */
228 #ifdef CONFIG_VIDEO_SW_CURSOR
230 #error only one of CONFIG_CONSOLE_CURSOR,CONFIG_VIDEO_SW_CURSOR,CONFIG_VIDEO_HW_CURSOR can be defined
233 #define CURSOR_OFF video_putchar(console_col * VIDEO_FONT_WIDTH,\
234 console_row * VIDEO_FONT_HEIGHT, ' ');
235 #define CURSOR_SET video_set_cursor();
236 #endif /* CONFIG_VIDEO_SW_CURSOR */
239 #ifdef CONFIG_VIDEO_HW_CURSOR
241 #error only one of CONFIG_CONSOLE_CURSOR,CONFIG_VIDEO_SW_CURSOR,CONFIG_VIDEO_HW_CURSOR can be defined
245 #define CURSOR_SET video_set_hw_cursor(console_col * VIDEO_FONT_WIDTH, \
246 (console_row * VIDEO_FONT_HEIGHT) + VIDEO_LOGO_HEIGHT);
247 #endif /* CONFIG_VIDEO_HW_CURSOR */
249 #ifdef CONFIG_VIDEO_LOGO
250 #ifdef CONFIG_VIDEO_BMP_LOGO
251 #include <bmp_logo.h>
252 #define VIDEO_LOGO_WIDTH BMP_LOGO_WIDTH
253 #define VIDEO_LOGO_HEIGHT BMP_LOGO_HEIGHT
254 #define VIDEO_LOGO_LUT_OFFSET BMP_LOGO_OFFSET
255 #define VIDEO_LOGO_COLORS BMP_LOGO_COLORS
257 #else /* CONFIG_VIDEO_BMP_LOGO */
258 #define LINUX_LOGO_WIDTH 80
259 #define LINUX_LOGO_HEIGHT 80
260 #define LINUX_LOGO_COLORS 214
261 #define LINUX_LOGO_LUT_OFFSET 0x20
263 #include <linux_logo.h>
264 #define VIDEO_LOGO_WIDTH LINUX_LOGO_WIDTH
265 #define VIDEO_LOGO_HEIGHT LINUX_LOGO_HEIGHT
266 #define VIDEO_LOGO_LUT_OFFSET LINUX_LOGO_LUT_OFFSET
267 #define VIDEO_LOGO_COLORS LINUX_LOGO_COLORS
268 #endif /* CONFIG_VIDEO_BMP_LOGO */
269 #define VIDEO_INFO_X (VIDEO_LOGO_WIDTH)
270 #define VIDEO_INFO_Y (VIDEO_FONT_HEIGHT/2)
271 #else /* CONFIG_VIDEO_LOGO */
272 #define VIDEO_LOGO_WIDTH 0
273 #define VIDEO_LOGO_HEIGHT 0
274 #endif /* CONFIG_VIDEO_LOGO */
276 #define VIDEO_COLS VIDEO_VISIBLE_COLS
277 #define VIDEO_ROWS VIDEO_VISIBLE_ROWS
278 #define VIDEO_SIZE (VIDEO_ROWS*VIDEO_COLS*VIDEO_PIXEL_SIZE)
279 #define VIDEO_PIX_BLOCKS (VIDEO_SIZE >> 2)
280 #define VIDEO_LINE_LEN (VIDEO_COLS*VIDEO_PIXEL_SIZE)
281 #define VIDEO_BURST_LEN (VIDEO_COLS/8)
283 #ifdef CONFIG_VIDEO_LOGO
284 #define CONSOLE_ROWS ((VIDEO_ROWS - VIDEO_LOGO_HEIGHT) / VIDEO_FONT_HEIGHT)
286 #define CONSOLE_ROWS (VIDEO_ROWS / VIDEO_FONT_HEIGHT)
289 #define CONSOLE_COLS (VIDEO_COLS / VIDEO_FONT_WIDTH)
290 #define CONSOLE_ROW_SIZE (VIDEO_FONT_HEIGHT * VIDEO_LINE_LEN)
291 #define CONSOLE_ROW_FIRST (video_console_address)
292 #define CONSOLE_ROW_SECOND (video_console_address + CONSOLE_ROW_SIZE)
293 #define CONSOLE_ROW_LAST (video_console_address + CONSOLE_SIZE - CONSOLE_ROW_SIZE)
294 #define CONSOLE_SIZE (CONSOLE_ROW_SIZE * CONSOLE_ROWS)
295 #define CONSOLE_SCROLL_SIZE (CONSOLE_SIZE - CONSOLE_ROW_SIZE)
298 #ifdef VIDEO_FB_LITTLE_ENDIAN
299 #define SWAP16(x) ((((x) & 0x00ff) << 8) | ( (x) >> 8))
300 #define SWAP32(x) ((((x) & 0x000000ff) << 24) | (((x) & 0x0000ff00) << 8)|\
301 (((x) & 0x00ff0000) >> 8) | (((x) & 0xff000000) >> 24) )
302 #define SHORTSWAP32(x) ((((x) & 0x000000ff) << 8) | (((x) & 0x0000ff00) >> 8)|\
303 (((x) & 0x00ff0000) << 8) | (((x) & 0xff000000) >> 8) )
305 #define SWAP16(x) (x)
306 #define SWAP32(x) (x)
307 #define SHORTSWAP32(x) (x)
310 #if defined(DEBUG) || defined(DEBUG_CFB_CONSOLE)
311 #define PRINTD(x) printf(x)
317 #ifdef CONFIG_CONSOLE_EXTRA_INFO
318 extern void video_get_info_str ( /* setup a board string: type, speed, etc. */
319 int line_number, /* location to place info string beside logo */
320 char *info /* buffer for info string */
326 static GraphicDevice *pGD; /* Pointer to Graphic array */
328 static void *video_fb_address; /* frame buffer address */
329 static void *video_console_address; /* console buffer start address */
331 static int console_col = 0; /* cursor col */
332 static int console_row = 0; /* cursor row */
334 static u32 eorx, fgx, bgx; /* color pats */
336 static const int video_font_draw_table8[] = {
337 0x00000000, 0x000000ff, 0x0000ff00, 0x0000ffff,
338 0x00ff0000, 0x00ff00ff, 0x00ffff00, 0x00ffffff,
339 0xff000000, 0xff0000ff, 0xff00ff00, 0xff00ffff,
340 0xffff0000, 0xffff00ff, 0xffffff00, 0xffffffff };
342 static const int video_font_draw_table15[] = {
343 0x00000000, 0x00007fff, 0x7fff0000, 0x7fff7fff };
345 static const int video_font_draw_table16[] = {
346 0x00000000, 0x0000ffff, 0xffff0000, 0xffffffff };
348 static const int video_font_draw_table24[16][3] = {
349 { 0x00000000, 0x00000000, 0x00000000 },
350 { 0x00000000, 0x00000000, 0x00ffffff },
351 { 0x00000000, 0x0000ffff, 0xff000000 },
352 { 0x00000000, 0x0000ffff, 0xffffffff },
353 { 0x000000ff, 0xffff0000, 0x00000000 },
354 { 0x000000ff, 0xffff0000, 0x00ffffff },
355 { 0x000000ff, 0xffffffff, 0xff000000 },
356 { 0x000000ff, 0xffffffff, 0xffffffff },
357 { 0xffffff00, 0x00000000, 0x00000000 },
358 { 0xffffff00, 0x00000000, 0x00ffffff },
359 { 0xffffff00, 0x0000ffff, 0xff000000 },
360 { 0xffffff00, 0x0000ffff, 0xffffffff },
361 { 0xffffffff, 0xffff0000, 0x00000000 },
362 { 0xffffffff, 0xffff0000, 0x00ffffff },
363 { 0xffffffff, 0xffffffff, 0xff000000 },
364 { 0xffffffff, 0xffffffff, 0xffffffff } };
366 static const int video_font_draw_table32[16][4] = {
367 { 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
368 { 0x00000000, 0x00000000, 0x00000000, 0x00ffffff },
369 { 0x00000000, 0x00000000, 0x00ffffff, 0x00000000 },
370 { 0x00000000, 0x00000000, 0x00ffffff, 0x00ffffff },
371 { 0x00000000, 0x00ffffff, 0x00000000, 0x00000000 },
372 { 0x00000000, 0x00ffffff, 0x00000000, 0x00ffffff },
373 { 0x00000000, 0x00ffffff, 0x00ffffff, 0x00000000 },
374 { 0x00000000, 0x00ffffff, 0x00ffffff, 0x00ffffff },
375 { 0x00ffffff, 0x00000000, 0x00000000, 0x00000000 },
376 { 0x00ffffff, 0x00000000, 0x00000000, 0x00ffffff },
377 { 0x00ffffff, 0x00000000, 0x00ffffff, 0x00000000 },
378 { 0x00ffffff, 0x00000000, 0x00ffffff, 0x00ffffff },
379 { 0x00ffffff, 0x00ffffff, 0x00000000, 0x00000000 },
380 { 0x00ffffff, 0x00ffffff, 0x00000000, 0x00ffffff },
381 { 0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00000000 },
382 { 0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00ffffff } };
385 int gunzip(void *, int, unsigned char *, unsigned long *);
387 /******************************************************************************/
389 static void video_drawchars (int xx, int yy, unsigned char *s, int count)
391 u8 *cdat, *dest, *dest0;
394 offset = yy * VIDEO_LINE_LEN + xx * VIDEO_PIXEL_SIZE;
395 dest0 = video_fb_address + offset;
397 switch (VIDEO_DATA_FORMAT) {
398 case GDF__8BIT_INDEX:
399 case GDF__8BIT_332RGB:
402 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
403 for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
405 dest += VIDEO_LINE_LEN) {
408 ((u32 *) dest)[0] = (video_font_draw_table8[bits >> 4] & eorx) ^ bgx;
409 ((u32 *) dest)[1] = (video_font_draw_table8[bits & 15] & eorx) ^ bgx;
411 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
416 case GDF_15BIT_555RGB:
419 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
420 for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
422 dest += VIDEO_LINE_LEN) {
425 ((u32 *) dest)[0] = SHORTSWAP32 ((video_font_draw_table15 [bits >> 6] & eorx) ^ bgx);
426 ((u32 *) dest)[1] = SHORTSWAP32 ((video_font_draw_table15 [bits >> 4 & 3] & eorx) ^ bgx);
427 ((u32 *) dest)[2] = SHORTSWAP32 ((video_font_draw_table15 [bits >> 2 & 3] & eorx) ^ bgx);
428 ((u32 *) dest)[3] = SHORTSWAP32 ((video_font_draw_table15 [bits & 3] & eorx) ^ bgx);
430 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
435 case GDF_16BIT_565RGB:
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_table16 [bits >> 6] & eorx) ^ bgx);
445 ((u32 *) dest)[1] = SHORTSWAP32 ((video_font_draw_table16 [bits >> 4 & 3] & eorx) ^ bgx);
446 ((u32 *) dest)[2] = SHORTSWAP32 ((video_font_draw_table16 [bits >> 2 & 3] & eorx) ^ bgx);
447 ((u32 *) dest)[3] = SHORTSWAP32 ((video_font_draw_table16 [bits & 3] & eorx) ^ bgx);
449 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
454 case GDF_32BIT_X888RGB:
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] = SWAP32 ((video_font_draw_table32 [bits >> 4][0] & eorx) ^ bgx);
464 ((u32 *) dest)[1] = SWAP32 ((video_font_draw_table32 [bits >> 4][1] & eorx) ^ bgx);
465 ((u32 *) dest)[2] = SWAP32 ((video_font_draw_table32 [bits >> 4][2] & eorx) ^ bgx);
466 ((u32 *) dest)[3] = SWAP32 ((video_font_draw_table32 [bits >> 4][3] & eorx) ^ bgx);
467 ((u32 *) dest)[4] = SWAP32 ((video_font_draw_table32 [bits & 15][0] & eorx) ^ bgx);
468 ((u32 *) dest)[5] = SWAP32 ((video_font_draw_table32 [bits & 15][1] & eorx) ^ bgx);
469 ((u32 *) dest)[6] = SWAP32 ((video_font_draw_table32 [bits & 15][2] & eorx) ^ bgx);
470 ((u32 *) dest)[7] = SWAP32 ((video_font_draw_table32 [bits & 15][3] & eorx) ^ bgx);
472 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
477 case GDF_24BIT_888RGB:
480 cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
481 for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
483 dest += VIDEO_LINE_LEN) {
486 ((u32 *) dest)[0] = (video_font_draw_table24[bits >> 4][0] & eorx) ^ bgx;
487 ((u32 *) dest)[1] = (video_font_draw_table24[bits >> 4][1] & eorx) ^ bgx;
488 ((u32 *) dest)[2] = (video_font_draw_table24[bits >> 4][2] & eorx) ^ bgx;
489 ((u32 *) dest)[3] = (video_font_draw_table24[bits & 15][0] & eorx) ^ bgx;
490 ((u32 *) dest)[4] = (video_font_draw_table24[bits & 15][1] & eorx) ^ bgx;
491 ((u32 *) dest)[5] = (video_font_draw_table24[bits & 15][2] & eorx) ^ bgx;
493 dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
500 /*****************************************************************************/
502 static inline void video_drawstring (int xx, int yy, unsigned char *s)
504 video_drawchars (xx, yy, s, strlen ((char *)s));
507 /*****************************************************************************/
509 static void video_putchar (int xx, int yy, unsigned char c)
511 video_drawchars (xx, yy + VIDEO_LOGO_HEIGHT, &c, 1);
514 /*****************************************************************************/
515 #if defined(CONFIG_CONSOLE_CURSOR) || defined(CONFIG_VIDEO_SW_CURSOR)
516 static void video_set_cursor (void)
518 /* swap drawing colors */
524 video_putchar (console_col * VIDEO_FONT_WIDTH,
525 console_row * VIDEO_FONT_HEIGHT,
527 /* restore drawing colors */
534 /*****************************************************************************/
535 #ifdef CONFIG_CONSOLE_CURSOR
536 void console_cursor (int state)
538 static int last_state = 0;
540 #ifdef CONFIG_CONSOLE_TIME
544 /* time update only if cursor is on (faster scroll) */
548 sprintf (info, " %02d:%02d:%02d ", tm.tm_hour, tm.tm_min,
550 video_drawstring (VIDEO_VISIBLE_COLS - 10 * VIDEO_FONT_WIDTH,
551 VIDEO_INFO_Y, (uchar *)info);
553 sprintf (info, "%02d.%02d.%04d", tm.tm_mday, tm.tm_mon,
555 video_drawstring (VIDEO_VISIBLE_COLS - 10 * VIDEO_FONT_WIDTH,
556 VIDEO_INFO_Y + 1 * VIDEO_FONT_HEIGHT, (uchar *)info);
560 if (state && (last_state != state)) {
564 if (!state && (last_state != state)) {
566 video_putchar (console_col * VIDEO_FONT_WIDTH,
567 console_row * VIDEO_FONT_HEIGHT,
575 /*****************************************************************************/
577 #ifndef VIDEO_HW_RECTFILL
578 static void memsetl (int *p, int c, int v)
585 /*****************************************************************************/
587 #ifndef VIDEO_HW_BITBLT
588 static void memcpyl (int *d, int *s, int c)
595 /*****************************************************************************/
597 static void console_scrollup (void)
599 /* copy up rows ignoring the first one */
601 #ifdef VIDEO_HW_BITBLT
602 video_hw_bitblt (VIDEO_PIXEL_SIZE, /* bytes per pixel */
603 0, /* source pos x */
604 VIDEO_LOGO_HEIGHT + VIDEO_FONT_HEIGHT, /* source pos y */
606 VIDEO_LOGO_HEIGHT, /* dest pos y */
607 VIDEO_VISIBLE_COLS, /* frame width */
608 VIDEO_VISIBLE_ROWS - VIDEO_LOGO_HEIGHT - VIDEO_FONT_HEIGHT /* frame height */
611 memcpyl (CONSOLE_ROW_FIRST, CONSOLE_ROW_SECOND,
612 CONSOLE_SCROLL_SIZE >> 2);
615 /* clear the last one */
616 #ifdef VIDEO_HW_RECTFILL
617 video_hw_rectfill (VIDEO_PIXEL_SIZE, /* bytes per pixel */
619 VIDEO_VISIBLE_ROWS - VIDEO_FONT_HEIGHT, /* dest pos y */
620 VIDEO_VISIBLE_COLS, /* frame width */
621 VIDEO_FONT_HEIGHT, /* frame height */
622 CONSOLE_BG_COL /* fill color */
625 memsetl (CONSOLE_ROW_LAST, CONSOLE_ROW_SIZE >> 2, CONSOLE_BG_COL);
629 /*****************************************************************************/
631 static void console_back (void)
633 CURSOR_OFF console_col--;
635 if (console_col < 0) {
636 console_col = CONSOLE_COLS - 1;
641 video_putchar (console_col * VIDEO_FONT_WIDTH,
642 console_row * VIDEO_FONT_HEIGHT,
646 /*****************************************************************************/
648 static void console_newline (void)
650 /* Check if last character in the line was just drawn. If so, cursor was
651 overwriten and need not to be cleared. Cursor clearing without this
652 check causes overwriting the 1st character of the line if line lenght
655 if (console_col < CONSOLE_COLS)
660 /* Check if we need to scroll the terminal */
661 if (console_row >= CONSOLE_ROWS) {
662 /* Scroll everything up */
665 /* Decrement row number */
670 static void console_cr (void)
672 CURSOR_OFF console_col = 0;
675 /*****************************************************************************/
677 void video_putc (const char c)
682 case 13: /* back to first column */
686 case '\n': /* next line */
687 if (console_col || (!console_col && nl))
693 CURSOR_OFF console_col |= 0x0008;
694 console_col &= ~0x0007;
696 if (console_col >= CONSOLE_COLS)
700 case 8: /* backspace */
704 default: /* draw the char */
705 video_putchar (console_col * VIDEO_FONT_WIDTH,
706 console_row * VIDEO_FONT_HEIGHT,
710 /* check for newline */
711 if (console_col >= CONSOLE_COLS) {
719 /*****************************************************************************/
721 void video_puts (const char *s)
723 int count = strlen (s);
729 /*****************************************************************************/
731 #if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN)
733 #define FILL_8BIT_332RGB(r,g,b) { \
734 *fb = ((r>>5)<<5) | ((g>>5)<<2) | (b>>6); \
738 #define FILL_15BIT_555RGB(r,g,b) { \
739 *(unsigned short *)fb = SWAP16((unsigned short)(((r>>3)<<10) | ((g>>3)<<5) | (b>>3))); \
743 #define FILL_16BIT_565RGB(r,g,b) { \
744 *(unsigned short *)fb = SWAP16((unsigned short)((((r)>>3)<<11) | (((g)>>2)<<5) | ((b)>>3))); \
748 #define FILL_32BIT_X888RGB(r,g,b) { \
749 *(unsigned long *)fb = SWAP32((unsigned long)(((r<<16) | (g<<8) | b))); \
753 #ifdef VIDEO_FB_LITTLE_ENDIAN
754 #define FILL_24BIT_888RGB(r,g,b) { \
761 #define FILL_24BIT_888RGB(r,g,b) { \
771 * Display the BMP file located at address bmp_image.
774 int video_display_bitmap (ulong bmp_image, int x, int y)
776 ushort xcount, ycount;
778 bmp_image_t *bmp = (bmp_image_t *) bmp_image;
781 unsigned long width, height, bpp;
783 unsigned long compression;
784 bmp_color_table_entry_t cte;
785 #ifdef CONFIG_VIDEO_BMP_GZIP
786 unsigned char *dst = NULL;
792 if (!((bmp->header.signature[0] == 'B') &&
793 (bmp->header.signature[1] == 'M'))) {
795 #ifdef CONFIG_VIDEO_BMP_GZIP
797 * Could be a gzipped bmp image, try to decrompress...
799 len = CFG_VIDEO_LOGO_MAX_SIZE;
800 dst = malloc(CFG_VIDEO_LOGO_MAX_SIZE);
802 printf("Error: malloc in gunzip failed!\n");
805 if (gunzip(dst, CFG_VIDEO_LOGO_MAX_SIZE, (uchar *)bmp_image, &len) != 0) {
806 printf ("Error: no valid bmp or bmp.gz image at %lx\n", bmp_image);
810 if (len == CFG_VIDEO_LOGO_MAX_SIZE) {
811 printf("Image could be truncated (increase CFG_VIDEO_LOGO_MAX_SIZE)!\n");
815 * Set addr to decompressed image
817 bmp = (bmp_image_t *)dst;
819 if (!((bmp->header.signature[0] == 'B') &&
820 (bmp->header.signature[1] == 'M'))) {
821 printf ("Error: no valid bmp.gz image at %lx\n", bmp_image);
825 printf ("Error: no valid bmp image at %lx\n", bmp_image);
827 #endif /* CONFIG_VIDEO_BMP_GZIP */
830 width = le32_to_cpu (bmp->header.width);
831 height = le32_to_cpu (bmp->header.height);
832 bpp = le16_to_cpu (bmp->header.bit_count);
833 colors = le32_to_cpu (bmp->header.colors_used);
834 compression = le32_to_cpu (bmp->header.compression);
836 debug ("Display-bmp: %d x %d with %d colors\n",
837 width, height, colors);
839 if (compression != BMP_BI_RGB) {
840 printf ("Error: compression type %ld not supported\n",
845 padded_line = (((width * bpp + 7) / 8) + 3) & ~0x3;
847 if ((x + width) > VIDEO_VISIBLE_COLS)
848 width = VIDEO_VISIBLE_COLS - x;
849 if ((y + height) > VIDEO_VISIBLE_ROWS)
850 height = VIDEO_VISIBLE_ROWS - y;
852 bmap = (uchar *) bmp + le32_to_cpu (bmp->header.data_offset);
853 fb = (uchar *) (video_fb_address +
854 ((y + height - 1) * VIDEO_COLS * VIDEO_PIXEL_SIZE) +
855 x * VIDEO_PIXEL_SIZE);
857 /* We handle only 8bpp or 24 bpp bitmap */
858 switch (le16_to_cpu (bmp->header.bit_count)) {
860 padded_line -= width;
861 if (VIDEO_DATA_FORMAT == GDF__8BIT_INDEX) {
863 for (xcount = 0; xcount < colors; ++xcount) {
864 cte = bmp->color_table[xcount];
865 video_set_lut (xcount, cte.red, cte.green, cte.blue);
869 switch (VIDEO_DATA_FORMAT) {
870 case GDF__8BIT_INDEX:
878 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
881 case GDF__8BIT_332RGB:
886 cte = bmp->color_table[*bmap++];
887 FILL_8BIT_332RGB (cte.red, cte.green, cte.blue);
890 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
893 case GDF_15BIT_555RGB:
898 cte = bmp->color_table[*bmap++];
899 FILL_15BIT_555RGB (cte.red, cte.green, cte.blue);
902 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
905 case GDF_16BIT_565RGB:
910 cte = bmp->color_table[*bmap++];
911 FILL_16BIT_565RGB (cte.red, cte.green, cte.blue);
914 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
917 case GDF_32BIT_X888RGB:
922 cte = bmp->color_table[*bmap++];
923 FILL_32BIT_X888RGB (cte.red, cte.green, cte.blue);
926 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
929 case GDF_24BIT_888RGB:
934 cte = bmp->color_table[*bmap++];
935 FILL_24BIT_888RGB (cte.red, cte.green, cte.blue);
938 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
944 padded_line -= 3 * width;
946 switch (VIDEO_DATA_FORMAT) {
947 case GDF__8BIT_332RGB:
952 FILL_8BIT_332RGB (bmap[2], bmap[1], bmap[0]);
956 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
959 case GDF_15BIT_555RGB:
964 FILL_15BIT_555RGB (bmap[2], bmap[1], bmap[0]);
968 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
971 case GDF_16BIT_565RGB:
976 FILL_16BIT_565RGB (bmap[2], bmap[1], bmap[0]);
980 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
983 case GDF_32BIT_X888RGB:
988 FILL_32BIT_X888RGB (bmap[2], bmap[1], bmap[0]);
992 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
995 case GDF_24BIT_888RGB:
1000 FILL_24BIT_888RGB (bmap[2], bmap[1], bmap[0]);
1003 bmap += padded_line;
1004 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1008 printf ("Error: 24 bits/pixel bitmap incompatible with current video mode\n");
1013 printf ("Error: %d bit/pixel bitmaps not supported by U-Boot\n",
1014 le16_to_cpu (bmp->header.bit_count));
1018 #ifdef CONFIG_VIDEO_BMP_GZIP
1028 /*****************************************************************************/
1030 #ifdef CONFIG_VIDEO_LOGO
1031 void logo_plot (void *screen, int width, int x, int y)
1035 int skip = (width - VIDEO_LOGO_WIDTH) * VIDEO_PIXEL_SIZE;
1036 int ycount = VIDEO_LOGO_HEIGHT;
1037 unsigned char r, g, b, *logo_red, *logo_blue, *logo_green;
1038 unsigned char *source;
1039 unsigned char *dest = (unsigned char *)screen + ((y * width * VIDEO_PIXEL_SIZE) + x);
1041 #ifdef CONFIG_VIDEO_BMP_LOGO
1042 source = bmp_logo_bitmap;
1044 /* Allocate temporary space for computing colormap */
1045 logo_red = malloc (BMP_LOGO_COLORS);
1046 logo_green = malloc (BMP_LOGO_COLORS);
1047 logo_blue = malloc (BMP_LOGO_COLORS);
1048 /* Compute color map */
1049 for (i = 0; i < VIDEO_LOGO_COLORS; i++) {
1050 logo_red[i] = (bmp_logo_palette[i] & 0x0f00) >> 4;
1051 logo_green[i] = (bmp_logo_palette[i] & 0x00f0);
1052 logo_blue[i] = (bmp_logo_palette[i] & 0x000f) << 4;
1055 source = linux_logo;
1056 logo_red = linux_logo_red;
1057 logo_green = linux_logo_green;
1058 logo_blue = linux_logo_blue;
1061 if (VIDEO_DATA_FORMAT == GDF__8BIT_INDEX) {
1062 for (i = 0; i < VIDEO_LOGO_COLORS; i++) {
1063 video_set_lut (i + VIDEO_LOGO_LUT_OFFSET,
1064 logo_red[i], logo_green[i], logo_blue[i]);
1069 xcount = VIDEO_LOGO_WIDTH;
1071 r = logo_red[*source - VIDEO_LOGO_LUT_OFFSET];
1072 g = logo_green[*source - VIDEO_LOGO_LUT_OFFSET];
1073 b = logo_blue[*source - VIDEO_LOGO_LUT_OFFSET];
1075 switch (VIDEO_DATA_FORMAT) {
1076 case GDF__8BIT_INDEX:
1079 case GDF__8BIT_332RGB:
1080 *dest = ((r >> 5) << 5) | ((g >> 5) << 2) | (b >> 6);
1082 case GDF_15BIT_555RGB:
1083 *(unsigned short *) dest =
1084 SWAP16 ((unsigned short) (((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3)));
1086 case GDF_16BIT_565RGB:
1087 *(unsigned short *) dest =
1088 SWAP16 ((unsigned short) (((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3)));
1090 case GDF_32BIT_X888RGB:
1091 *(unsigned long *) dest =
1092 SWAP32 ((unsigned long) ((r << 16) | (g << 8) | b));
1094 case GDF_24BIT_888RGB:
1095 #ifdef VIDEO_FB_LITTLE_ENDIAN
1107 dest += VIDEO_PIXEL_SIZE;
1111 #ifdef CONFIG_VIDEO_BMP_LOGO
1118 /*****************************************************************************/
1120 static void *video_logo (void)
1123 extern char version_string;
1125 #ifdef CONFIG_SPLASH_SCREEN
1129 if ((s = getenv ("splashimage")) != NULL) {
1130 addr = simple_strtoul (s, NULL, 16);
1132 if (video_display_bitmap (addr, 0, 0) == 0) {
1133 return ((void *) (video_fb_address));
1136 #endif /* CONFIG_SPLASH_SCREEN */
1138 logo_plot (video_fb_address, VIDEO_COLS, 0, 0);
1140 sprintf (info, " %s", &version_string);
1141 video_drawstring (VIDEO_INFO_X, VIDEO_INFO_Y, (uchar *)info);
1143 #ifdef CONFIG_CONSOLE_EXTRA_INFO
1145 int i, n = ((VIDEO_LOGO_HEIGHT - VIDEO_FONT_HEIGHT) / VIDEO_FONT_HEIGHT);
1147 for (i = 1; i < n; i++) {
1148 video_get_info_str (i, info);
1150 video_drawstring (VIDEO_INFO_X,
1151 VIDEO_INFO_Y + i * VIDEO_FONT_HEIGHT,
1157 return (video_fb_address + VIDEO_LOGO_HEIGHT * VIDEO_LINE_LEN);
1162 /*****************************************************************************/
1164 static int video_init (void)
1166 unsigned char color8;
1168 if ((pGD = video_hw_init ()) == NULL)
1171 video_fb_address = (void *) VIDEO_FB_ADRS;
1172 #ifdef CONFIG_VIDEO_HW_CURSOR
1173 video_init_hw_cursor (VIDEO_FONT_WIDTH, VIDEO_FONT_HEIGHT);
1176 /* Init drawing pats */
1177 switch (VIDEO_DATA_FORMAT) {
1178 case GDF__8BIT_INDEX:
1179 video_set_lut (0x01, CONSOLE_FG_COL, CONSOLE_FG_COL, CONSOLE_FG_COL);
1180 video_set_lut (0x00, CONSOLE_BG_COL, CONSOLE_BG_COL, CONSOLE_BG_COL);
1184 case GDF__8BIT_332RGB:
1185 color8 = ((CONSOLE_FG_COL & 0xe0) |
1186 ((CONSOLE_FG_COL >> 3) & 0x1c) | CONSOLE_FG_COL >> 6);
1187 fgx = (color8 << 24) | (color8 << 16) | (color8 << 8) | color8;
1188 color8 = ((CONSOLE_BG_COL & 0xe0) |
1189 ((CONSOLE_BG_COL >> 3) & 0x1c) | CONSOLE_BG_COL >> 6);
1190 bgx = (color8 << 24) | (color8 << 16) | (color8 << 8) | color8;
1192 case GDF_15BIT_555RGB:
1193 fgx = (((CONSOLE_FG_COL >> 3) << 26) |
1194 ((CONSOLE_FG_COL >> 3) << 21) | ((CONSOLE_FG_COL >> 3) << 16) |
1195 ((CONSOLE_FG_COL >> 3) << 10) | ((CONSOLE_FG_COL >> 3) << 5) |
1196 (CONSOLE_FG_COL >> 3));
1197 bgx = (((CONSOLE_BG_COL >> 3) << 26) |
1198 ((CONSOLE_BG_COL >> 3) << 21) | ((CONSOLE_BG_COL >> 3) << 16) |
1199 ((CONSOLE_BG_COL >> 3) << 10) | ((CONSOLE_BG_COL >> 3) << 5) |
1200 (CONSOLE_BG_COL >> 3));
1202 case GDF_16BIT_565RGB:
1203 fgx = (((CONSOLE_FG_COL >> 3) << 27) |
1204 ((CONSOLE_FG_COL >> 2) << 21) | ((CONSOLE_FG_COL >> 3) << 16) |
1205 ((CONSOLE_FG_COL >> 3) << 11) | ((CONSOLE_FG_COL >> 2) << 5) |
1206 (CONSOLE_FG_COL >> 3));
1207 bgx = (((CONSOLE_BG_COL >> 3) << 27) |
1208 ((CONSOLE_BG_COL >> 2) << 21) | ((CONSOLE_BG_COL >> 3) << 16) |
1209 ((CONSOLE_BG_COL >> 3) << 11) | ((CONSOLE_BG_COL >> 2) << 5) |
1210 (CONSOLE_BG_COL >> 3));
1212 case GDF_32BIT_X888RGB:
1213 fgx = (CONSOLE_FG_COL << 16) | (CONSOLE_FG_COL << 8) | CONSOLE_FG_COL;
1214 bgx = (CONSOLE_BG_COL << 16) | (CONSOLE_BG_COL << 8) | CONSOLE_BG_COL;
1216 case GDF_24BIT_888RGB:
1217 fgx = (CONSOLE_FG_COL << 24) | (CONSOLE_FG_COL << 16) |
1218 (CONSOLE_FG_COL << 8) | CONSOLE_FG_COL;
1219 bgx = (CONSOLE_BG_COL << 24) | (CONSOLE_BG_COL << 16) |
1220 (CONSOLE_BG_COL << 8) | CONSOLE_BG_COL;
1225 #ifdef CONFIG_VIDEO_LOGO
1226 /* Plot the logo and get start point of console */
1227 PRINTD ("Video: Drawing the logo ...\n");
1228 video_console_address = video_logo ();
1230 video_console_address = video_fb_address;
1233 /* Initialize the console */
1241 /*****************************************************************************/
1243 int drv_video_init (void)
1246 device_t console_dev;
1250 /* Init video chip - returns with framebuffer cleared */
1251 if (video_init () == -1)
1254 #ifdef CONFIG_VGA_AS_SINGLE_DEVICE
1255 /* Devices VGA and Keyboard will be assigned seperately */
1256 /* Init vga device */
1257 if (!skip_dev_init) {
1258 memset (&console_dev, 0, sizeof (console_dev));
1259 strcpy (console_dev.name, "vga");
1260 console_dev.ext = DEV_EXT_VIDEO; /* Video extensions */
1261 console_dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_SYSTEM;
1262 console_dev.putc = video_putc; /* 'putc' function */
1263 console_dev.puts = video_puts; /* 'puts' function */
1264 console_dev.tstc = NULL; /* 'tstc' function */
1265 console_dev.getc = NULL; /* 'getc' function */
1267 if (device_register (&console_dev) == 0)
1271 PRINTD ("KBD: Keyboard init ...\n");
1272 if (VIDEO_KBD_INIT_FCT == -1)
1275 /* Init console device */
1276 if (!skip_dev_init) {
1277 memset (&console_dev, 0, sizeof (console_dev));
1278 strcpy (console_dev.name, "vga");
1279 console_dev.ext = DEV_EXT_VIDEO; /* Video extensions */
1280 console_dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT | DEV_FLAGS_SYSTEM;
1281 console_dev.putc = video_putc; /* 'putc' function */
1282 console_dev.puts = video_puts; /* 'puts' function */
1283 console_dev.tstc = VIDEO_TSTC_FCT; /* 'tstc' function */
1284 console_dev.getc = VIDEO_GETC_FCT; /* 'getc' function */
1286 if (device_register (&console_dev) == 0)
1289 #endif /* CONFIG_VGA_AS_SINGLE_DEVICE */
1290 /* No console dev available */
1293 #endif /* CONFIG_CFB_CONSOLE */