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