drivers/video/cfb_console.c

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