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