drivers/video/cfb_console.c

   1 /*
   2  * (C) Copyright 2002 ELTEC Elektronik AG
   3  * Frank Gottschling <fgottschling@eltec.de>
   4  *
   5  * See file CREDITS for list of people who contributed to this
   6  * project.
   7  *
   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.
  12  *
  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.
  17  *
  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,
  21  * MA 02111-1307 USA
  22  */
  23
  24 /*
  25  * cfb_console.c
  26  *
  27  * Color Framebuffer Console driver for 8/15/16/24/32 bits per pixel.
  28  *
  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.
  33  *
  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.
  39
  40  The driver uses graphic specific defines/parameters/functions:
  41
  42  (for SMI LynxE graphic chip)
  43
  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
  48
  49  Console Parameters are set by graphic drivers global struct:
  50
  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
  56
  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
  61
  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,
  74                                                  info);
  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).
  82
  83 CONFIG_VIDEO_SW_CURSOR:      - Draws a cursor after the last character. No
  84                                blinking is provided. Uses the macros CURSOR_SET
  85                                and CURSOR_OFF.
  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
  91 */
  92
  93 #include <common.h>
  94
  95 #include <malloc.h>
  96
  97 /*****************************************************************************/
  98 /* Console device defines with SMI graphic                                   */
  99 /* Any other graphic must change this section                                */
 100 /*****************************************************************************/
 101
 102 #ifdef  CONFIG_VIDEO_SMI_LYNXEM
 103
 104 #define VIDEO_FB_LITTLE_ENDIAN
 105 #define VIDEO_HW_RECTFILL
 106 #define VIDEO_HW_BITBLT
 107 #endif
 108
 109 /*****************************************************************************/
 110 /* Defines for the CT69000 driver                                            */
 111 /*****************************************************************************/
 112 #ifdef  CONFIG_VIDEO_CT69000
 113
 114 #define VIDEO_FB_LITTLE_ENDIAN
 115 #define VIDEO_HW_RECTFILL
 116 #define VIDEO_HW_BITBLT
 117 #endif
 118
 119 /*****************************************************************************/
 120 /* Defines for the SED13806 driver                                           */
 121 /*****************************************************************************/
 122 #ifdef CONFIG_VIDEO_SED13806
 123
 124 #ifndef CONFIG_TOTAL5200
 125 #define VIDEO_FB_LITTLE_ENDIAN
 126 #endif
 127 #define VIDEO_HW_RECTFILL
 128 #define VIDEO_HW_BITBLT
 129 #endif
 130
 131 /*****************************************************************************/
 132 /* Defines for the SED13806 driver                                           */
 133 /*****************************************************************************/
 134 #ifdef CONFIG_VIDEO_SM501
 135
 136 #ifdef CONFIG_HH405
 137 #define VIDEO_FB_LITTLE_ENDIAN
 138 #endif
 139 #endif
 140
 141 /*****************************************************************************/
 142 /* Defines for the MB862xx driver                                            */
 143 /*****************************************************************************/
 144 #ifdef CONFIG_VIDEO_MB862xx
 145
 146 #ifdef CONFIG_VIDEO_CORALP
 147 #define VIDEO_FB_LITTLE_ENDIAN
 148 #endif
 149 #ifdef CONFIG_VIDEO_MB862xx_ACCEL
 150 #define VIDEO_HW_RECTFILL
 151 #define VIDEO_HW_BITBLT
 152 #endif
 153 #endif
 154
 155 /*****************************************************************************/
 156 /* Include video_fb.h after definitions of VIDEO_HW_RECTFILL etc             */
 157 /*****************************************************************************/
 158 #include <video_fb.h>
 159
 160 /*****************************************************************************/
 161 /* some Macros                                                               */
 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)
 168
 169 /*****************************************************************************/
 170 /* Console device defines with i8042 keyboard controller                     */
 171 /* Any other keyboard controller must change this section                    */
 172 /*****************************************************************************/
 173
 174 #ifdef  CONFIG_I8042_KBD
 175 #include <i8042.h>
 176
 177 #define VIDEO_KBD_INIT_FCT      i8042_kbd_init()
 178 #define VIDEO_TSTC_FCT          i8042_tstc
 179 #define VIDEO_GETC_FCT          i8042_getc
 180 #endif
 181
 182 /*****************************************************************************/
 183 /* Console device                                                            */
 184 /*****************************************************************************/
 185
 186 #include <version.h>
 187 #include <linux/types.h>
 188 #include <stdio_dev.h>
 189 #include <video_font.h>
 190
 191 #if defined(CONFIG_CMD_DATE)
 192 #include <rtc.h>
 193 #endif
 194
 195 #if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN)
 196 #include <watchdog.h>
 197 #include <bmp_layout.h>
 198
 199 #ifdef CONFIG_SPLASH_SCREEN_ALIGN
 200 #define BMP_ALIGN_CENTER        0x7FFF
 201 #endif
 202
 203 #endif
 204
 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 */
 223 #define CURSOR_ON
 224 #define CURSOR_OFF
 225 #define CURSOR_SET
 226 #endif
 227
 228 #ifdef  CONFIG_CONSOLE_CURSOR
 229 #ifdef  CURSOR_ON
 230 #error  only one of CONFIG_CONSOLE_CURSOR,CONFIG_VIDEO_SW_CURSOR,CONFIG_VIDEO_HW_CURSOR can be defined
 231 #endif
 232 void    console_cursor (int state);
 233 #define CURSOR_ON  console_cursor(1)
 234 #define CURSOR_OFF console_cursor(0)
 235 #define CURSOR_SET
 236 #ifndef CONFIG_I8042_KBD
 237 #warning Cursor drawing on/off needs timer function s.a. drivers/input/i8042.c
 238 #endif
 239 #else
 240 #ifdef  CONFIG_CONSOLE_TIME
 241 #error  CONFIG_CONSOLE_CURSOR must be defined for CONFIG_CONSOLE_TIME
 242 #endif
 243 #endif /* CONFIG_CONSOLE_CURSOR */
 244
 245 #ifdef  CONFIG_VIDEO_SW_CURSOR
 246 #ifdef  CURSOR_ON
 247 #error  only one of CONFIG_CONSOLE_CURSOR,CONFIG_VIDEO_SW_CURSOR,CONFIG_VIDEO_HW_CURSOR can be defined
 248 #endif
 249 #define CURSOR_ON
 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 */
 254
 255
 256 #ifdef CONFIG_VIDEO_HW_CURSOR
 257 #ifdef  CURSOR_ON
 258 #error  only one of CONFIG_CONSOLE_CURSOR,CONFIG_VIDEO_SW_CURSOR,CONFIG_VIDEO_HW_CURSOR can be defined
 259 #endif
 260 #define CURSOR_ON
 261 #define CURSOR_OFF
 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 */
 265
 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
 273
 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
 279 #define __initdata
 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 */
 292
 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)
 299
 300 #ifdef  CONFIG_VIDEO_LOGO
 301 #define CONSOLE_ROWS            ((VIDEO_ROWS - video_logo_height) / VIDEO_FONT_HEIGHT)
 302 #else
 303 #define CONSOLE_ROWS            (VIDEO_ROWS / VIDEO_FONT_HEIGHT)
 304 #endif
 305
 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)
 313
 314 /* Macros */
 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) )
 321 #else
 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) )
 326 #else
 327 #define SHORTSWAP32(x)   (x)
 328 #endif
 329 #endif
 330
 331 #if defined(DEBUG) || defined(DEBUG_CFB_CONSOLE)
 332 #define PRINTD(x)         printf(x)
 333 #else
 334 #define PRINTD(x)
 335 #endif
 336
 337
 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 */
 342     );
 343
 344 #endif
 345
 346 /* Locals */
 347 static GraphicDevice *pGD;      /* Pointer to Graphic array */
 348
 349 static void *video_fb_address;          /* frame buffer address */
 350 static void *video_console_address;     /* console buffer start address */
 351
 352 static int video_logo_height = VIDEO_LOGO_HEIGHT;
 353
 354 static int console_col = 0; /* cursor col */
 355 static int console_row = 0; /* cursor row */
 356
 357 static u32 eorx, fgx, bgx;  /* color pats */
 358
 359 static const int video_font_draw_table8[] = {
 360             0x00000000, 0x000000ff, 0x0000ff00, 0x0000ffff,
 361             0x00ff0000, 0x00ff00ff, 0x00ffff00, 0x00ffffff,
 362             0xff000000, 0xff0000ff, 0xff00ff00, 0xff00ffff,
 363             0xffff0000, 0xffff00ff, 0xffffff00, 0xffffffff };
 364
 365 static const int video_font_draw_table15[] = {
 366             0x00000000, 0x00007fff, 0x7fff0000, 0x7fff7fff };
 367
 368 static const int video_font_draw_table16[] = {
 369             0x00000000, 0x0000ffff, 0xffff0000, 0xffffffff };
 370
 371 static const int video_font_draw_table24[16][3] = {
 372             { 0x00000000, 0x00000000, 0x00000000 },
 373             { 0x00000000, 0x00000000, 0x00ffffff },
 374             { 0x00000000, 0x0000ffff, 0xff000000 },
 375             { 0x00000000, 0x0000ffff, 0xffffffff },
 376             { 0x000000ff, 0xffff0000, 0x00000000 },
 377             { 0x000000ff, 0xffff0000, 0x00ffffff },
 378             { 0x000000ff, 0xffffffff, 0xff000000 },
 379             { 0x000000ff, 0xffffffff, 0xffffffff },
 380             { 0xffffff00, 0x00000000, 0x00000000 },
 381             { 0xffffff00, 0x00000000, 0x00ffffff },
 382             { 0xffffff00, 0x0000ffff, 0xff000000 },
 383             { 0xffffff00, 0x0000ffff, 0xffffffff },
 384             { 0xffffffff, 0xffff0000, 0x00000000 },
 385             { 0xffffffff, 0xffff0000, 0x00ffffff },
 386             { 0xffffffff, 0xffffffff, 0xff000000 },
 387             { 0xffffffff, 0xffffffff, 0xffffffff } };
 388
 389 static const int video_font_draw_table32[16][4] = {
 390             { 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 391             { 0x00000000, 0x00000000, 0x00000000, 0x00ffffff },
 392             { 0x00000000, 0x00000000, 0x00ffffff, 0x00000000 },
 393             { 0x00000000, 0x00000000, 0x00ffffff, 0x00ffffff },
 394             { 0x00000000, 0x00ffffff, 0x00000000, 0x00000000 },
 395             { 0x00000000, 0x00ffffff, 0x00000000, 0x00ffffff },
 396             { 0x00000000, 0x00ffffff, 0x00ffffff, 0x00000000 },
 397             { 0x00000000, 0x00ffffff, 0x00ffffff, 0x00ffffff },
 398             { 0x00ffffff, 0x00000000, 0x00000000, 0x00000000 },
 399             { 0x00ffffff, 0x00000000, 0x00000000, 0x00ffffff },
 400             { 0x00ffffff, 0x00000000, 0x00ffffff, 0x00000000 },
 401             { 0x00ffffff, 0x00000000, 0x00ffffff, 0x00ffffff },
 402             { 0x00ffffff, 0x00ffffff, 0x00000000, 0x00000000 },
 403             { 0x00ffffff, 0x00ffffff, 0x00000000, 0x00ffffff },
 404             { 0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00000000 },
 405             { 0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00ffffff } };
 406
 407
 408 /******************************************************************************/
 409
 410 static void video_drawchars (int xx, int yy, unsigned char *s, int count)
 411 {
 412         u8 *cdat, *dest, *dest0;
 413         int rows, offset, c;
 414
 415         offset = yy * VIDEO_LINE_LEN + xx * VIDEO_PIXEL_SIZE;
 416         dest0 = video_fb_address + offset;
 417
 418         switch (VIDEO_DATA_FORMAT) {
 419         case GDF__8BIT_INDEX:
 420         case GDF__8BIT_332RGB:
 421                 while (count--) {
 422                         c = *s;
 423                         cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
 424                         for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
 425                              rows--;
 426                              dest += VIDEO_LINE_LEN) {
 427                                 u8 bits = *cdat++;
 428
 429                                 ((u32 *) dest)[0] = (video_font_draw_table8[bits >> 4] & eorx) ^ bgx;
 430                                 ((u32 *) dest)[1] = (video_font_draw_table8[bits & 15] & eorx) ^ bgx;
 431                         }
 432                         dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
 433                         s++;
 434                 }
 435                 break;
 436
 437         case GDF_15BIT_555RGB:
 438                 while (count--) {
 439                         c = *s;
 440                         cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
 441                         for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
 442                              rows--;
 443                              dest += VIDEO_LINE_LEN) {
 444                                 u8 bits = *cdat++;
 445
 446                                 ((u32 *) dest)[0] = SHORTSWAP32 ((video_font_draw_table15 [bits >> 6] & eorx) ^ bgx);
 447                                 ((u32 *) dest)[1] = SHORTSWAP32 ((video_font_draw_table15 [bits >> 4 & 3] & eorx) ^ bgx);
 448                                 ((u32 *) dest)[2] = SHORTSWAP32 ((video_font_draw_table15 [bits >> 2 & 3] & eorx) ^ bgx);
 449                                 ((u32 *) dest)[3] = SHORTSWAP32 ((video_font_draw_table15 [bits & 3] & eorx) ^ bgx);
 450                         }
 451                         dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
 452                         s++;
 453                 }
 454                 break;
 455
 456         case GDF_16BIT_565RGB:
 457                 while (count--) {
 458                         c = *s;
 459                         cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
 460                         for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
 461                              rows--;
 462                              dest += VIDEO_LINE_LEN) {
 463                                 u8 bits = *cdat++;
 464
 465                                 ((u32 *) dest)[0] = SHORTSWAP32 ((video_font_draw_table16 [bits >> 6] & eorx) ^ bgx);
 466                                 ((u32 *) dest)[1] = SHORTSWAP32 ((video_font_draw_table16 [bits >> 4 & 3] & eorx) ^ bgx);
 467                                 ((u32 *) dest)[2] = SHORTSWAP32 ((video_font_draw_table16 [bits >> 2 & 3] & eorx) ^ bgx);
 468                                 ((u32 *) dest)[3] = SHORTSWAP32 ((video_font_draw_table16 [bits & 3] & eorx) ^ bgx);
 469                         }
 470                         dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
 471                         s++;
 472                 }
 473                 break;
 474
 475         case GDF_32BIT_X888RGB:
 476                 while (count--) {
 477                         c = *s;
 478                         cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
 479                         for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
 480                              rows--;
 481                              dest += VIDEO_LINE_LEN) {
 482                                 u8 bits = *cdat++;
 483
 484                                 ((u32 *) dest)[0] = SWAP32 ((video_font_draw_table32 [bits >> 4][0] & eorx) ^ bgx);
 485                                 ((u32 *) dest)[1] = SWAP32 ((video_font_draw_table32 [bits >> 4][1] & eorx) ^ bgx);
 486                                 ((u32 *) dest)[2] = SWAP32 ((video_font_draw_table32 [bits >> 4][2] & eorx) ^ bgx);
 487                                 ((u32 *) dest)[3] = SWAP32 ((video_font_draw_table32 [bits >> 4][3] & eorx) ^ bgx);
 488                                 ((u32 *) dest)[4] = SWAP32 ((video_font_draw_table32 [bits & 15][0] & eorx) ^ bgx);
 489                                 ((u32 *) dest)[5] = SWAP32 ((video_font_draw_table32 [bits & 15][1] & eorx) ^ bgx);
 490                                 ((u32 *) dest)[6] = SWAP32 ((video_font_draw_table32 [bits & 15][2] & eorx) ^ bgx);
 491                                 ((u32 *) dest)[7] = SWAP32 ((video_font_draw_table32 [bits & 15][3] & eorx) ^ bgx);
 492                         }
 493                         dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
 494                         s++;
 495                 }
 496                 break;
 497
 498         case GDF_24BIT_888RGB:
 499                 while (count--) {
 500                         c = *s;
 501                         cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
 502                         for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
 503                              rows--;
 504                              dest += VIDEO_LINE_LEN) {
 505                                 u8 bits = *cdat++;
 506
 507                                 ((u32 *) dest)[0] = (video_font_draw_table24[bits >> 4][0] & eorx) ^ bgx;
 508                                 ((u32 *) dest)[1] = (video_font_draw_table24[bits >> 4][1] & eorx) ^ bgx;
 509                                 ((u32 *) dest)[2] = (video_font_draw_table24[bits >> 4][2] & eorx) ^ bgx;
 510                                 ((u32 *) dest)[3] = (video_font_draw_table24[bits & 15][0] & eorx) ^ bgx;
 511                                 ((u32 *) dest)[4] = (video_font_draw_table24[bits & 15][1] & eorx) ^ bgx;
 512                                 ((u32 *) dest)[5] = (video_font_draw_table24[bits & 15][2] & eorx) ^ bgx;
 513                         }
 514                         dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
 515                         s++;
 516                 }
 517                 break;
 518         }
 519 }
 520
 521 /*****************************************************************************/
 522
 523 static inline void video_drawstring (int xx, int yy, unsigned char *s)
 524 {
 525         video_drawchars (xx, yy, s, strlen ((char *)s));
 526 }
 527
 528 /*****************************************************************************/
 529
 530 static void video_putchar (int xx, int yy, unsigned char c)
 531 {
 532         video_drawchars (xx, yy + video_logo_height, &c, 1);
 533 }
 534
 535 /*****************************************************************************/
 536 #if defined(CONFIG_CONSOLE_CURSOR) || defined(CONFIG_VIDEO_SW_CURSOR)
 537 static void video_set_cursor (void)
 538 {
 539         /* swap drawing colors */
 540         eorx = fgx;
 541         fgx = bgx;
 542         bgx = eorx;
 543         eorx = fgx ^ bgx;
 544         /* draw cursor */
 545         video_putchar (console_col * VIDEO_FONT_WIDTH,
 546                        console_row * VIDEO_FONT_HEIGHT,
 547                        ' ');
 548         /* restore drawing colors */
 549         eorx = fgx;
 550         fgx = bgx;
 551         bgx = eorx;
 552         eorx = fgx ^ bgx;
 553 }
 554 #endif
 555 /*****************************************************************************/
 556 #ifdef CONFIG_CONSOLE_CURSOR
 557 void console_cursor (int state)
 558 {
 559         static int last_state = 0;
 560
 561 #ifdef CONFIG_CONSOLE_TIME
 562         struct rtc_time tm;
 563         char info[16];
 564
 565         /* time update only if cursor is on (faster scroll) */
 566         if (state) {
 567                 rtc_get (&tm);
 568
 569                 sprintf (info, " %02d:%02d:%02d ", tm.tm_hour, tm.tm_min,
 570                          tm.tm_sec);
 571                 video_drawstring (VIDEO_VISIBLE_COLS - 10 * VIDEO_FONT_WIDTH,
 572                                   VIDEO_INFO_Y, (uchar *)info);
 573
 574                 sprintf (info, "%02d.%02d.%04d", tm.tm_mday, tm.tm_mon,
 575                          tm.tm_year);
 576                 video_drawstring (VIDEO_VISIBLE_COLS - 10 * VIDEO_FONT_WIDTH,
 577                                   VIDEO_INFO_Y + 1 * VIDEO_FONT_HEIGHT, (uchar *)info);
 578         }
 579 #endif
 580
 581         if (state && (last_state != state)) {
 582                 video_set_cursor ();
 583         }
 584
 585         if (!state && (last_state != state)) {
 586                 /* clear cursor */
 587                 video_putchar (console_col * VIDEO_FONT_WIDTH,
 588                                console_row * VIDEO_FONT_HEIGHT,
 589                                ' ');
 590         }
 591
 592         last_state = state;
 593 }
 594 #endif
 595
 596 /*****************************************************************************/
 597
 598 #ifndef VIDEO_HW_RECTFILL
 599 static void memsetl (int *p, int c, int v)
 600 {
 601         while (c--)
 602                 *(p++) = v;
 603 }
 604 #endif
 605
 606 /*****************************************************************************/
 607
 608 #ifndef VIDEO_HW_BITBLT
 609 static void memcpyl (int *d, int *s, int c)
 610 {
 611         while (c--)
 612                 *(d++) = *(s++);
 613 }
 614 #endif
 615
 616 /*****************************************************************************/
 617
 618 static void console_scrollup (void)
 619 {
 620         /* copy up rows ignoring the first one */
 621
 622 #ifdef VIDEO_HW_BITBLT
 623         video_hw_bitblt (VIDEO_PIXEL_SIZE,      /* bytes per pixel */
 624                          0,     /* source pos x */
 625                          video_logo_height + VIDEO_FONT_HEIGHT, /* source pos y */
 626                          0,     /* dest pos x */
 627                          video_logo_height,     /* dest pos y */
 628                          VIDEO_VISIBLE_COLS,    /* frame width */
 629                          VIDEO_VISIBLE_ROWS - video_logo_height - VIDEO_FONT_HEIGHT     /* frame height */
 630                 );
 631 #else
 632         memcpyl (CONSOLE_ROW_FIRST, CONSOLE_ROW_SECOND,
 633                  CONSOLE_SCROLL_SIZE >> 2);
 634 #endif
 635
 636         /* clear the last one */
 637 #ifdef VIDEO_HW_RECTFILL
 638         video_hw_rectfill (VIDEO_PIXEL_SIZE,    /* bytes per pixel */
 639                            0,   /* dest pos x */
 640                            VIDEO_VISIBLE_ROWS - VIDEO_FONT_HEIGHT,      /* dest pos y */
 641                            VIDEO_VISIBLE_COLS,  /* frame width */
 642                            VIDEO_FONT_HEIGHT,   /* frame height */
 643                            CONSOLE_BG_COL       /* fill color */
 644                 );
 645 #else
 646         memsetl (CONSOLE_ROW_LAST, CONSOLE_ROW_SIZE >> 2, CONSOLE_BG_COL);
 647 #endif
 648 }
 649
 650 /*****************************************************************************/
 651
 652 static void console_back (void)
 653 {
 654         CURSOR_OFF;
 655         console_col--;
 656
 657         if (console_col < 0) {
 658                 console_col = CONSOLE_COLS - 1;
 659                 console_row--;
 660                 if (console_row < 0)
 661                         console_row = 0;
 662         }
 663         video_putchar (console_col * VIDEO_FONT_WIDTH,
 664                        console_row * VIDEO_FONT_HEIGHT,
 665                        ' ');
 666 }
 667
 668 /*****************************************************************************/
 669
 670 static void console_newline (void)
 671 {
 672         /* Check if last character in the line was just drawn. If so, cursor was
 673            overwriten and need not to be cleared. Cursor clearing without this
 674            check causes overwriting the 1st character of the line if line lenght
 675            is >= CONSOLE_COLS
 676          */
 677         if (console_col < CONSOLE_COLS)
 678                 CURSOR_OFF;
 679         console_row++;
 680         console_col = 0;
 681
 682         /* Check if we need to scroll the terminal */
 683         if (console_row >= CONSOLE_ROWS) {
 684                 /* Scroll everything up */
 685                 console_scrollup ();
 686
 687                 /* Decrement row number */
 688                 console_row--;
 689         }
 690 }
 691
 692 static void console_cr (void)
 693 {
 694         CURSOR_OFF;
 695         console_col = 0;
 696 }
 697
 698 /*****************************************************************************/
 699
 700 void video_putc (const char c)
 701 {
 702         static int nl = 1;
 703
 704         switch (c) {
 705         case 13:                /* back to first column */
 706                 console_cr ();
 707                 break;
 708
 709         case '\n':              /* next line */
 710                 if (console_col || (!console_col && nl))
 711                         console_newline ();
 712                 nl = 1;
 713                 break;
 714
 715         case 9:         /* tab 8 */
 716                 CURSOR_OFF;
 717                 console_col |= 0x0008;
 718                 console_col &= ~0x0007;
 719
 720                 if (console_col >= CONSOLE_COLS)
 721                         console_newline ();
 722                 break;
 723
 724         case 8:         /* backspace */
 725                 console_back ();
 726                 break;
 727
 728         default:                /* draw the char */
 729                 video_putchar (console_col * VIDEO_FONT_WIDTH,
 730                                console_row * VIDEO_FONT_HEIGHT,
 731                                c);
 732                 console_col++;
 733
 734                 /* check for newline */
 735                 if (console_col >= CONSOLE_COLS) {
 736                         console_newline ();
 737                         nl = 0;
 738                 }
 739         }
 740         CURSOR_SET;
 741 }
 742
 743
 744 /*****************************************************************************/
 745
 746 void video_puts (const char *s)
 747 {
 748         int count = strlen (s);
 749
 750         while (count--)
 751                 video_putc (*s++);
 752 }
 753
 754 /*****************************************************************************/
 755
 756 /*
 757  * Do not enforce drivers (or board code) to provide empty
 758  * video_set_lut() if they do not support 8 bpp format.
 759  * Implement weak default function instead.
 760  */
 761 void __video_set_lut (unsigned int index, unsigned char r,
 762                       unsigned char g, unsigned char b)
 763 {
 764 }
 765 void video_set_lut (unsigned int, unsigned char, unsigned char, unsigned char)
 766                         __attribute__((weak, alias("__video_set_lut")));
 767
 768 #if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN)
 769
 770 #define FILL_8BIT_332RGB(r,g,b) {                       \
 771         *fb = ((r>>5)<<5) | ((g>>5)<<2) | (b>>6);       \
 772         fb ++;                                          \
 773 }
 774
 775 #define FILL_15BIT_555RGB(r,g,b) {                      \
 776         *(unsigned short *)fb = SWAP16((unsigned short)(((r>>3)<<10) | ((g>>3)<<5) | (b>>3))); \
 777         fb += 2;                                        \
 778 }
 779
 780 #define FILL_16BIT_565RGB(r,g,b) {                      \
 781         *(unsigned short *)fb = SWAP16((unsigned short)((((r)>>3)<<11) | (((g)>>2)<<5) | ((b)>>3))); \
 782         fb += 2;                                        \
 783 }
 784
 785 #define FILL_32BIT_X888RGB(r,g,b) {                     \
 786         *(unsigned long *)fb = SWAP32((unsigned long)(((r<<16) | (g<<8) | b))); \
 787         fb += 4;                                        \
 788 }
 789
 790 #ifdef VIDEO_FB_LITTLE_ENDIAN
 791 #define FILL_24BIT_888RGB(r,g,b) {                      \
 792         fb[0] = b;                                      \
 793         fb[1] = g;                                      \
 794         fb[2] = r;                                      \
 795         fb += 3;                                        \
 796 }
 797 #else
 798 #define FILL_24BIT_888RGB(r,g,b) {                      \
 799         fb[0] = r;                                      \
 800         fb[1] = g;                                      \
 801         fb[2] = b;                                      \
 802         fb += 3;                                        \
 803 }
 804 #endif
 805
 806 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
 807 static void inline fill_555rgb_pswap(uchar *fb, int x,
 808                                      u8 r, u8 g, u8 b)
 809 {
 810         ushort *dst = (ushort *)fb;
 811         ushort color = (ushort)(((r >> 3) << 10) |
 812                                 ((g >> 3) << 5) |
 813                                 (b >> 3));
 814         if (x & 1)
 815                 *(--dst) = color;
 816         else
 817                 *(++dst) = color;
 818 }
 819 #endif
 820
 821 /*
 822  * RLE8 bitmap support
 823  */
 824
 825 #ifdef CONFIG_VIDEO_BMP_RLE8
 826 /* Pre-calculated color table entry */
 827 struct palette {
 828         union {
 829                 unsigned short  w;      /* word */
 830                 unsigned int    dw;     /* double word */
 831         } ce; /* color entry */
 832 };
 833
 834 /*
 835  * Helper to draw encoded/unencoded run.
 836  */
 837 static void draw_bitmap (uchar **fb, uchar *bm, struct palette *p,
 838                          int cnt, int enc)
 839 {
 840         ulong addr = (ulong)*fb;
 841         int *off;
 842         int enc_off = 1;
 843         int i;
 844
 845         /*
 846          * Setup offset of the color index in the bitmap.
 847          * Color index of encoded run is at offset 1.
 848          */
 849         off = enc ? &enc_off : &i;
 850
 851         switch (VIDEO_DATA_FORMAT) {
 852         case GDF__8BIT_INDEX:
 853                 for (i = 0; i < cnt; i++)
 854                         *(unsigned char *)addr++ = bm[*off];
 855                 break;
 856         case GDF_15BIT_555RGB:
 857         case GDF_16BIT_565RGB:
 858                 /* differences handled while pre-calculating palette */
 859                 for (i = 0; i < cnt; i++) {
 860                         *(unsigned short *)addr = p[bm[*off]].ce.w;
 861                         addr += 2;
 862                 }
 863                 break;
 864         case GDF_32BIT_X888RGB:
 865                 for (i = 0; i < cnt; i++) {
 866                         *(unsigned long *)addr = p[bm[*off]].ce.dw;
 867                         addr += 4;
 868                 }
 869                 break;
 870         }
 871         *fb = (uchar *)addr; /* return modified address */
 872 }
 873
 874 static int display_rle8_bitmap (bmp_image_t *img, int xoff, int yoff,
 875                                 int width, int height)
 876 {
 877         unsigned char *bm;
 878         unsigned char *fbp;
 879         unsigned int cnt, runlen;
 880         int decode = 1;
 881         int x, y, bpp, i, ncolors;
 882         struct palette p[256];
 883         bmp_color_table_entry_t cte;
 884         int green_shift, red_off;
 885         int limit = VIDEO_COLS * VIDEO_ROWS;
 886         int pixels = 0;
 887
 888         x = 0;
 889         y = __le32_to_cpu(img->header.height) - 1;
 890         ncolors = __le32_to_cpu(img->header.colors_used);
 891         bpp = VIDEO_PIXEL_SIZE;
 892         fbp = (unsigned char *)((unsigned int)video_fb_address +
 893                                 (((y + yoff) * VIDEO_COLS) + xoff) * bpp);
 894
 895         bm = (uchar *)img + __le32_to_cpu(img->header.data_offset);
 896
 897         /* pre-calculate and setup palette */
 898         switch (VIDEO_DATA_FORMAT) {
 899         case GDF__8BIT_INDEX:
 900                 for (i = 0; i < ncolors; i++) {
 901                         cte = img->color_table[i];
 902                         video_set_lut (i, cte.red, cte.green, cte.blue);
 903                 }
 904                 break;
 905         case GDF_15BIT_555RGB:
 906         case GDF_16BIT_565RGB:
 907                 if (VIDEO_DATA_FORMAT == GDF_15BIT_555RGB) {
 908                         green_shift = 3;
 909                         red_off = 10;
 910                 } else {
 911                         green_shift = 2;
 912                         red_off = 11;
 913                 }
 914                 for (i = 0; i < ncolors; i++) {
 915                         cte = img->color_table[i];
 916                         p[i].ce.w = SWAP16((unsigned short)
 917                                            (((cte.red >> 3) << red_off) |
 918                                             ((cte.green >> green_shift) << 5) |
 919                                             cte.blue >> 3));
 920                 }
 921                 break;
 922         case GDF_32BIT_X888RGB:
 923                 for (i = 0; i < ncolors; i++) {
 924                         cte = img->color_table[i];
 925                         p[i].ce.dw = SWAP32((cte.red << 16) | (cte.green << 8) |
 926                                              cte.blue);
 927                 }
 928                 break;
 929         default:
 930                 printf("RLE Bitmap unsupported in video mode 0x%x\n",
 931                         VIDEO_DATA_FORMAT);
 932                 return -1;
 933         }
 934
 935         while (decode) {
 936                 switch (bm[0]) {
 937                 case 0:
 938                         switch (bm[1]) {
 939                         case 0:
 940                                 /* scan line end marker */
 941                                 bm += 2;
 942                                 x = 0;
 943                                 y--;
 944                                 fbp = (unsigned char *)
 945                                         ((unsigned int)video_fb_address +
 946                                          (((y + yoff) * VIDEO_COLS) +
 947                                           xoff) * bpp);
 948                                 continue;
 949                         case 1:
 950                                 /* end of bitmap data marker */
 951                                 decode = 0;
 952                                 break;
 953                         case 2:
 954                                 /* run offset marker */
 955                                 x += bm[2];
 956                                 y -= bm[3];
 957                                 fbp = (unsigned char *)
 958                                         ((unsigned int)video_fb_address +
 959                                          (((y + yoff) * VIDEO_COLS) +
 960                                           x + xoff) * bpp);
 961                                 bm += 4;
 962                                 break;
 963                         default:
 964                                 /* unencoded run */
 965                                 cnt = bm[1];
 966                                 runlen = cnt;
 967                                 pixels += cnt;
 968                                 if (pixels > limit)
 969                                         goto error;
 970
 971                                 bm += 2;
 972                                 if (y < height) {
 973                                         if (x >= width) {
 974                                                 x += runlen;
 975                                                 goto next_run;
 976                                         }
 977                                         if (x + runlen > width)
 978                                                 cnt = width - x;
 979                                         draw_bitmap (&fbp, bm, p, cnt, 0);
 980                                         x += runlen;
 981                                 }
 982 next_run:
 983                                 bm += runlen;
 984                                 if (runlen & 1)
 985                                         bm++; /* 0 padding if length is odd */
 986                         }
 987                         break;
 988                 default:
 989                         /* encoded run */
 990                         cnt = bm[0];
 991                         runlen = cnt;
 992                         pixels += cnt;
 993                         if (pixels > limit)
 994                                 goto error;
 995
 996                         if (y < height) { /* only draw into visible area */
 997                                 if (x >= width) {
 998                                         x += runlen;
 999                                         bm += 2;
1000                                         continue;
1001                                 }
1002                                 if (x + runlen > width)
1003                                         cnt = width - x;
1004                                 draw_bitmap (&fbp, bm, p, cnt, 1);
1005                                 x += runlen;
1006                         }
1007                         bm += 2;
1008                         break;
1009                 }
1010         }
1011         return 0;
1012 error:
1013         printf("Error: Too much encoded pixel data, validate your bitmap\n");
1014         return -1;
1015 }
1016 #endif
1017
1018 /*
1019  * Display the BMP file located at address bmp_image.
1020  */
1021 int video_display_bitmap (ulong bmp_image, int x, int y)
1022 {
1023         ushort xcount, ycount;
1024         uchar *fb;
1025         bmp_image_t *bmp = (bmp_image_t *) bmp_image;
1026         uchar *bmap;
1027         ushort padded_line;
1028         unsigned long width, height, bpp;
1029         unsigned colors;
1030         unsigned long compression;
1031         bmp_color_table_entry_t cte;
1032 #ifdef CONFIG_VIDEO_BMP_GZIP
1033         unsigned char *dst = NULL;
1034         ulong len;
1035 #endif
1036
1037         WATCHDOG_RESET ();
1038
1039         if (!((bmp->header.signature[0] == 'B') &&
1040               (bmp->header.signature[1] == 'M'))) {
1041
1042 #ifdef CONFIG_VIDEO_BMP_GZIP
1043                 /*
1044                  * Could be a gzipped bmp image, try to decrompress...
1045                  */
1046                 len = CONFIG_SYS_VIDEO_LOGO_MAX_SIZE;
1047                 dst = malloc(CONFIG_SYS_VIDEO_LOGO_MAX_SIZE);
1048                 if (dst == NULL) {
1049                         printf("Error: malloc in gunzip failed!\n");
1050                         return(1);
1051                 }
1052                 if (gunzip(dst, CONFIG_SYS_VIDEO_LOGO_MAX_SIZE, (uchar *)bmp_image, &len) != 0) {
1053                         printf ("Error: no valid bmp or bmp.gz image at %lx\n", bmp_image);
1054                         free(dst);
1055                         return 1;
1056                 }
1057                 if (len == CONFIG_SYS_VIDEO_LOGO_MAX_SIZE) {
1058                         printf("Image could be truncated (increase CONFIG_SYS_VIDEO_LOGO_MAX_SIZE)!\n");
1059                 }
1060
1061                 /*
1062                  * Set addr to decompressed image
1063                  */
1064                 bmp = (bmp_image_t *)dst;
1065
1066                 if (!((bmp->header.signature[0] == 'B') &&
1067                       (bmp->header.signature[1] == 'M'))) {
1068                         printf ("Error: no valid bmp.gz image at %lx\n", bmp_image);
1069                         free(dst);
1070                         return 1;
1071                 }
1072 #else
1073                 printf ("Error: no valid bmp image at %lx\n", bmp_image);
1074                 return 1;
1075 #endif /* CONFIG_VIDEO_BMP_GZIP */
1076         }
1077
1078         width = le32_to_cpu (bmp->header.width);
1079         height = le32_to_cpu (bmp->header.height);
1080         bpp = le16_to_cpu (bmp->header.bit_count);
1081         colors = le32_to_cpu (bmp->header.colors_used);
1082         compression = le32_to_cpu (bmp->header.compression);
1083
1084         debug ("Display-bmp: %d x %d  with %d colors\n",
1085                width, height, colors);
1086
1087         if (compression != BMP_BI_RGB
1088 #ifdef CONFIG_VIDEO_BMP_RLE8
1089             && compression != BMP_BI_RLE8
1090 #endif
1091            ) {
1092                 printf ("Error: compression type %ld not supported\n",
1093                         compression);
1094 #ifdef CONFIG_VIDEO_BMP_GZIP
1095                 if (dst)
1096                         free(dst);
1097 #endif
1098                 return 1;
1099         }
1100
1101         padded_line = (((width * bpp + 7) / 8) + 3) & ~0x3;
1102
1103 #ifdef CONFIG_SPLASH_SCREEN_ALIGN
1104         if (x == BMP_ALIGN_CENTER)
1105                 x = max(0, (VIDEO_VISIBLE_COLS - width) / 2);
1106         else if (x < 0)
1107                 x = max(0, VIDEO_VISIBLE_COLS - width + x + 1);
1108
1109         if (y == BMP_ALIGN_CENTER)
1110                 y = max(0, (VIDEO_VISIBLE_ROWS - height) / 2);
1111         else if (y < 0)
1112                 y = max(0, VIDEO_VISIBLE_ROWS - height + y + 1);
1113 #endif /* CONFIG_SPLASH_SCREEN_ALIGN */
1114
1115         if ((x + width) > VIDEO_VISIBLE_COLS)
1116                 width = VIDEO_VISIBLE_COLS - x;
1117         if ((y + height) > VIDEO_VISIBLE_ROWS)
1118                 height = VIDEO_VISIBLE_ROWS - y;
1119
1120         bmap = (uchar *) bmp + le32_to_cpu (bmp->header.data_offset);
1121         fb = (uchar *) (video_fb_address +
1122                         ((y + height - 1) * VIDEO_COLS * VIDEO_PIXEL_SIZE) +
1123                         x * VIDEO_PIXEL_SIZE);
1124
1125 #ifdef CONFIG_VIDEO_BMP_RLE8
1126         if (compression == BMP_BI_RLE8) {
1127                 return display_rle8_bitmap(bmp,
1128                                            x, y, width, height);
1129         }
1130 #endif
1131
1132         /* We handle only 4, 8, or 24 bpp bitmaps */
1133         switch (le16_to_cpu (bmp->header.bit_count)) {
1134         case 4:
1135                 padded_line -= width / 2;
1136                 ycount = height;
1137
1138                 switch (VIDEO_DATA_FORMAT) {
1139                 case GDF_32BIT_X888RGB:
1140                         while (ycount--) {
1141                                 WATCHDOG_RESET ();
1142                                 /*
1143                                  * Don't assume that 'width' is an
1144                                  * even number
1145                                  */
1146                                 for (xcount = 0; xcount < width; xcount++) {
1147                                         uchar idx;
1148
1149                                         if (xcount & 1) {
1150                                                 idx = *bmap & 0xF;
1151                                                 bmap++;
1152                                         } else
1153                                                 idx = *bmap >> 4;
1154                                         cte = bmp->color_table[idx];
1155                                         FILL_32BIT_X888RGB(cte.red, cte.green,
1156                                                            cte.blue);
1157                                 }
1158                                 bmap += padded_line;
1159                                 fb -= (VIDEO_VISIBLE_COLS + width) *
1160                                       VIDEO_PIXEL_SIZE;
1161                         }
1162                         break;
1163                 default:
1164                         puts("4bpp bitmap unsupported with current "
1165                              "video mode\n");
1166                         break;
1167                 }
1168                 break;
1169
1170         case 8:
1171                 padded_line -= width;
1172                 if (VIDEO_DATA_FORMAT == GDF__8BIT_INDEX) {
1173                         /* Copy colormap */
1174                         for (xcount = 0; xcount < colors; ++xcount) {
1175                                 cte = bmp->color_table[xcount];
1176                                 video_set_lut (xcount, cte.red, cte.green, cte.blue);
1177                         }
1178                 }
1179                 ycount = height;
1180                 switch (VIDEO_DATA_FORMAT) {
1181                 case GDF__8BIT_INDEX:
1182                         while (ycount--) {
1183                                 WATCHDOG_RESET ();
1184                                 xcount = width;
1185                                 while (xcount--) {
1186                                         *fb++ = *bmap++;
1187                                 }
1188                                 bmap += padded_line;
1189                                 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1190                         }
1191                         break;
1192                 case GDF__8BIT_332RGB:
1193                         while (ycount--) {
1194                                 WATCHDOG_RESET ();
1195                                 xcount = width;
1196                                 while (xcount--) {
1197                                         cte = bmp->color_table[*bmap++];
1198                                         FILL_8BIT_332RGB (cte.red, cte.green, cte.blue);
1199                                 }
1200                                 bmap += padded_line;
1201                                 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1202                         }
1203                         break;
1204                 case GDF_15BIT_555RGB:
1205                         while (ycount--) {
1206 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1207                                 int xpos = x;
1208 #endif
1209                                 WATCHDOG_RESET ();
1210                                 xcount = width;
1211                                 while (xcount--) {
1212                                         cte = bmp->color_table[*bmap++];
1213 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1214                                         fill_555rgb_pswap (fb, xpos++, cte.red,
1215                                                            cte.green, cte.blue);
1216                                         fb += 2;
1217 #else
1218                                         FILL_15BIT_555RGB (cte.red, cte.green, cte.blue);
1219 #endif
1220                                 }
1221                                 bmap += padded_line;
1222                                 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1223                         }
1224                         break;
1225                 case GDF_16BIT_565RGB:
1226                         while (ycount--) {
1227                                 WATCHDOG_RESET ();
1228                                 xcount = width;
1229                                 while (xcount--) {
1230                                         cte = bmp->color_table[*bmap++];
1231                                         FILL_16BIT_565RGB (cte.red, cte.green, cte.blue);
1232                                 }
1233                                 bmap += padded_line;
1234                                 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1235                         }
1236                         break;
1237                 case GDF_32BIT_X888RGB:
1238                         while (ycount--) {
1239                                 WATCHDOG_RESET ();
1240                                 xcount = width;
1241                                 while (xcount--) {
1242                                         cte = bmp->color_table[*bmap++];
1243                                         FILL_32BIT_X888RGB (cte.red, cte.green, cte.blue);
1244                                 }
1245                                 bmap += padded_line;
1246                                 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1247                         }
1248                         break;
1249                 case GDF_24BIT_888RGB:
1250                         while (ycount--) {
1251                                 WATCHDOG_RESET ();
1252                                 xcount = width;
1253                                 while (xcount--) {
1254                                         cte = bmp->color_table[*bmap++];
1255                                         FILL_24BIT_888RGB (cte.red, cte.green, cte.blue);
1256                                 }
1257                                 bmap += padded_line;
1258                                 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1259                         }
1260                         break;
1261                 }
1262                 break;
1263         case 24:
1264                 padded_line -= 3 * width;
1265                 ycount = height;
1266                 switch (VIDEO_DATA_FORMAT) {
1267                 case GDF__8BIT_332RGB:
1268                         while (ycount--) {
1269                                 WATCHDOG_RESET ();
1270                                 xcount = width;
1271                                 while (xcount--) {
1272                                         FILL_8BIT_332RGB (bmap[2], bmap[1], bmap[0]);
1273                                         bmap += 3;
1274                                 }
1275                                 bmap += padded_line;
1276                                 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1277                         }
1278                         break;
1279                 case GDF_15BIT_555RGB:
1280                         while (ycount--) {
1281 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1282                                 int xpos = x;
1283 #endif
1284                                 WATCHDOG_RESET ();
1285                                 xcount = width;
1286                                 while (xcount--) {
1287 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1288                                         fill_555rgb_pswap (fb, xpos++, bmap[2],
1289                                                            bmap[1], bmap[0]);
1290                                         fb += 2;
1291 #else
1292                                         FILL_15BIT_555RGB (bmap[2], bmap[1], bmap[0]);
1293 #endif
1294                                         bmap += 3;
1295                                 }
1296                                 bmap += padded_line;
1297                                 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1298                         }
1299                         break;
1300                 case GDF_16BIT_565RGB:
1301                         while (ycount--) {
1302                                 WATCHDOG_RESET ();
1303                                 xcount = width;
1304                                 while (xcount--) {
1305                                         FILL_16BIT_565RGB (bmap[2], bmap[1], bmap[0]);
1306                                         bmap += 3;
1307                                 }
1308                                 bmap += padded_line;
1309                                 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1310                         }
1311                         break;
1312                 case GDF_32BIT_X888RGB:
1313                         while (ycount--) {
1314                                 WATCHDOG_RESET ();
1315                                 xcount = width;
1316                                 while (xcount--) {
1317                                         FILL_32BIT_X888RGB (bmap[2], bmap[1], bmap[0]);
1318                                         bmap += 3;
1319                                 }
1320                                 bmap += padded_line;
1321                                 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1322                         }
1323                         break;
1324                 case GDF_24BIT_888RGB:
1325                         while (ycount--) {
1326                                 WATCHDOG_RESET ();
1327                                 xcount = width;
1328                                 while (xcount--) {
1329                                         FILL_24BIT_888RGB (bmap[2], bmap[1], bmap[0]);
1330                                         bmap += 3;
1331                                 }
1332                                 bmap += padded_line;
1333                                 fb -= (VIDEO_VISIBLE_COLS + width) * VIDEO_PIXEL_SIZE;
1334                         }
1335                         break;
1336                 default:
1337                         printf ("Error: 24 bits/pixel bitmap incompatible with current video mode\n");
1338                         break;
1339                 }
1340                 break;
1341         default:
1342                 printf ("Error: %d bit/pixel bitmaps not supported by U-Boot\n",
1343                         le16_to_cpu (bmp->header.bit_count));
1344                 break;
1345         }
1346
1347 #ifdef CONFIG_VIDEO_BMP_GZIP
1348         if (dst) {
1349                 free(dst);
1350         }
1351 #endif
1352
1353         return (0);
1354 }
1355 #endif
1356
1357 /*****************************************************************************/
1358
1359 #ifdef CONFIG_VIDEO_LOGO
1360 void logo_plot (void *screen, int width, int x, int y)
1361 {
1362
1363         int xcount, i;
1364         int skip   = (width - VIDEO_LOGO_WIDTH) * VIDEO_PIXEL_SIZE;
1365         int ycount = video_logo_height;
1366         unsigned char r, g, b, *logo_red, *logo_blue, *logo_green;
1367         unsigned char *source;
1368         unsigned char *dest = (unsigned char *)screen +
1369                               ((y * width * VIDEO_PIXEL_SIZE) +
1370                                x * VIDEO_PIXEL_SIZE);
1371
1372 #ifdef CONFIG_VIDEO_BMP_LOGO
1373         source = bmp_logo_bitmap;
1374
1375         /* Allocate temporary space for computing colormap */
1376         logo_red = malloc (BMP_LOGO_COLORS);
1377         logo_green = malloc (BMP_LOGO_COLORS);
1378         logo_blue = malloc (BMP_LOGO_COLORS);
1379         /* Compute color map */
1380         for (i = 0; i < VIDEO_LOGO_COLORS; i++) {
1381                 logo_red[i] = (bmp_logo_palette[i] & 0x0f00) >> 4;
1382                 logo_green[i] = (bmp_logo_palette[i] & 0x00f0);
1383                 logo_blue[i] = (bmp_logo_palette[i] & 0x000f) << 4;
1384         }
1385 #else
1386         source = linux_logo;
1387         logo_red = linux_logo_red;
1388         logo_green = linux_logo_green;
1389         logo_blue = linux_logo_blue;
1390 #endif
1391
1392         if (VIDEO_DATA_FORMAT == GDF__8BIT_INDEX) {
1393                 for (i = 0; i < VIDEO_LOGO_COLORS; i++) {
1394                         video_set_lut (i + VIDEO_LOGO_LUT_OFFSET,
1395                                        logo_red[i], logo_green[i], logo_blue[i]);
1396                 }
1397         }
1398
1399         while (ycount--) {
1400 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1401                 int xpos = x;
1402 #endif
1403                 xcount = VIDEO_LOGO_WIDTH;
1404                 while (xcount--) {
1405                         r = logo_red[*source - VIDEO_LOGO_LUT_OFFSET];
1406                         g = logo_green[*source - VIDEO_LOGO_LUT_OFFSET];
1407                         b = logo_blue[*source - VIDEO_LOGO_LUT_OFFSET];
1408
1409                         switch (VIDEO_DATA_FORMAT) {
1410                         case GDF__8BIT_INDEX:
1411                                 *dest = *source;
1412                                 break;
1413                         case GDF__8BIT_332RGB:
1414                                 *dest = ((r >> 5) << 5) | ((g >> 5) << 2) | (b >> 6);
1415                                 break;
1416                         case GDF_15BIT_555RGB:
1417 #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1418                                 fill_555rgb_pswap (dest, xpos++, r, g, b);
1419 #else
1420                                 *(unsigned short *) dest =
1421                                         SWAP16 ((unsigned short) (((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3)));
1422 #endif
1423                                 break;
1424                         case GDF_16BIT_565RGB:
1425                                 *(unsigned short *) dest =
1426                                         SWAP16 ((unsigned short) (((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3)));
1427                                 break;
1428                         case GDF_32BIT_X888RGB:
1429                                 *(unsigned long *) dest =
1430                                         SWAP32 ((unsigned long) ((r << 16) | (g << 8) | b));
1431                                 break;
1432                         case GDF_24BIT_888RGB:
1433 #ifdef VIDEO_FB_LITTLE_ENDIAN
1434                                 dest[0] = b;
1435                                 dest[1] = g;
1436                                 dest[2] = r;
1437 #else
1438                                 dest[0] = r;
1439                                 dest[1] = g;
1440                                 dest[2] = b;
1441 #endif
1442                                 break;
1443                         }
1444                         source++;
1445                         dest += VIDEO_PIXEL_SIZE;
1446                 }
1447                 dest += skip;
1448         }
1449 #ifdef CONFIG_VIDEO_BMP_LOGO
1450         free (logo_red);
1451         free (logo_green);
1452         free (logo_blue);
1453 #endif
1454 }
1455
1456 /*****************************************************************************/
1457
1458 static void *video_logo (void)
1459 {
1460         char info[128];
1461         extern char version_string;
1462         int space, len, y_off = 0;
1463
1464 #ifdef CONFIG_SPLASH_SCREEN
1465         char *s;
1466         ulong addr;
1467
1468         if ((s = getenv ("splashimage")) != NULL) {
1469                 int x = 0, y = 0;
1470
1471                 addr = simple_strtoul (s, NULL, 16);
1472 #ifdef CONFIG_SPLASH_SCREEN_ALIGN
1473                 if ((s = getenv ("splashpos")) != NULL) {
1474                         if (s[0] == 'm')
1475                                 x = BMP_ALIGN_CENTER;
1476                         else
1477                                 x = simple_strtol (s, NULL, 0);
1478
1479                         if ((s = strchr (s + 1, ',')) != NULL) {
1480                                 if (s[1] == 'm')
1481                                         y = BMP_ALIGN_CENTER;
1482                                 else
1483                                         y = simple_strtol (s + 1, NULL, 0);
1484                         }
1485                 }
1486 #endif /* CONFIG_SPLASH_SCREEN_ALIGN */
1487
1488                 if (video_display_bitmap (addr, x, y) == 0) {
1489                         video_logo_height = 0;
1490                         return ((void *) (video_fb_address));
1491                 }
1492         }
1493 #endif /* CONFIG_SPLASH_SCREEN */
1494
1495         logo_plot (video_fb_address, VIDEO_COLS, 0, 0);
1496
1497         sprintf (info, " %s", &version_string);
1498
1499         space = (VIDEO_LINE_LEN / 2 - VIDEO_INFO_X) / VIDEO_FONT_WIDTH;
1500         len = strlen(info);
1501
1502         if (len > space) {
1503                 video_drawchars (VIDEO_INFO_X, VIDEO_INFO_Y,
1504                                  (uchar *)info, space);
1505                 video_drawchars (VIDEO_INFO_X + VIDEO_FONT_WIDTH,
1506                                  VIDEO_INFO_Y + VIDEO_FONT_HEIGHT,
1507                                  (uchar *)info + space, len - space);
1508                 y_off = 1;
1509         } else
1510                 video_drawstring (VIDEO_INFO_X, VIDEO_INFO_Y, (uchar *)info);
1511
1512 #ifdef CONFIG_CONSOLE_EXTRA_INFO
1513         {
1514                 int i, n = ((video_logo_height - VIDEO_FONT_HEIGHT) / VIDEO_FONT_HEIGHT);
1515
1516                 for (i = 1; i < n; i++) {
1517                         video_get_info_str (i, info);
1518                         if (!*info)
1519                                 continue;
1520
1521                         len = strlen(info);
1522                         if (len > space) {
1523                                 video_drawchars (VIDEO_INFO_X,
1524                                                  VIDEO_INFO_Y +
1525                                                  (i + y_off) * VIDEO_FONT_HEIGHT,
1526                                                  (uchar *)info, space);
1527                                 y_off++;
1528                                 video_drawchars (VIDEO_INFO_X + VIDEO_FONT_WIDTH,
1529                                                  VIDEO_INFO_Y +
1530                                                  (i + y_off) * VIDEO_FONT_HEIGHT,
1531                                                  (uchar *)info + space,
1532                                                  len - space);
1533                         } else {
1534                                 video_drawstring (VIDEO_INFO_X,
1535                                                   VIDEO_INFO_Y +
1536                                                   (i + y_off) * VIDEO_FONT_HEIGHT,
1537                                                   (uchar *)info);
1538                         }
1539                 }
1540         }
1541 #endif
1542
1543         return (video_fb_address + video_logo_height * VIDEO_LINE_LEN);
1544 }
1545 #endif
1546
1547
1548 /*****************************************************************************/
1549
1550 static int video_init (void)
1551 {
1552         unsigned char color8;
1553
1554         if ((pGD = video_hw_init ()) == NULL)
1555                 return -1;
1556
1557         video_fb_address = (void *) VIDEO_FB_ADRS;
1558 #ifdef CONFIG_VIDEO_HW_CURSOR
1559         video_init_hw_cursor (VIDEO_FONT_WIDTH, VIDEO_FONT_HEIGHT);
1560 #endif
1561
1562         /* Init drawing pats */
1563         switch (VIDEO_DATA_FORMAT) {
1564         case GDF__8BIT_INDEX:
1565                 video_set_lut (0x01, CONSOLE_FG_COL, CONSOLE_FG_COL, CONSOLE_FG_COL);
1566                 video_set_lut (0x00, CONSOLE_BG_COL, CONSOLE_BG_COL, CONSOLE_BG_COL);
1567                 fgx = 0x01010101;
1568                 bgx = 0x00000000;
1569                 break;
1570         case GDF__8BIT_332RGB:
1571                 color8 = ((CONSOLE_FG_COL & 0xe0) |
1572                           ((CONSOLE_FG_COL >> 3) & 0x1c) | CONSOLE_FG_COL >> 6);
1573                 fgx = (color8 << 24) | (color8 << 16) | (color8 << 8) | color8;
1574                 color8 = ((CONSOLE_BG_COL & 0xe0) |
1575                           ((CONSOLE_BG_COL >> 3) & 0x1c) | CONSOLE_BG_COL >> 6);
1576                 bgx = (color8 << 24) | (color8 << 16) | (color8 << 8) | color8;
1577                 break;
1578         case GDF_15BIT_555RGB:
1579                 fgx = (((CONSOLE_FG_COL >> 3) << 26) |
1580                        ((CONSOLE_FG_COL >> 3) << 21) | ((CONSOLE_FG_COL >> 3) << 16) |
1581                        ((CONSOLE_FG_COL >> 3) << 10) | ((CONSOLE_FG_COL >> 3) << 5) |
1582                        (CONSOLE_FG_COL >> 3));
1583                 bgx = (((CONSOLE_BG_COL >> 3) << 26) |
1584                        ((CONSOLE_BG_COL >> 3) << 21) | ((CONSOLE_BG_COL >> 3) << 16) |
1585                        ((CONSOLE_BG_COL >> 3) << 10) | ((CONSOLE_BG_COL >> 3) << 5) |
1586                        (CONSOLE_BG_COL >> 3));
1587                 break;
1588         case GDF_16BIT_565RGB:
1589                 fgx = (((CONSOLE_FG_COL >> 3) << 27) |
1590                        ((CONSOLE_FG_COL >> 2) << 21) | ((CONSOLE_FG_COL >> 3) << 16) |
1591                        ((CONSOLE_FG_COL >> 3) << 11) | ((CONSOLE_FG_COL >> 2) << 5) |
1592                        (CONSOLE_FG_COL >> 3));
1593                 bgx = (((CONSOLE_BG_COL >> 3) << 27) |
1594                        ((CONSOLE_BG_COL >> 2) << 21) | ((CONSOLE_BG_COL >> 3) << 16) |
1595                        ((CONSOLE_BG_COL >> 3) << 11) | ((CONSOLE_BG_COL >> 2) << 5) |
1596                        (CONSOLE_BG_COL >> 3));
1597                 break;
1598         case GDF_32BIT_X888RGB:
1599                 fgx = (CONSOLE_FG_COL << 16) | (CONSOLE_FG_COL << 8) | CONSOLE_FG_COL;
1600                 bgx = (CONSOLE_BG_COL << 16) | (CONSOLE_BG_COL << 8) | CONSOLE_BG_COL;
1601                 break;
1602         case GDF_24BIT_888RGB:
1603                 fgx = (CONSOLE_FG_COL << 24) | (CONSOLE_FG_COL << 16) |
1604                         (CONSOLE_FG_COL << 8) | CONSOLE_FG_COL;
1605                 bgx = (CONSOLE_BG_COL << 24) | (CONSOLE_BG_COL << 16) |
1606                         (CONSOLE_BG_COL << 8) | CONSOLE_BG_COL;
1607                 break;
1608         }
1609         eorx = fgx ^ bgx;
1610
1611 #ifdef CONFIG_VIDEO_LOGO
1612         /* Plot the logo and get start point of console */
1613         PRINTD ("Video: Drawing the logo ...\n");
1614         video_console_address = video_logo ();
1615 #else
1616         video_console_address = video_fb_address;
1617 #endif
1618
1619         /* Initialize the console */
1620         console_col = 0;
1621         console_row = 0;
1622
1623         return 0;
1624 }
1625
1626
1627 /*****************************************************************************/
1628
1629 /*
1630  * Implement a weak default function for boards that optionally
1631  * need to skip the video initialization.
1632  */
1633 int __board_video_skip(void)
1634 {
1635         /* As default, don't skip test */
1636         return 0;
1637 }
1638 int board_video_skip(void) __attribute__((weak, alias("__board_video_skip")));
1639
1640 int drv_video_init (void)
1641 {
1642         int skip_dev_init;
1643         struct stdio_dev console_dev;
1644
1645         /* Check if video initialization should be skipped */
1646         if (board_video_skip())
1647                 return 0;
1648
1649         /* Init video chip - returns with framebuffer cleared */
1650         skip_dev_init = (video_init () == -1);
1651
1652 #if !defined(CONFIG_VGA_AS_SINGLE_DEVICE)
1653         PRINTD ("KBD: Keyboard init ...\n");
1654         skip_dev_init |= (VIDEO_KBD_INIT_FCT == -1);
1655 #endif
1656
1657         if (skip_dev_init)
1658                 return 0;
1659
1660         /* Init vga device */
1661         memset (&console_dev, 0, sizeof (console_dev));
1662         strcpy (console_dev.name, "vga");
1663         console_dev.ext = DEV_EXT_VIDEO;        /* Video extensions */
1664         console_dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_SYSTEM;
1665         console_dev.putc = video_putc;  /* 'putc' function */
1666         console_dev.puts = video_puts;  /* 'puts' function */
1667         console_dev.tstc = NULL;        /* 'tstc' function */
1668         console_dev.getc = NULL;        /* 'getc' function */
1669
1670 #if !defined(CONFIG_VGA_AS_SINGLE_DEVICE)
1671         /* Also init console device */
1672         console_dev.flags |= DEV_FLAGS_INPUT;
1673         console_dev.tstc = VIDEO_TSTC_FCT;      /* 'tstc' function */
1674         console_dev.getc = VIDEO_GETC_FCT;      /* 'getc' function */
1675 #endif /* CONFIG_VGA_AS_SINGLE_DEVICE */
1676
1677         if (stdio_register (&console_dev) != 0)
1678                 return 0;
1679
1680         /* Return success */
1681         return 1;
1682 }