cpu/mpc8xx/lcd.c

   1 /*
   2  * (C) Copyright 2001-2002
   3  * Wolfgang Denk, DENX Software Engineering -- wd@denx.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 /* ** HEADER FILES                                                      */
  26 /************************************************************************/
  27
  28 /* #define DEBUG */
  29
  30 #include <config.h>
  31 #include <common.h>
  32 #include <watchdog.h>
  33 #include <version.h>
  34 #include <stdarg.h>
  35 #include <lcdvideo.h>
  36 #include <linux/types.h>
  37 #include <devices.h>
  38 #if defined(CONFIG_POST)
  39 #include <post.h>
  40 #endif
  41 #include <lcd.h>
  42
  43 #ifdef CONFIG_LCD
  44
  45 /************************************************************************/
  46 /* ** CONFIG STUFF -- should be moved to board config file              */
  47 /************************************************************************/
  48 #define CONFIG_LCD_LOGO
  49 #define LCD_INFO                /* Display Logo, (C) and system info    */
  50
  51 #if defined(CONFIG_V37) || defined(CONFIG_EDT32F10)
  52 #undef CONFIG_LCD_LOGO
  53 #undef LCD_INFO
  54 #endif
  55
  56 /* #define LCD_TEST_PATTERN */  /* color backgnd for frame/color adjust */
  57 /* #define CFG_INVERT_COLORS */ /* Not needed - adjust vl_dp instead    */
  58 /************************************************************************/
  59
  60 /************************************************************************/
  61 /* ** BITMAP DISPLAY SUPPORT  -- should probably be moved elsewhere     */
  62 /************************************************************************/
  63
  64 #if (CONFIG_COMMANDS & CFG_CMD_BMP)
  65 #include <bmp_layout.h>
  66 #endif /* (CONFIG_COMMANDS & CFG_CMD_BMP) */
  67
  68 /************************************************************************/
  69 /* ** FONT AND LOGO DATA                                                */
  70 /************************************************************************/
  71
  72 #include <video_font.h>         /* Get font data, width and height      */
  73
  74 #ifdef CONFIG_LCD_LOGO
  75 # include <bmp_logo.h>          /* Get logo data, width and height      */
  76 #endif
  77
  78 /************************************************************************/
  79 /************************************************************************/
  80
  81 /*
  82  *  Information about displays we are using.  This is for configuring
  83  *  the LCD controller and memory allocation.  Someone has to know what
  84  *  is connected, as we can't autodetect anything.
  85  */
  86 #define CFG_HIGH        0       /* Pins are active high */
  87 #define CFG_LOW         1       /* Pins are active low */
  88
  89 typedef struct vidinfo {
  90     ushort      vl_col;         /* Number of columns (i.e. 640) */
  91     ushort      vl_row;         /* Number of rows (i.e. 480) */
  92     ushort      vl_width;       /* Width of display area in millimeters */
  93     ushort      vl_height;      /* Height of display area in millimeters */
  94
  95     /* LCD configuration register.
  96     */
  97     u_char      vl_clkp;        /* Clock polarity */
  98     u_char      vl_oep;         /* Output Enable polarity */
  99     u_char      vl_hsp;         /* Horizontal Sync polarity */
 100     u_char      vl_vsp;         /* Vertical Sync polarity */
 101     u_char      vl_dp;          /* Data polarity */
 102     u_char      vl_bpix;        /* Bits per pixel, 0 = 1, 1 = 2, 2 = 4, 3 = 8 */
 103     u_char      vl_lbw;         /* LCD Bus width, 0 = 4, 1 = 8 */
 104     u_char      vl_splt;        /* Split display, 0 = single-scan, 1 = dual-scan */
 105     u_char      vl_clor;        /* Color, 0 = mono, 1 = color */
 106     u_char      vl_tft;         /* 0 = passive, 1 = TFT */
 107
 108     /* Horizontal control register.  Timing from data sheet.
 109     */
 110     ushort      vl_wbl;         /* Wait between lines */
 111
 112     /* Vertical control register.
 113     */
 114     u_char      vl_vpw;         /* Vertical sync pulse width */
 115     u_char      vl_lcdac;       /* LCD AC timing */
 116     u_char      vl_wbf;         /* Wait between frames */
 117 } vidinfo_t;
 118
 119 #define LCD_MONOCHROME  0
 120 #define LCD_COLOR2      1
 121 #define LCD_COLOR4      2
 122 #define LCD_COLOR8      3
 123
 124 /*----------------------------------------------------------------------*/
 125 #ifdef CONFIG_KYOCERA_KCS057QV1AJ
 126 /*
 127  *  Kyocera KCS057QV1AJ-G23. Passive, color, single scan.
 128  */
 129 #define LCD_BPP LCD_COLOR4
 130
 131 static vidinfo_t panel_info = {
 132     640, 480, 132, 99, CFG_HIGH, CFG_HIGH, CFG_HIGH, CFG_HIGH, CFG_HIGH,
 133     LCD_BPP, 1, 0, 1, 0,  5, 0, 0, 0
 134                 /* wbl, vpw, lcdac, wbf */
 135 };
 136 #endif /* CONFIG_KYOCERA_KCS057QV1AJ */
 137 /*----------------------------------------------------------------------*/
 138
 139 /*----------------------------------------------------------------------*/
 140 #ifdef CONFIG_HITACHI_SP19X001_Z1A
 141 /*
 142  *  Hitachi SP19X001-. Active, color, single scan.
 143  */
 144 static vidinfo_t panel_info = {
 145     640, 480, 154, 116, CFG_HIGH, CFG_HIGH, CFG_HIGH, CFG_HIGH, CFG_HIGH,
 146     LCD_COLOR8, 1, 0, 1, 0, 0, 0, 0, 0
 147                 /* wbl, vpw, lcdac, wbf */
 148 };
 149 #endif /* CONFIG_HITACHI_SP19X001_Z1A */
 150 /*----------------------------------------------------------------------*/
 151
 152 /*----------------------------------------------------------------------*/
 153 #ifdef CONFIG_NEC_NL6648AC33
 154 /*
 155  *  NEC NL6648AC33-18. Active, color, single scan.
 156  */
 157 static vidinfo_t panel_info = {
 158     640, 480, 132, 99, CFG_HIGH, CFG_HIGH, CFG_LOW, CFG_LOW, CFG_HIGH,
 159     3, 0, 0, 1, 1, 144, 2, 0, 33
 160                 /* wbl, vpw, lcdac, wbf */
 161 };
 162 #endif /* CONFIG_NEC_NL6648AC33 */
 163 /*----------------------------------------------------------------------*/
 164
 165 #ifdef CONFIG_NEC_NL6648BC20
 166 /*
 167  *  NEC NL6648BC20-08. 6.5", 640x480. Active, color, single scan.
 168  */
 169 static vidinfo_t panel_info = {
 170     640, 480, 132, 99, CFG_HIGH, CFG_HIGH, CFG_LOW, CFG_LOW, CFG_HIGH,
 171     3, 0, 0, 1, 1, 144, 2, 0, 33
 172                 /* wbl, vpw, lcdac, wbf */
 173 };
 174 #endif /* CONFIG_NEC_NL6648BC20 */
 175 /*----------------------------------------------------------------------*/
 176
 177 #ifdef CONFIG_SHARP_LQ104V7DS01
 178 /*
 179  *  SHARP LQ104V7DS01. 6.5", 640x480. Active, color, single scan.
 180  */
 181 static vidinfo_t panel_info = {
 182     640, 480, 132, 99, CFG_HIGH, CFG_HIGH, CFG_LOW, CFG_LOW, CFG_LOW,
 183     3, 0, 0, 1, 1, 25, 1, 0, 33
 184                 /* wbl, vpw, lcdac, wbf */
 185 };
 186 #endif /* CONFIG_SHARP_LQ104V7DS01 */
 187 /*----------------------------------------------------------------------*/
 188
 189 #ifdef CONFIG_SHARP_16x9
 190 /*
 191  * Sharp 320x240. Active, color, single scan.  It isn't 16x9, and I am
 192  * not sure what it is.......
 193  */
 194 static vidinfo_t panel_info = {
 195     320, 240, 0, 0, CFG_HIGH, CFG_HIGH, CFG_HIGH, CFG_HIGH, CFG_HIGH,
 196     3, 0, 0, 1, 1, 15, 4, 0, 3
 197 };
 198 #endif /* CONFIG_SHARP_16x9 */
 199 /*----------------------------------------------------------------------*/
 200
 201 #ifdef CONFIG_SHARP_LQ057Q3DC02
 202 /*
 203  * Sharp LQ057Q3DC02 display. Active, color, single scan.
 204  */
 205 #define LCD_DF 12
 206
 207 static vidinfo_t panel_info = {
 208     320, 240, 0, 0, CFG_HIGH, CFG_HIGH, CFG_LOW, CFG_LOW, CFG_HIGH,
 209     3, 0, 0, 1, 1, 15, 4, 0, 3
 210                 /* wbl, vpw, lcdac, wbf */
 211 };
 212 #define LCD_INFO_BELOW_LOGO
 213 #endif /* CONFIG_SHARP_LQ057Q3DC02 */
 214 /*----------------------------------------------------------------------*/
 215
 216 #ifdef CONFIG_SHARP_LQ64D341
 217 /*
 218  * Sharp LQ64D341 display, 640x480. Active, color, single scan.
 219  */
 220 static vidinfo_t panel_info = {
 221     640, 480, 0, 0, CFG_HIGH, CFG_HIGH, CFG_LOW, CFG_LOW, CFG_HIGH,
 222     3, 0, 0, 1, 1, 128, 16, 0, 32
 223                 /* wbl, vpw, lcdac, wbf */
 224 };
 225 #endif /* CONFIG_SHARP_LQ64D341 */
 226
 227 #ifdef CONFIG_SHARP_LQ084V1DG21
 228 /*
 229  * Sharp LQ084V1DG21 display, 640x480. Active, color, single scan.
 230  */
 231 static vidinfo_t panel_info = {
 232     640, 480, 171, 129, CFG_HIGH, CFG_HIGH, CFG_LOW, CFG_LOW, CFG_LOW,
 233     3, 0, 0, 1, 1, 160, 3, 0, 48
 234                 /* wbl, vpw, lcdac, wbf */
 235 };
 236 #endif /* CONFIG_SHARP_LQ084V1DG21 */
 237
 238 /*----------------------------------------------------------------------*/
 239
 240 #ifdef CONFIG_HLD1045
 241 /*
 242  * HLD1045 display, 640x480. Active, color, single scan.
 243  */
 244 static vidinfo_t panel_info = {
 245     640, 480, 0, 0, CFG_HIGH, CFG_HIGH, CFG_LOW, CFG_LOW, CFG_HIGH,
 246     3, 0, 0, 1, 1, 160, 3, 0, 48
 247                 /* wbl, vpw, lcdac, wbf */
 248 };
 249 #endif /* CONFIG_HLD1045 */
 250 /*----------------------------------------------------------------------*/
 251
 252 #ifdef CONFIG_PRIMEVIEW_V16C6448AC
 253 /*
 254  * Prime View V16C6448AC
 255  */
 256 static vidinfo_t panel_info = {
 257     640, 480, 130, 98, CFG_HIGH, CFG_HIGH, CFG_LOW, CFG_LOW, CFG_HIGH,
 258     3, 0, 0, 1, 1, 144, 2, 0, 35
 259                 /* wbl, vpw, lcdac, wbf */
 260 };
 261 #endif /* CONFIG_PRIMEVIEW_V16C6448AC */
 262
 263 /*----------------------------------------------------------------------*/
 264
 265 #ifdef CONFIG_OPTREX_BW
 266 /*
 267  * Optrex   CBL50840-2 NF-FW 99 22 M5
 268  * or
 269  * Hitachi  LMG6912RPFC-00T
 270  * or
 271  * Hitachi  SP14Q002
 272  *
 273  * 320x240. Black & white.
 274  */
 275 #define OPTREX_BPP      0       /* 0 - monochrome,     1 bpp */
 276                                 /* 1 -  4 grey levels, 2 bpp */
 277                                 /* 2 - 16 grey levels, 4 bpp */
 278 static vidinfo_t panel_info = {
 279     320, 240, 0, 0, CFG_HIGH, CFG_HIGH, CFG_HIGH, CFG_HIGH, CFG_LOW,
 280     OPTREX_BPP, 0, 0, 0, 0, 0, 0, 0, 0, 4
 281 };
 282 #endif /* CONFIG_OPTREX_BW */
 283
 284 /*-----------------------------------------------------------------*/
 285 #ifdef CONFIG_EDT32F10
 286 /*
 287  * Emerging Display Technologies 320x240. Passive, monochrome, single scan.
 288  */
 289 #define LCD_BPP         LCD_MONOCHROME
 290 #define LCD_DF          10
 291
 292 static vidinfo_t panel_info = {
 293     320, 240, 0, 0, CFG_HIGH, CFG_HIGH, CFG_HIGH, CFG_HIGH, CFG_LOW,
 294     LCD_BPP,  0, 0, 0, 0, 33, 0, 0, 0
 295 };
 296 #endif
 297 /*----------------------------------------------------------------------*/
 298
 299 #if defined(LCD_INFO_BELOW_LOGO)
 300 # define LCD_INFO_X             0
 301 # define LCD_INFO_Y             (BMP_LOGO_HEIGHT + VIDEO_FONT_HEIGHT)
 302 #elif defined(CONFIG_LCD_LOGO)
 303 # define LCD_INFO_X             (BMP_LOGO_WIDTH + 4 * VIDEO_FONT_WIDTH)
 304 # define LCD_INFO_Y             (VIDEO_FONT_HEIGHT)
 305 #else
 306 # define LCD_INFO_X             (VIDEO_FONT_WIDTH)
 307 # define LCD_INFO_Y             (VIDEO_FONT_HEIGHT)
 308 #endif
 309
 310 #ifndef LCD_BPP
 311 #define LCD_BPP                 LCD_COLOR8
 312 #endif
 313 #ifndef LCD_DF
 314 #define LCD_DF                  1
 315 #endif
 316
 317 #define NBITS(bit_code)         (1 << (bit_code))
 318 #define NCOLORS(bit_code)       (1 << NBITS(bit_code))
 319
 320 static int lcd_line_length;
 321
 322 static int lcd_color_fg;
 323 static int lcd_color_bg;
 324
 325 char lcd_is_enabled = 0;                /* Indicate that LCD is enabled */
 326
 327 /*
 328  * Frame buffer memory information
 329  */
 330 static void *lcd_base;                  /* Start of framebuffer memory  */
 331 static void *lcd_console_address;       /* Start of console buffer      */
 332
 333
 334 /************************************************************************/
 335 /* ** CONSOLE CONSTANTS                                                 */
 336 /************************************************************************/
 337
 338 #if LCD_BPP == LCD_MONOCHROME
 339
 340 /*
 341  * Simple color definitions
 342  */
 343 #define CONSOLE_COLOR_BLACK      0
 344 #define CONSOLE_COLOR_WHITE      1      /* Must remain last / highest */
 345
 346 #else
 347
 348 /*
 349  * Simple color definitions
 350  */
 351 #define CONSOLE_COLOR_BLACK      0
 352 #define CONSOLE_COLOR_RED        1
 353 #define CONSOLE_COLOR_GREEN      2
 354 #define CONSOLE_COLOR_YELLOW     3
 355 #define CONSOLE_COLOR_BLUE       4
 356 #define CONSOLE_COLOR_MAGENTA    5
 357 #define CONSOLE_COLOR_CYAN       6
 358 #define CONSOLE_COLOR_GREY      14
 359 #define CONSOLE_COLOR_WHITE     15      /* Must remain last / highest */
 360
 361 #endif
 362
 363 #if defined(CONFIG_LCD_LOGO) && (CONSOLE_COLOR_WHITE >= BMP_LOGO_OFFSET)
 364 #error Default Color Map overlaps with Logo Color Map
 365 #endif
 366
 367 /************************************************************************/
 368
 369 #ifndef PAGE_SIZE
 370 #define PAGE_SIZE       4096
 371 #endif
 372
 373
 374 /************************************************************************/
 375 /* ** CONSOLE DEFINITIONS & FUNCTIONS                                   */
 376 /************************************************************************/
 377
 378 #if defined(CONFIG_LCD_LOGO) && !defined(LCD_INFO_BELOW_LOGO)
 379 #define CONSOLE_ROWS            ((panel_info.vl_row-BMP_LOGO_HEIGHT) \
 380                                         / VIDEO_FONT_HEIGHT)
 381 #else
 382 #define CONSOLE_ROWS            (panel_info.vl_row / VIDEO_FONT_HEIGHT)
 383 #endif
 384 #define CONSOLE_COLS            (panel_info.vl_col / VIDEO_FONT_WIDTH)
 385 #define CONSOLE_ROW_SIZE        (VIDEO_FONT_HEIGHT * lcd_line_length)
 386 #define CONSOLE_ROW_FIRST       (lcd_console_address)
 387 #define CONSOLE_ROW_SECOND      (lcd_console_address + CONSOLE_ROW_SIZE)
 388 #define CONSOLE_ROW_LAST        (lcd_console_address + CONSOLE_SIZE \
 389                                         - CONSOLE_ROW_SIZE)
 390 #define CONSOLE_SIZE            (CONSOLE_ROW_SIZE * CONSOLE_ROWS)
 391 #define CONSOLE_SCROLL_SIZE     (CONSOLE_SIZE - CONSOLE_ROW_SIZE)
 392
 393 #if  LCD_BPP == LCD_MONOCHROME
 394 #define COLOR_MASK(c)           ((c)      | (c) << 1 | (c) << 2 | (c) << 3 | \
 395                                  (c) << 4 | (c) << 5 | (c) << 6 | (c) << 7)
 396 #elif LCD_BPP == LCD_COLOR8
 397 #define COLOR_MASK(c)           (c)
 398 #else
 399 #error Unsupported LCD BPP.
 400 #endif
 401
 402 static short console_col;
 403 static short console_row;
 404
 405 /************************************************************************/
 406
 407 ulong   lcd_setmem (ulong addr);
 408
 409 static void     lcd_drawchars  (ushort x, ushort y, uchar *str, int count);
 410 static inline void lcd_puts_xy (ushort x, ushort y, uchar *s);
 411 static inline void lcd_putc_xy (ushort x, ushort y, uchar  c);
 412
 413 int     lcd_init (void *lcdbase);
 414
 415 static void     lcd_ctrl_init (void *lcdbase);
 416 static void     lcd_enable (void);
 417 static void    *lcd_logo (void);
 418 #if LCD_BPP == LCD_COLOR8
 419 static void     lcd_setcolreg (ushort regno,
 420                                 ushort red, ushort green, ushort blue);
 421 #endif
 422 #if LCD_BPP == LCD_MONOCHROME
 423 static void     lcd_initcolregs (void);
 424 #endif
 425 static int      lcd_getbgcolor (void);
 426 static void     lcd_setfgcolor (int color);
 427 static void     lcd_setbgcolor (int color);
 428
 429 #if defined(CONFIG_RBC823)
 430 void    lcd_disable (void);
 431 #endif
 432
 433 #ifdef  NOT_USED_SO_FAR
 434 static void     lcd_getcolreg (ushort regno,
 435                                 ushort *red, ushort *green, ushort *blue);
 436 static int      lcd_getfgcolor (void);
 437 #endif  /* NOT_USED_SO_FAR */
 438
 439 /************************************************************************/
 440
 441 /*----------------------------------------------------------------------*/
 442
 443 static void console_scrollup (void)
 444 {
 445 #if 1
 446         /* Copy up rows ignoring the first one */
 447         memcpy (CONSOLE_ROW_FIRST, CONSOLE_ROW_SECOND, CONSOLE_SCROLL_SIZE);
 448
 449         /* Clear the last one */
 450         memset (CONSOLE_ROW_LAST, COLOR_MASK(lcd_color_bg), CONSOLE_ROW_SIZE);
 451 #else
 452         /*
 453          * Poor attempt to optimize speed by moving "long"s.
 454          * But the code is ugly, and not a bit faster :-(
 455          */
 456         ulong *t = (ulong *)CONSOLE_ROW_FIRST;
 457         ulong *s = (ulong *)CONSOLE_ROW_SECOND;
 458         ulong    l = CONSOLE_SCROLL_SIZE / sizeof(ulong);
 459         uchar  c = lcd_color_bg & 0xFF;
 460         ulong val= (c<<24) | (c<<16) | (c<<8) | c;
 461
 462         while (l--)
 463                 *t++ = *s++;
 464
 465         t = (ulong *)CONSOLE_ROW_LAST;
 466         l = CONSOLE_ROW_SIZE / sizeof(ulong);
 467
 468         while (l-- > 0)
 469                 *t++ = val;
 470 #endif
 471 }
 472
 473 /*----------------------------------------------------------------------*/
 474
 475 static inline void console_back (void)
 476 {
 477         if (--console_col < 0) {
 478                 console_col = CONSOLE_COLS-1 ;
 479                 if (--console_row < 0) {
 480                         console_row = 0;
 481                 }
 482         }
 483
 484         lcd_putc_xy (console_col * VIDEO_FONT_WIDTH,
 485                      console_row * VIDEO_FONT_HEIGHT,
 486                      ' ');
 487 }
 488
 489 /*----------------------------------------------------------------------*/
 490
 491 static inline void console_newline (void)
 492 {
 493         ++console_row;
 494         console_col = 0;
 495
 496         /* Check if we need to scroll the terminal */
 497         if (console_row >= CONSOLE_ROWS) {
 498                 /* Scroll everything up */
 499                 console_scrollup () ;
 500                 --console_row;
 501         }
 502 }
 503
 504 /*----------------------------------------------------------------------*/
 505
 506 void lcd_putc (const char c)
 507 {
 508         if (!lcd_is_enabled) {
 509                 serial_putc(c);
 510                 return;
 511         }
 512
 513         switch (c) {
 514         case '\r':      console_col = 0;
 515                         return;
 516
 517         case '\n':      console_newline();
 518                         return;
 519
 520         case '\t':      /* Tab (8 chars alignment) */
 521                         console_col |=  8;
 522                         console_col &= ~7;
 523
 524                         if (console_col >= CONSOLE_COLS) {
 525                                 console_newline();
 526                         }
 527                         return;
 528
 529         case '\b':      console_back();
 530                         return;
 531
 532         default:        lcd_putc_xy (console_col * VIDEO_FONT_WIDTH,
 533                                      console_row * VIDEO_FONT_HEIGHT,
 534                                      c);
 535                         if (++console_col >= CONSOLE_COLS) {
 536                                 console_newline();
 537                         }
 538                         return;
 539         }
 540         /* NOTREACHED */
 541 }
 542
 543 /*----------------------------------------------------------------------*/
 544
 545 void lcd_puts (const char *s)
 546 {
 547         if (!lcd_is_enabled) {
 548                 serial_puts (s);
 549                 return;
 550         }
 551
 552         while (*s) {
 553                 lcd_putc (*s++);
 554         }
 555 }
 556
 557 /************************************************************************/
 558 /* ** Low-Level Graphics Routines                                       */
 559 /************************************************************************/
 560
 561 static void lcd_drawchars (ushort x, ushort y, uchar *str, int count)
 562 {
 563         uchar *dest;
 564         ushort off, row;
 565
 566         dest = (uchar *)(lcd_base + y * lcd_line_length + x * (1 << LCD_BPP) / 8);
 567         off  = x * (1 << LCD_BPP) % 8;
 568
 569         for (row=0;  row < VIDEO_FONT_HEIGHT;  ++row, dest += lcd_line_length)  {
 570                 uchar *s = str;
 571                 uchar *d = dest;
 572                 int i;
 573
 574 #if LCD_BPP == LCD_MONOCHROME
 575                 uchar rest = *d & -(1 << (8-off));
 576                 uchar sym;
 577 #endif
 578                 for (i=0; i<count; ++i) {
 579                         uchar c, bits;
 580
 581                         c = *s++;
 582                         bits = video_fontdata[c * VIDEO_FONT_HEIGHT + row];
 583
 584 #if LCD_BPP == LCD_MONOCHROME
 585                         sym  = (COLOR_MASK(lcd_color_fg) & bits) |
 586                                (COLOR_MASK(lcd_color_bg) & ~bits);
 587
 588                         *d++ = rest | (sym >> off);
 589                         rest = sym << (8-off);
 590 #elif LCD_BPP == LCD_COLOR8
 591                         for (c=0; c<8; ++c) {
 592                                 *d++ = (bits & 0x80) ?
 593                                                 lcd_color_fg : lcd_color_bg;
 594                                 bits <<= 1;
 595                         }
 596 #endif
 597                 }
 598
 599 #if LCD_BPP == LCD_MONOCHROME
 600                 *d  = rest | (*d & ((1 << (8-off)) - 1));
 601 #endif
 602         }
 603 }
 604
 605 /*----------------------------------------------------------------------*/
 606
 607 static inline void lcd_puts_xy (ushort x, ushort y, uchar *s)
 608 {
 609 #if defined(CONFIG_LCD_LOGO) && !defined(LCD_INFO_BELOW_LOGO)
 610         lcd_drawchars (x, y+BMP_LOGO_HEIGHT, s, strlen (s));
 611 #else
 612         lcd_drawchars (x, y, s, strlen (s));
 613 #endif
 614 }
 615
 616 /*----------------------------------------------------------------------*/
 617
 618 static inline void lcd_putc_xy (ushort x, ushort y, uchar c)
 619 {
 620 #if defined(CONFIG_LCD_LOGO) && !defined(LCD_INFO_BELOW_LOGO)
 621         lcd_drawchars (x, y+BMP_LOGO_HEIGHT, &c, 1);
 622 #else
 623         lcd_drawchars (x, y, &c, 1);
 624 #endif
 625 }
 626
 627 /************************************************************************/
 628 /**  Small utility to check that you got the colours right              */
 629 /************************************************************************/
 630 #ifdef LCD_TEST_PATTERN
 631
 632 #define N_BLK_VERT      2
 633 #define N_BLK_HOR       3
 634
 635 static int test_colors[N_BLK_HOR*N_BLK_VERT] = {
 636         CONSOLE_COLOR_RED,      CONSOLE_COLOR_GREEN,    CONSOLE_COLOR_YELLOW,
 637         CONSOLE_COLOR_BLUE,     CONSOLE_COLOR_MAGENTA,  CONSOLE_COLOR_CYAN,
 638 };
 639
 640 static void test_pattern (void)
 641 {
 642         ushort v_max  = panel_info.vl_row;
 643         ushort h_max  = panel_info.vl_col;
 644         ushort v_step = (v_max + N_BLK_VERT - 1) / N_BLK_VERT;
 645         ushort h_step = (h_max + N_BLK_HOR  - 1) / N_BLK_HOR;
 646         ushort v, h;
 647         uchar *pix = (uchar *)lcd_base;
 648
 649         printf ("[LCD] Test Pattern: %d x %d [%d x %d]\n",
 650                 h_max, v_max, h_step, v_step);
 651
 652         /* WARNING: Code silently assumes 8bit/pixel */
 653         for (v=0; v<v_max; ++v) {
 654                 uchar iy = v / v_step;
 655                 for (h=0; h<h_max; ++h) {
 656                         uchar ix = N_BLK_HOR * iy + (h/h_step);
 657                         *pix++ = test_colors[ix];
 658                 }
 659         }
 660 }
 661 #endif /* LCD_TEST_PATTERN */
 662
 663
 664 /************************************************************************/
 665 /* ** GENERIC Initialization Routines                                   */
 666 /************************************************************************/
 667
 668 int drv_lcd_init (void)
 669 {
 670         DECLARE_GLOBAL_DATA_PTR;
 671
 672         device_t lcddev;
 673         int rc;
 674
 675         lcd_base = (void *)(gd->fb_base);
 676
 677         lcd_line_length = (panel_info.vl_col * NBITS (panel_info.vl_bpix)) / 8;
 678
 679         lcd_init (lcd_base);            /* LCD initialization */
 680
 681         /* Device initialization */
 682         memset (&lcddev, 0, sizeof (lcddev));
 683
 684         strcpy (lcddev.name, "lcd");
 685         lcddev.ext   = 0;                       /* No extensions */
 686         lcddev.flags = DEV_FLAGS_OUTPUT;        /* Output only */
 687         lcddev.putc  = lcd_putc;                /* 'putc' function */
 688         lcddev.puts  = lcd_puts;                /* 'puts' function */
 689
 690         rc = device_register (&lcddev);
 691
 692         return (rc == 0) ? 1 : rc;
 693 }
 694
 695 /*----------------------------------------------------------------------*/
 696
 697 int lcd_init (void *lcdbase)
 698 {
 699         /* Initialize the lcd controller */
 700         debug ("[LCD] Initializing LCD frambuffer at %p\n", lcdbase);
 701
 702         lcd_ctrl_init (lcdbase);
 703
 704 #if LCD_BPP == LCD_MONOCHROME
 705         /* Setting the palette */
 706         lcd_initcolregs();
 707
 708 #elif LCD_BPP == LCD_COLOR8
 709         /* Setting the palette */
 710         lcd_setcolreg  (CONSOLE_COLOR_BLACK,       0,    0,    0);
 711         lcd_setcolreg  (CONSOLE_COLOR_RED,      0xFF,    0,    0);
 712         lcd_setcolreg  (CONSOLE_COLOR_GREEN,       0, 0xFF,    0);
 713         lcd_setcolreg  (CONSOLE_COLOR_YELLOW,   0xFF, 0xFF,    0);
 714         lcd_setcolreg  (CONSOLE_COLOR_BLUE,        0,    0, 0xFF);
 715         lcd_setcolreg  (CONSOLE_COLOR_MAGENTA,  0xFF,    0, 0xFF);
 716         lcd_setcolreg  (CONSOLE_COLOR_CYAN,        0, 0xFF, 0xFF);
 717         lcd_setcolreg  (CONSOLE_COLOR_GREY,     0xAA, 0xAA, 0xAA);
 718         lcd_setcolreg  (CONSOLE_COLOR_WHITE,    0xFF, 0xFF, 0xFF);
 719 #endif
 720
 721 #ifndef CFG_WHITE_ON_BLACK
 722         lcd_setfgcolor (CONSOLE_COLOR_BLACK);
 723         lcd_setbgcolor (CONSOLE_COLOR_WHITE);
 724 #else
 725         lcd_setfgcolor (CONSOLE_COLOR_WHITE);
 726         lcd_setbgcolor (CONSOLE_COLOR_BLACK);
 727 #endif  /* CFG_WHITE_ON_BLACK */
 728
 729 #ifdef  LCD_TEST_PATTERN
 730         test_pattern();
 731 #else
 732         /* set framebuffer to background color */
 733         memset ((char *)lcd_base,
 734                 COLOR_MASK(lcd_getbgcolor()),
 735                 lcd_line_length*panel_info.vl_row);
 736 #endif
 737
 738         lcd_enable ();
 739
 740         /* Paint the logo and retrieve LCD base address */
 741         debug ("[LCD] Drawing the logo...\n");
 742         lcd_console_address = lcd_logo ();
 743
 744         /* Initialize the console */
 745         console_col = 0;
 746 #ifdef LCD_INFO_BELOW_LOGO
 747         console_row = 7 + BMP_LOGO_HEIGHT / VIDEO_FONT_HEIGHT;
 748 #else
 749         console_row = 1;        /* leave 1 blank line below logo */
 750 #endif
 751         lcd_is_enabled = 1;
 752
 753         return 0;
 754 }
 755
 756
 757 /************************************************************************/
 758 /* ** ROM capable initialization part - needed to reserve FB memory     */
 759 /************************************************************************/
 760
 761 /*
 762  * This is called early in the system initialization to grab memory
 763  * for the LCD controller.
 764  * Returns new address for monitor, after reserving LCD buffer memory
 765  *
 766  * Note that this is running from ROM, so no write access to global data.
 767  */
 768 ulong lcd_setmem (ulong addr)
 769 {
 770         ulong size;
 771         int line_length = (panel_info.vl_col * NBITS (panel_info.vl_bpix)) / 8;
 772
 773         debug ("LCD panel info: %d x %d, %d bit/pix\n",
 774                 panel_info.vl_col, panel_info.vl_row, NBITS (panel_info.vl_bpix) );
 775
 776         size = line_length * panel_info.vl_row;
 777
 778         /* Round up to nearest full page */
 779         size = (size + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
 780
 781         /* Allocate pages for the frame buffer. */
 782         addr -= size;
 783
 784         debug ("Reserving %ldk for LCD Framebuffer at: %08lx\n", size>>10, addr);
 785
 786         return (addr);
 787 }
 788
 789
 790 /************************************************************************/
 791 /* ----------------- chipset specific functions ----------------------- */
 792 /************************************************************************/
 793
 794 static void lcd_ctrl_init (void *lcdbase)
 795 {
 796         volatile immap_t *immr = (immap_t *) CFG_IMMR;
 797         volatile lcd823_t *lcdp = &immr->im_lcd;
 798
 799         uint lccrtmp;
 800         uint lchcr_hpc_tmp;
 801
 802         /* Initialize the LCD control register according to the LCD
 803          * parameters defined.  We do everything here but enable
 804          * the controller.
 805          */
 806
 807         lccrtmp  = LCDBIT (LCCR_BNUM_BIT,
 808                    (((panel_info.vl_row * panel_info.vl_col) * (1 << LCD_BPP)) / 128));
 809
 810         lccrtmp |= LCDBIT (LCCR_CLKP_BIT, panel_info.vl_clkp)   |
 811                    LCDBIT (LCCR_OEP_BIT,  panel_info.vl_oep)    |
 812                    LCDBIT (LCCR_HSP_BIT,  panel_info.vl_hsp)    |
 813                    LCDBIT (LCCR_VSP_BIT,  panel_info.vl_vsp)    |
 814                    LCDBIT (LCCR_DP_BIT,   panel_info.vl_dp)     |
 815                    LCDBIT (LCCR_BPIX_BIT, panel_info.vl_bpix)   |
 816                    LCDBIT (LCCR_LBW_BIT,  panel_info.vl_lbw)    |
 817                    LCDBIT (LCCR_SPLT_BIT, panel_info.vl_splt)   |
 818                    LCDBIT (LCCR_CLOR_BIT, panel_info.vl_clor)   |
 819                    LCDBIT (LCCR_TFT_BIT,  panel_info.vl_tft);
 820
 821 #if 0
 822         lccrtmp |= ((SIU_LEVEL5 / 2) << 12);
 823         lccrtmp |= LCCR_EIEN;
 824 #endif
 825
 826         lcdp->lcd_lccr = lccrtmp;
 827         lcdp->lcd_lcsr = 0xFF;          /* Clear pending interrupts */
 828
 829         /* Initialize LCD controller bus priorities.
 830          */
 831 #ifdef CONFIG_RBC823
 832         immr->im_siu_conf.sc_sdcr = (immr->im_siu_conf.sc_sdcr & ~0x0f) | 1;    /* RAID = 01, LAID = 00 */
 833 #else
 834         immr->im_siu_conf.sc_sdcr &= ~0x0f;     /* RAID = LAID = 0 */
 835
 836         /* set SHFT/CLOCK division factor 4
 837          * This needs to be set based upon display type and processor
 838          * speed.  The TFT displays run about 20 to 30 MHz.
 839          * I was running 64 MHz processor speed.
 840          * The value for this divider must be chosen so the result is
 841          * an integer of the processor speed (i.e., divide by 3 with
 842          * 64 MHz would be bad).
 843          */
 844         immr->im_clkrst.car_sccr &= ~0x1F;
 845         immr->im_clkrst.car_sccr |= LCD_DF;     /* was 8 */
 846
 847 #endif /* CONFIG_RBC823 */
 848
 849 #if defined(CONFIG_RBC823)
 850         /* Enable LCD on port D.
 851          */
 852         immr->im_ioport.iop_pddat &= 0x0300;
 853         immr->im_ioport.iop_pdpar |= 0x1CFF;
 854         immr->im_ioport.iop_pddir |= 0x1CFF;
 855
 856         /* Configure LCD_ON, VEE_ON, CCFL_ON on port B.
 857          */
 858         immr->im_cpm.cp_pbdat &= ~0x00005001;
 859         immr->im_cpm.cp_pbpar &= ~0x00005001;
 860         immr->im_cpm.cp_pbdir |=  0x00005001;
 861 #elif !defined(CONFIG_EDT32F10)
 862         /* Enable LCD on port D.
 863          */
 864         immr->im_ioport.iop_pdpar |= 0x1FFF;
 865         immr->im_ioport.iop_pddir |= 0x1FFF;
 866
 867         /* Enable LCD_A/B/C on port B.
 868          */
 869         immr->im_cpm.cp_pbpar |= 0x00005001;
 870         immr->im_cpm.cp_pbdir |= 0x00005001;
 871 #else
 872         /* Enable LCD on port D.
 873          */
 874         immr->im_ioport.iop_pdpar |= 0x1DFF;
 875         immr->im_ioport.iop_pdpar &= ~0x0200;
 876         immr->im_ioport.iop_pddir |= 0x1FFF;
 877         immr->im_ioport.iop_pddat |= 0x0200;
 878 #endif
 879
 880         /* Load the physical address of the linear frame buffer
 881          * into the LCD controller.
 882          * BIG NOTE:  This has to be modified to load A and B depending
 883          * upon the split mode of the LCD.
 884          */
 885         lcdp->lcd_lcfaa = (ulong)lcd_base;
 886         lcdp->lcd_lcfba = (ulong)lcd_base;
 887
 888         /* MORE HACKS...This must be updated according to 823 manual
 889          * for different panels.
 890          * Udi Finkelstein - done - see below:
 891          * Note: You better not try unsupported combinations such as
 892          * 4-bit wide passive dual scan LCD at 4/8 Bit color.
 893          */
 894         lchcr_hpc_tmp =
 895                 (panel_info.vl_col *
 896                  (panel_info.vl_tft ? 8 :
 897                         (((2 - panel_info.vl_lbw) << /* 4 bit=2, 8-bit = 1 */
 898                          /* use << to mult by: single scan = 1, dual scan = 2 */
 899                           panel_info.vl_splt) *
 900                          (panel_info.vl_bpix | 1)))) >> 3; /* 2/4 BPP = 1, 8/16 BPP = 3 */
 901
 902         lcdp->lcd_lchcr = LCHCR_BO |
 903                           LCDBIT (LCHCR_AT_BIT, 4) |
 904                           LCDBIT (LCHCR_HPC_BIT, lchcr_hpc_tmp) |
 905                           panel_info.vl_wbl;
 906
 907         lcdp->lcd_lcvcr = LCDBIT (LCVCR_VPW_BIT, panel_info.vl_vpw) |
 908                           LCDBIT (LCVCR_LCD_AC_BIT, panel_info.vl_lcdac) |
 909                           LCDBIT (LCVCR_VPC_BIT, panel_info.vl_row) |
 910                           panel_info.vl_wbf;
 911
 912 }
 913
 914 /*----------------------------------------------------------------------*/
 915
 916 #ifdef  NOT_USED_SO_FAR
 917 static void
 918 lcd_getcolreg (ushort regno, ushort *red, ushort *green, ushort *blue)
 919 {
 920         volatile immap_t *immr = (immap_t *) CFG_IMMR;
 921         volatile cpm8xx_t *cp = &(immr->im_cpm);
 922         unsigned short colreg, *cmap_ptr;
 923
 924         cmap_ptr = (unsigned short *)&cp->lcd_cmap[regno * 2];
 925
 926         colreg = *cmap_ptr;
 927 #ifdef  CFG_INVERT_COLORS
 928         colreg ^= 0x0FFF;
 929 #endif
 930
 931         *red   = (colreg >> 8) & 0x0F;
 932         *green = (colreg >> 4) & 0x0F;
 933         *blue  =  colreg       & 0x0F;
 934 }
 935 #endif  /* NOT_USED_SO_FAR */
 936
 937 /*----------------------------------------------------------------------*/
 938
 939 #if LCD_BPP == LCD_COLOR8
 940 static void
 941 lcd_setcolreg (ushort regno, ushort red, ushort green, ushort blue)
 942 {
 943         volatile immap_t *immr = (immap_t *) CFG_IMMR;
 944         volatile cpm8xx_t *cp = &(immr->im_cpm);
 945         unsigned short colreg, *cmap_ptr;
 946
 947         cmap_ptr = (unsigned short *)&cp->lcd_cmap[regno * 2];
 948
 949         colreg = ((red   & 0x0F) << 8) |
 950                  ((green & 0x0F) << 4) |
 951                   (blue  & 0x0F) ;
 952 #ifdef  CFG_INVERT_COLORS
 953         colreg ^= 0x0FFF;
 954 #endif
 955         *cmap_ptr = colreg;
 956
 957         debug ("setcolreg: reg %2d @ %p: R=%02X G=%02X B=%02X => %02X%02X\n",
 958                 regno, &(cp->lcd_cmap[regno * 2]),
 959                 red, green, blue,
 960                 cp->lcd_cmap[ regno * 2 ], cp->lcd_cmap[(regno * 2) + 1]);
 961 }
 962 #endif  /* LCD_COLOR8 */
 963
 964 /*----------------------------------------------------------------------*/
 965
 966 #if LCD_BPP == LCD_MONOCHROME
 967 static
 968 void lcd_initcolregs (void)
 969 {
 970         volatile immap_t *immr = (immap_t *) CFG_IMMR;
 971         volatile cpm8xx_t *cp = &(immr->im_cpm);
 972         ushort regno;
 973
 974         for (regno = 0; regno < 16; regno++) {
 975                 cp->lcd_cmap[regno * 2] = 0;
 976                 cp->lcd_cmap[(regno * 2) + 1] = regno & 0x0f;
 977         }
 978 }
 979 #endif
 980
 981 /*----------------------------------------------------------------------*/
 982
 983 static void lcd_setfgcolor (int color)
 984 {
 985         lcd_color_fg = color & 0x0F;
 986 }
 987
 988 /*----------------------------------------------------------------------*/
 989
 990 static void lcd_setbgcolor (int color)
 991 {
 992         lcd_color_bg = color & 0x0F;
 993 }
 994
 995 /*----------------------------------------------------------------------*/
 996
 997 #ifdef  NOT_USED_SO_FAR
 998 static int lcd_getfgcolor (void)
 999 {
1000         return lcd_color_fg;
1001 }
1002 #endif  /* NOT_USED_SO_FAR */
1003
1004 /*----------------------------------------------------------------------*/
1005
1006 static int lcd_getbgcolor (void)
1007 {
1008         return lcd_color_bg;
1009 }
1010
1011 /*----------------------------------------------------------------------*/
1012
1013 static void lcd_enable (void)
1014 {
1015         volatile immap_t *immr = (immap_t *) CFG_IMMR;
1016         volatile lcd823_t *lcdp = &immr->im_lcd;
1017
1018         /* Enable the LCD panel */
1019 #ifndef CONFIG_RBC823
1020         immr->im_siu_conf.sc_sdcr |= (1 << (31 - 25));          /* LAM = 1 */
1021 #endif
1022         lcdp->lcd_lccr |= LCCR_PON;
1023
1024 #ifdef CONFIG_V37
1025         /* Turn on display backlight */
1026         immr->im_cpm.cp_pbpar |= 0x00008000;
1027         immr->im_cpm.cp_pbdir |= 0x00008000;
1028 #elif defined(CONFIG_RBC823)
1029         /* Turn on display backlight */
1030         immr->im_cpm.cp_pbdat |= 0x00004000;
1031 #endif
1032
1033 #if defined(CONFIG_LWMON)
1034     {   uchar c = pic_read (0x60);
1035 #if defined(CONFIG_LCD) && defined(CONFIG_LWMON) && (CONFIG_POST & CFG_POST_SYSMON)
1036         c |= 0x04;      /* Chip Enable LCD */
1037 #else
1038         c |= 0x07;      /* Power on CCFL, Enable CCFL, Chip Enable LCD */
1039 #endif
1040         pic_write (0x60, c);
1041     }
1042 #endif /* CONFIG_LWMON */
1043
1044 #if defined(CONFIG_R360MPI)
1045     {
1046         extern void r360_i2c_lcd_write (uchar data0, uchar data1);
1047
1048         r360_i2c_lcd_write(0x10, 0x01);
1049         r360_i2c_lcd_write(0x20, 0x01);
1050         r360_i2c_lcd_write(0x3F, 0xFF);
1051         r360_i2c_lcd_write(0x47, 0xFF);
1052     }
1053 #endif /* CONFIG_R360MPI */
1054 #ifdef CONFIG_RBC823
1055         udelay(200000); /* wait 200ms */
1056         /* Turn VEE_ON first */
1057         immr->im_cpm.cp_pbdat |= 0x00000001;
1058         udelay(200000); /* wait 200ms */
1059         /* Now turn on LCD_ON */
1060         immr->im_cpm.cp_pbdat |= 0x00001000;
1061 #endif
1062 #ifdef CONFIG_RRVISION
1063         debug ("PC4->Output(1): enable LVDS\n");
1064         debug ("PC5->Output(0): disable PAL clock\n");
1065         immr->im_ioport.iop_pddir |=  0x1000;
1066         immr->im_ioport.iop_pcpar &= ~(0x0C00);
1067         immr->im_ioport.iop_pcdir |=   0x0C00 ;
1068         immr->im_ioport.iop_pcdat |=   0x0800 ;
1069         immr->im_ioport.iop_pcdat &= ~(0x0400);
1070         debug ("PDPAR=0x%04X PDDIR=0x%04X PDDAT=0x%04X\n",
1071                immr->im_ioport.iop_pdpar,
1072                immr->im_ioport.iop_pddir,
1073                immr->im_ioport.iop_pddat);
1074         debug ("PCPAR=0x%04X PCDIR=0x%04X PCDAT=0x%04X\n",
1075                immr->im_ioport.iop_pcpar,
1076                immr->im_ioport.iop_pcdir,
1077                immr->im_ioport.iop_pcdat);
1078 #endif
1079 }
1080
1081 /*----------------------------------------------------------------------*/
1082
1083 #if defined (CONFIG_RBC823)
1084 void lcd_disable (void)
1085 {
1086         volatile immap_t *immr = (immap_t *) CFG_IMMR;
1087         volatile lcd823_t *lcdp = &immr->im_lcd;
1088
1089 #if defined(CONFIG_LWMON)
1090     {   uchar c = pic_read (0x60);
1091         c &= ~0x07;     /* Power off CCFL, Disable CCFL, Chip Disable LCD */
1092         pic_write (0x60, c);
1093     }
1094 #elif defined(CONFIG_R360MPI)
1095     {
1096         extern void r360_i2c_lcd_write (uchar data0, uchar data1);
1097
1098         r360_i2c_lcd_write(0x10, 0x00);
1099         r360_i2c_lcd_write(0x20, 0x00);
1100         r360_i2c_lcd_write(0x30, 0x00);
1101         r360_i2c_lcd_write(0x40, 0x00);
1102     }
1103 #endif /* CONFIG_LWMON */
1104         /* Disable the LCD panel */
1105         lcdp->lcd_lccr &= ~LCCR_PON;
1106 #ifdef CONFIG_RBC823
1107         /* Turn off display backlight, VEE and LCD_ON */
1108         immr->im_cpm.cp_pbdat &= ~0x00005001;
1109 #else
1110         immr->im_siu_conf.sc_sdcr &= ~(1 << (31 - 25)); /* LAM = 0 */
1111 #endif /* CONFIG_RBC823 */
1112 }
1113 #endif  /* NOT_USED_SO_FAR || CONFIG_RBC823 */
1114
1115
1116 /************************************************************************/
1117 /* ** Chipset depending Bitmap / Logo stuff...                          */
1118 /************************************************************************/
1119
1120
1121 #ifdef CONFIG_LCD_LOGO
1122 static void bitmap_plot (int x, int y)
1123 {
1124         volatile immap_t *immr = (immap_t *) CFG_IMMR;
1125         volatile cpm8xx_t *cp = &(immr->im_cpm);
1126         ushort *cmap;
1127         ushort i;
1128         uchar *bmap;
1129         uchar *fb;
1130
1131         debug ("Logo: width %d  height %d  colors %d  cmap %d\n",
1132                 BMP_LOGO_WIDTH, BMP_LOGO_HEIGHT, BMP_LOGO_COLORS,
1133                 sizeof(bmp_logo_palette)/(sizeof(ushort))
1134         );
1135
1136         /* Leave room for default color map */
1137         cmap = (ushort *)&(cp->lcd_cmap[BMP_LOGO_OFFSET*sizeof(ushort)]);
1138
1139         WATCHDOG_RESET();
1140
1141         /* Set color map */
1142         for (i=0; i<(sizeof(bmp_logo_palette)/(sizeof(ushort))); ++i) {
1143                 ushort colreg = bmp_logo_palette[i];
1144 #ifdef  CFG_INVERT_COLORS
1145                 colreg ^= 0xFFF;
1146 #endif
1147                 *cmap++ = colreg;
1148         }
1149
1150         bmap = &bmp_logo_bitmap[0];
1151         fb   = (char *)(lcd_base + y * lcd_line_length + x);
1152
1153         WATCHDOG_RESET();
1154
1155         for (i=0; i<BMP_LOGO_HEIGHT; ++i) {
1156                 memcpy (fb, bmap, BMP_LOGO_WIDTH);
1157                 bmap += BMP_LOGO_WIDTH;
1158                 fb   += panel_info.vl_col;
1159         }
1160
1161         WATCHDOG_RESET();
1162 }
1163 #endif /* CONFIG_LCD_LOGO */
1164
1165 #if (CONFIG_COMMANDS & CFG_CMD_BMP)
1166 /*
1167  * Display the BMP file located at address bmp_image.
1168  * Only uncompressed
1169  */
1170 int lcd_display_bitmap(ulong bmp_image)
1171 {
1172         volatile immap_t *immr = (immap_t *) CFG_IMMR;
1173         volatile cpm8xx_t *cp = &(immr->im_cpm);
1174         ushort *cmap;
1175         ushort i, j;
1176         uchar *fb;
1177         bmp_image_t *bmp=(bmp_image_t *)bmp_image;
1178         uchar *bmap;
1179         ushort padded_line;
1180         unsigned long width, height;
1181         unsigned colors,bpix;
1182         unsigned long compression;
1183
1184         WATCHDOG_RESET();
1185
1186         if (!((bmp->header.signature[0]=='B') &&
1187               (bmp->header.signature[1]=='M'))) {
1188                 printf ("Error: no valid bmp image at %lx\n", bmp_image);
1189                 return 1;
1190         }
1191
1192         width = le32_to_cpu (bmp->header.width);
1193         height = le32_to_cpu (bmp->header.height);
1194         colors = 1<<le16_to_cpu (bmp->header.bit_count);
1195         compression = le32_to_cpu (bmp->header.compression);
1196
1197         bpix = NBITS(panel_info.vl_bpix);
1198
1199         if ((bpix != 1) && (bpix != 8)) {
1200                 printf ("Error: %d bit/pixel mode not supported by U-Boot\n",
1201                         bpix);
1202                 return 1;
1203         }
1204
1205         if (bpix != le16_to_cpu(bmp->header.bit_count)) {
1206                 printf ("Error: %d bit/pixel mode, but BMP has %d bit/pixel\n",
1207                         bpix,
1208                         le16_to_cpu(bmp->header.bit_count));
1209                 return 1;
1210         }
1211
1212         if (compression!=BMP_BI_RGB) {
1213                 printf ("Error: compression type %ld not supported\n",
1214                         compression);
1215                 return 1;
1216         }
1217
1218         debug ("Display-bmp: %d x %d  with %d colors\n",
1219                width, height, colors);
1220
1221         if (bpix==8) {
1222                 /* Fill the entire color map */
1223                 cmap = (ushort *)&(cp->lcd_cmap[255*sizeof(ushort)]);
1224
1225                 /* Set color map */
1226                 for (i = 0; i < colors; ++i) {
1227                         bmp_color_table_entry_t cte = bmp->color_table[i];
1228                         ushort colreg =
1229                                 ((cte.red>>4)   << 8) |
1230                                 ((cte.green>>4) << 4) |
1231                                 (cte.blue>>4) ;
1232 #ifdef  CFG_INVERT_COLORS
1233                         colreg ^= 0xFFF;
1234 #endif
1235                         *cmap-- = colreg;
1236                 }
1237
1238                 WATCHDOG_RESET();
1239         }
1240
1241         padded_line = (width&0x3) ? ((width&~0x3)+4) : (width);
1242         if (width>panel_info.vl_col)
1243                 width = panel_info.vl_col;
1244         if (height>panel_info.vl_row)
1245                 height = panel_info.vl_row;
1246
1247         bmap = (uchar *)bmp + le32_to_cpu (bmp->header.data_offset);
1248         fb   = (uchar *)
1249                 (lcd_base +
1250                  (((height>=panel_info.vl_row) ? panel_info.vl_row : height)-1)
1251                  * lcd_line_length);
1252         for (i = 0; i < height; ++i) {
1253                 WATCHDOG_RESET();
1254                 for (j = 0; j < width ; j++)
1255                         *(fb++)=255-*(bmap++);
1256                 bmap += (width - padded_line);
1257                 fb   -= (width + lcd_line_length);
1258         }
1259
1260         return (0);
1261 }
1262 #endif /* (CONFIG_COMMANDS & CFG_CMD_BMP) */
1263
1264 /*----------------------------------------------------------------------*/
1265
1266 static void *lcd_logo (void)
1267 {
1268 #ifdef LCD_INFO
1269         DECLARE_GLOBAL_DATA_PTR;
1270
1271         char info[80];
1272         char temp[32];
1273 #endif /* LCD_INFO */
1274
1275 #ifdef CONFIG_SPLASH_SCREEN
1276         char *s;
1277         ulong addr;
1278
1279         if ((s = getenv("splashimage")) != NULL) {
1280                 addr = simple_strtoul(s, NULL, 16);
1281
1282                 if (lcd_display_bitmap (addr) == 0) {
1283                         return ((void *)lcd_base);
1284                 }
1285         }
1286 #endif  /* CONFIG_SPLASH_SCREEN */
1287
1288 #ifdef CONFIG_LCD_LOGO
1289         bitmap_plot (0, 0);
1290 #endif /* CONFIG_LCD_LOGO */
1291
1292
1293 #ifdef LCD_INFO
1294         sprintf (info, "%s (%s - %s) ", U_BOOT_VERSION, __DATE__, __TIME__);
1295         lcd_drawchars (LCD_INFO_X, LCD_INFO_Y, info, strlen(info));
1296
1297         sprintf (info, "(C) 2003 DENX Software Engineering");
1298         lcd_drawchars (LCD_INFO_X, LCD_INFO_Y + VIDEO_FONT_HEIGHT,
1299                                         info, strlen(info));
1300
1301         sprintf (info, "    Wolfgang DENK, wd@denx.de");
1302         lcd_drawchars (LCD_INFO_X, LCD_INFO_Y + VIDEO_FONT_HEIGHT * 2,
1303                                         info, strlen(info));
1304 #ifdef LCD_INFO_BELOW_LOGO
1305         sprintf (info, "MPC823 CPU at %s MHz",
1306                 strmhz(temp, gd->cpu_clk));
1307         lcd_drawchars (LCD_INFO_X, LCD_INFO_Y + VIDEO_FONT_HEIGHT * 3,
1308                                         info, strlen(info));
1309         sprintf (info, "  %ld MB RAM, %ld MB Flash",
1310                 gd->ram_size >> 20,
1311                 gd->bd->bi_flashsize >> 20 );
1312         lcd_drawchars (LCD_INFO_X, LCD_INFO_Y + VIDEO_FONT_HEIGHT * 4,
1313                                         info, strlen(info));
1314 #else
1315         /* leave one blank line */
1316
1317         sprintf (info, "MPC823 CPU at %s MHz, %ld MB RAM, %ld MB Flash",
1318                 strmhz(temp, gd->cpu_clk),
1319                 gd->ram_size >> 20,
1320                 gd->bd->bi_flashsize >> 20 );
1321         lcd_drawchars (LCD_INFO_X, LCD_INFO_Y + VIDEO_FONT_HEIGHT * 4,
1322                                         info, strlen(info));
1323 #endif /* LCD_INFO_BELOW_LOGO */
1324 #endif /* LCD_INFO */
1325
1326 #if defined(CONFIG_LCD_LOGO) && !defined(LCD_INFO_BELOW_LOGO)
1327         return ((void *)((ulong)lcd_base + BMP_LOGO_HEIGHT * lcd_line_length));
1328 #else
1329         return ((void *)lcd_base);
1330 #endif  /* CONFIG_LCD_LOGO */
1331 }
1332
1333 /************************************************************************/
1334 /************************************************************************/
1335
1336 #endif /* CONFIG_LCD */