common/lcd.c

   1 /*
   2  * Common LCD routines for supported CPUs
   3  *
   4  * (C) Copyright 2001-2002
   5  * Wolfgang Denk, DENX Software Engineering -- wd@denx.de
   6  *
   7  * See file CREDITS for list of people who contributed to this
   8  * project.
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License as
  12  * published by the Free Software Foundation; either version 2 of
  13  * the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  23  * MA 02111-1307 USA
  24  */
  25
  26 /************************************************************************/
  27 /* ** HEADER FILES                                                      */
  28 /************************************************************************/
  29
  30 /* #define DEBUG */
  31
  32 #include <config.h>
  33 #include <common.h>
  34 #include <command.h>
  35 #include <version.h>
  36 #include <stdarg.h>
  37 #include <linux/types.h>
  38 #include <devices.h>
  39 #if defined(CONFIG_POST)
  40 #include <post.h>
  41 #endif
  42 #include <lcd.h>
  43 #include <watchdog.h>
  44
  45 #if defined(CONFIG_PXA250)
  46 #include <asm/byteorder.h>
  47 #endif
  48
  49 #if defined(CONFIG_MPC823)
  50 #include <lcdvideo.h>
  51 #endif
  52
  53 #if defined(CONFIG_ATMEL_LCD)
  54 #include <atmel_lcdc.h>
  55 #include <nand.h>
  56 #endif
  57
  58 /************************************************************************/
  59 /* ** FONT DATA                                                         */
  60 /************************************************************************/
  61 #include <video_font.h>         /* Get font data, width and height      */
  62
  63 /************************************************************************/
  64 /* ** LOGO DATA                                                         */
  65 /************************************************************************/
  66 #ifdef CONFIG_LCD_LOGO
  67 # include <bmp_logo.h>          /* Get logo data, width and height      */
  68 # if (CONSOLE_COLOR_WHITE >= BMP_LOGO_OFFSET)
  69 #  error Default Color Map overlaps with Logo Color Map
  70 # endif
  71 #endif
  72
  73 DECLARE_GLOBAL_DATA_PTR;
  74
  75 ulong lcd_setmem (ulong addr);
  76
  77 static void lcd_drawchars (ushort x, ushort y, uchar *str, int count);
  78 static inline void lcd_puts_xy (ushort x, ushort y, uchar *s);
  79 static inline void lcd_putc_xy (ushort x, ushort y, uchar  c);
  80
  81 static int lcd_init (void *lcdbase);
  82
  83 static int lcd_clear (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[]);
  84 extern void lcd_ctrl_init (void *lcdbase);
  85 extern void lcd_enable (void);
  86 static void *lcd_logo (void);
  87
  88
  89 #if LCD_BPP == LCD_COLOR8
  90 extern void lcd_setcolreg (ushort regno,
  91                                 ushort red, ushort green, ushort blue);
  92 #endif
  93 #if LCD_BPP == LCD_MONOCHROME
  94 extern void lcd_initcolregs (void);
  95 #endif
  96
  97 static int lcd_getbgcolor (void);
  98 static void lcd_setfgcolor (int color);
  99 static void lcd_setbgcolor (int color);
 100
 101 char lcd_is_enabled = 0;
 102 extern vidinfo_t panel_info;
 103
 104 #ifdef  NOT_USED_SO_FAR
 105 static void lcd_getcolreg (ushort regno,
 106                                 ushort *red, ushort *green, ushort *blue);
 107 static int lcd_getfgcolor (void);
 108 #endif  /* NOT_USED_SO_FAR */
 109
 110 /************************************************************************/
 111
 112 /*----------------------------------------------------------------------*/
 113
 114 static void console_scrollup (void)
 115 {
 116 #if 1
 117         /* Copy up rows ignoring the first one */
 118         memcpy (CONSOLE_ROW_FIRST, CONSOLE_ROW_SECOND, CONSOLE_SCROLL_SIZE);
 119
 120         /* Clear the last one */
 121         memset (CONSOLE_ROW_LAST, COLOR_MASK(lcd_color_bg), CONSOLE_ROW_SIZE);
 122 #else
 123         /*
 124          * Poor attempt to optimize speed by moving "long"s.
 125          * But the code is ugly, and not a bit faster :-(
 126          */
 127         ulong *t = (ulong *)CONSOLE_ROW_FIRST;
 128         ulong *s = (ulong *)CONSOLE_ROW_SECOND;
 129         ulong    l = CONSOLE_SCROLL_SIZE / sizeof(ulong);
 130         uchar  c = lcd_color_bg & 0xFF;
 131         ulong val= (c<<24) | (c<<16) | (c<<8) | c;
 132
 133         while (l--)
 134                 *t++ = *s++;
 135
 136         t = (ulong *)CONSOLE_ROW_LAST;
 137         l = CONSOLE_ROW_SIZE / sizeof(ulong);
 138
 139         while (l-- > 0)
 140                 *t++ = val;
 141 #endif
 142 }
 143
 144 /*----------------------------------------------------------------------*/
 145
 146 static inline void console_back (void)
 147 {
 148         if (--console_col < 0) {
 149                 console_col = CONSOLE_COLS-1 ;
 150                 if (--console_row < 0) {
 151                         console_row = 0;
 152                 }
 153         }
 154
 155         lcd_putc_xy (console_col * VIDEO_FONT_WIDTH,
 156                      console_row * VIDEO_FONT_HEIGHT,
 157                      ' ');
 158 }
 159
 160 /*----------------------------------------------------------------------*/
 161
 162 static inline void console_newline (void)
 163 {
 164         ++console_row;
 165         console_col = 0;
 166
 167         /* Check if we need to scroll the terminal */
 168         if (console_row >= CONSOLE_ROWS) {
 169                 /* Scroll everything up */
 170                 console_scrollup () ;
 171                 --console_row;
 172         }
 173 }
 174
 175 /*----------------------------------------------------------------------*/
 176
 177 void lcd_putc (const char c)
 178 {
 179         if (!lcd_is_enabled) {
 180                 serial_putc(c);
 181                 return;
 182         }
 183
 184         switch (c) {
 185         case '\r':      console_col = 0;
 186                         return;
 187
 188         case '\n':      console_newline();
 189                         return;
 190
 191         case '\t':      /* Tab (8 chars alignment) */
 192                         console_col |=  8;
 193                         console_col &= ~7;
 194
 195                         if (console_col >= CONSOLE_COLS) {
 196                                 console_newline();
 197                         }
 198                         return;
 199
 200         case '\b':      console_back();
 201                         return;
 202
 203         default:        lcd_putc_xy (console_col * VIDEO_FONT_WIDTH,
 204                                      console_row * VIDEO_FONT_HEIGHT,
 205                                      c);
 206                         if (++console_col >= CONSOLE_COLS) {
 207                                 console_newline();
 208                         }
 209                         return;
 210         }
 211         /* NOTREACHED */
 212 }
 213
 214 /*----------------------------------------------------------------------*/
 215
 216 void lcd_puts (const char *s)
 217 {
 218         if (!lcd_is_enabled) {
 219                 serial_puts (s);
 220                 return;
 221         }
 222
 223         while (*s) {
 224                 lcd_putc (*s++);
 225         }
 226 }
 227
 228 /*----------------------------------------------------------------------*/
 229
 230 void lcd_printf(const char *fmt, ...)
 231 {
 232         va_list args;
 233         char buf[CONFIG_SYS_PBSIZE];
 234
 235         va_start(args, fmt);
 236         vsprintf(buf, fmt, args);
 237         va_end(args);
 238
 239         lcd_puts(buf);
 240 }
 241
 242 /************************************************************************/
 243 /* ** Low-Level Graphics Routines                                       */
 244 /************************************************************************/
 245
 246 static void lcd_drawchars (ushort x, ushort y, uchar *str, int count)
 247 {
 248         uchar *dest;
 249         ushort off, row;
 250
 251         dest = (uchar *)(lcd_base + y * lcd_line_length + x * (1 << LCD_BPP) / 8);
 252         off  = x * (1 << LCD_BPP) % 8;
 253
 254         for (row=0;  row < VIDEO_FONT_HEIGHT;  ++row, dest += lcd_line_length)  {
 255                 uchar *s = str;
 256                 uchar *d = dest;
 257                 int i;
 258
 259 #if LCD_BPP == LCD_MONOCHROME
 260                 uchar rest = *d & -(1 << (8-off));
 261                 uchar sym;
 262 #endif
 263                 for (i=0; i<count; ++i) {
 264                         uchar c, bits;
 265
 266                         c = *s++;
 267                         bits = video_fontdata[c * VIDEO_FONT_HEIGHT + row];
 268
 269 #if LCD_BPP == LCD_MONOCHROME
 270                         sym  = (COLOR_MASK(lcd_color_fg) & bits) |
 271                                (COLOR_MASK(lcd_color_bg) & ~bits);
 272
 273                         *d++ = rest | (sym >> off);
 274                         rest = sym << (8-off);
 275 #elif LCD_BPP == LCD_COLOR8
 276                         for (c=0; c<8; ++c) {
 277                                 *d++ = (bits & 0x80) ?
 278                                                 lcd_color_fg : lcd_color_bg;
 279                                 bits <<= 1;
 280                         }
 281 #elif LCD_BPP == LCD_COLOR16
 282                         for (c=0; c<16; ++c) {
 283                                 *d++ = (bits & 0x80) ?
 284                                                 lcd_color_fg : lcd_color_bg;
 285                                 bits <<= 1;
 286                         }
 287 #endif
 288                 }
 289 #if LCD_BPP == LCD_MONOCHROME
 290                 *d  = rest | (*d & ((1 << (8-off)) - 1));
 291 #endif
 292         }
 293 }
 294
 295 /*----------------------------------------------------------------------*/
 296
 297 static inline void lcd_puts_xy (ushort x, ushort y, uchar *s)
 298 {
 299 #if defined(CONFIG_LCD_LOGO) && !defined(CONFIG_LCD_INFO_BELOW_LOGO)
 300         lcd_drawchars (x, y+BMP_LOGO_HEIGHT, s, strlen ((char *)s));
 301 #else
 302         lcd_drawchars (x, y, s, strlen ((char *)s));
 303 #endif
 304 }
 305
 306 /*----------------------------------------------------------------------*/
 307
 308 static inline void lcd_putc_xy (ushort x, ushort y, uchar c)
 309 {
 310 #if defined(CONFIG_LCD_LOGO) && !defined(CONFIG_LCD_INFO_BELOW_LOGO)
 311         lcd_drawchars (x, y+BMP_LOGO_HEIGHT, &c, 1);
 312 #else
 313         lcd_drawchars (x, y, &c, 1);
 314 #endif
 315 }
 316
 317 /************************************************************************/
 318 /**  Small utility to check that you got the colours right              */
 319 /************************************************************************/
 320 #ifdef LCD_TEST_PATTERN
 321
 322 #define N_BLK_VERT      2
 323 #define N_BLK_HOR       3
 324
 325 static int test_colors[N_BLK_HOR*N_BLK_VERT] = {
 326         CONSOLE_COLOR_RED,      CONSOLE_COLOR_GREEN,    CONSOLE_COLOR_YELLOW,
 327         CONSOLE_COLOR_BLUE,     CONSOLE_COLOR_MAGENTA,  CONSOLE_COLOR_CYAN,
 328 };
 329
 330 static void test_pattern (void)
 331 {
 332         ushort v_max  = panel_info.vl_row;
 333         ushort h_max  = panel_info.vl_col;
 334         ushort v_step = (v_max + N_BLK_VERT - 1) / N_BLK_VERT;
 335         ushort h_step = (h_max + N_BLK_HOR  - 1) / N_BLK_HOR;
 336         ushort v, h;
 337         uchar *pix = (uchar *)lcd_base;
 338
 339         printf ("[LCD] Test Pattern: %d x %d [%d x %d]\n",
 340                 h_max, v_max, h_step, v_step);
 341
 342         /* WARNING: Code silently assumes 8bit/pixel */
 343         for (v=0; v<v_max; ++v) {
 344                 uchar iy = v / v_step;
 345                 for (h=0; h<h_max; ++h) {
 346                         uchar ix = N_BLK_HOR * iy + (h/h_step);
 347                         *pix++ = test_colors[ix];
 348                 }
 349         }
 350 }
 351 #endif /* LCD_TEST_PATTERN */
 352
 353
 354 /************************************************************************/
 355 /* ** GENERIC Initialization Routines                                   */
 356 /************************************************************************/
 357
 358 int drv_lcd_init (void)
 359 {
 360         device_t lcddev;
 361         int rc;
 362
 363         lcd_base = (void *)(gd->fb_base);
 364
 365         lcd_line_length = (panel_info.vl_col * NBITS (panel_info.vl_bpix)) / 8;
 366
 367         lcd_init (lcd_base);            /* LCD initialization */
 368
 369         /* Device initialization */
 370         memset (&lcddev, 0, sizeof (lcddev));
 371
 372         strcpy (lcddev.name, "lcd");
 373         lcddev.ext   = 0;                       /* No extensions */
 374         lcddev.flags = DEV_FLAGS_OUTPUT;        /* Output only */
 375         lcddev.putc  = lcd_putc;                /* 'putc' function */
 376         lcddev.puts  = lcd_puts;                /* 'puts' function */
 377
 378         rc = device_register (&lcddev);
 379
 380         return (rc == 0) ? 1 : rc;
 381 }
 382
 383 /*----------------------------------------------------------------------*/
 384 static int lcd_clear (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
 385 {
 386 #if LCD_BPP == LCD_MONOCHROME
 387         /* Setting the palette */
 388         lcd_initcolregs();
 389
 390 #elif LCD_BPP == LCD_COLOR8
 391         /* Setting the palette */
 392         lcd_setcolreg  (CONSOLE_COLOR_BLACK,       0,    0,    0);
 393         lcd_setcolreg  (CONSOLE_COLOR_RED,      0xFF,    0,    0);
 394         lcd_setcolreg  (CONSOLE_COLOR_GREEN,       0, 0xFF,    0);
 395         lcd_setcolreg  (CONSOLE_COLOR_YELLOW,   0xFF, 0xFF,    0);
 396         lcd_setcolreg  (CONSOLE_COLOR_BLUE,        0,    0, 0xFF);
 397         lcd_setcolreg  (CONSOLE_COLOR_MAGENTA,  0xFF,    0, 0xFF);
 398         lcd_setcolreg  (CONSOLE_COLOR_CYAN,        0, 0xFF, 0xFF);
 399         lcd_setcolreg  (CONSOLE_COLOR_GREY,     0xAA, 0xAA, 0xAA);
 400         lcd_setcolreg  (CONSOLE_COLOR_WHITE,    0xFF, 0xFF, 0xFF);
 401 #endif
 402
 403 #ifndef CONFIG_SYS_WHITE_ON_BLACK
 404         lcd_setfgcolor (CONSOLE_COLOR_BLACK);
 405         lcd_setbgcolor (CONSOLE_COLOR_WHITE);
 406 #else
 407         lcd_setfgcolor (CONSOLE_COLOR_WHITE);
 408         lcd_setbgcolor (CONSOLE_COLOR_BLACK);
 409 #endif  /* CONFIG_SYS_WHITE_ON_BLACK */
 410
 411 #ifdef  LCD_TEST_PATTERN
 412         test_pattern();
 413 #else
 414         /* set framebuffer to background color */
 415         memset ((char *)lcd_base,
 416                 COLOR_MASK(lcd_getbgcolor()),
 417                 lcd_line_length*panel_info.vl_row);
 418 #endif
 419         /* Paint the logo and retrieve LCD base address */
 420         debug ("[LCD] Drawing the logo...\n");
 421         lcd_console_address = lcd_logo ();
 422
 423         console_col = 0;
 424         console_row = 0;
 425
 426         return (0);
 427 }
 428
 429 U_BOOT_CMD(
 430         cls,    1,      1,      lcd_clear,
 431         "cls     - clear screen\n",
 432         NULL
 433 );
 434
 435 /*----------------------------------------------------------------------*/
 436
 437 static int lcd_init (void *lcdbase)
 438 {
 439         /* Initialize the lcd controller */
 440         debug ("[LCD] Initializing LCD frambuffer at %p\n", lcdbase);
 441
 442         lcd_ctrl_init (lcdbase);
 443         lcd_is_enabled = 1;
 444         lcd_clear (NULL, 1, 1, NULL);   /* dummy args */
 445         lcd_enable ();
 446
 447         /* Initialize the console */
 448         console_col = 0;
 449 #ifdef CONFIG_LCD_INFO_BELOW_LOGO
 450         console_row = 7 + BMP_LOGO_HEIGHT / VIDEO_FONT_HEIGHT;
 451 #else
 452         console_row = 1;        /* leave 1 blank line below logo */
 453 #endif
 454
 455         return 0;
 456 }
 457
 458
 459 /************************************************************************/
 460 /* ** ROM capable initialization part - needed to reserve FB memory     */
 461 /************************************************************************/
 462 /*
 463  * This is called early in the system initialization to grab memory
 464  * for the LCD controller.
 465  * Returns new address for monitor, after reserving LCD buffer memory
 466  *
 467  * Note that this is running from ROM, so no write access to global data.
 468  */
 469 ulong lcd_setmem (ulong addr)
 470 {
 471         ulong size;
 472         int line_length = (panel_info.vl_col * NBITS (panel_info.vl_bpix)) / 8;
 473
 474         debug ("LCD panel info: %d x %d, %d bit/pix\n",
 475                 panel_info.vl_col, panel_info.vl_row, NBITS (panel_info.vl_bpix) );
 476
 477         size = line_length * panel_info.vl_row;
 478
 479         /* Round up to nearest full page */
 480         size = (size + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
 481
 482         /* Allocate pages for the frame buffer. */
 483         addr -= size;
 484
 485         debug ("Reserving %ldk for LCD Framebuffer at: %08lx\n", size>>10, addr);
 486
 487         return (addr);
 488 }
 489
 490 /*----------------------------------------------------------------------*/
 491
 492 static void lcd_setfgcolor (int color)
 493 {
 494 #ifdef CONFIG_ATMEL_LCD
 495         lcd_color_fg = color;
 496 #else
 497         lcd_color_fg = color & 0x0F;
 498 #endif
 499 }
 500
 501 /*----------------------------------------------------------------------*/
 502
 503 static void lcd_setbgcolor (int color)
 504 {
 505 #ifdef CONFIG_ATMEL_LCD
 506         lcd_color_bg = color;
 507 #else
 508         lcd_color_bg = color & 0x0F;
 509 #endif
 510 }
 511
 512 /*----------------------------------------------------------------------*/
 513
 514 #ifdef  NOT_USED_SO_FAR
 515 static int lcd_getfgcolor (void)
 516 {
 517         return lcd_color_fg;
 518 }
 519 #endif  /* NOT_USED_SO_FAR */
 520
 521 /*----------------------------------------------------------------------*/
 522
 523 static int lcd_getbgcolor (void)
 524 {
 525         return lcd_color_bg;
 526 }
 527
 528 /*----------------------------------------------------------------------*/
 529
 530 /************************************************************************/
 531 /* ** Chipset depending Bitmap / Logo stuff...                          */
 532 /************************************************************************/
 533 #ifdef CONFIG_LCD_LOGO
 534 void bitmap_plot (int x, int y)
 535 {
 536 #ifdef CONFIG_ATMEL_LCD
 537         uint *cmap;
 538 #else
 539         ushort *cmap;
 540 #endif
 541         ushort i, j;
 542         uchar *bmap;
 543         uchar *fb;
 544         ushort *fb16;
 545 #if defined(CONFIG_PXA250)
 546         struct pxafb_info *fbi = &panel_info.pxa;
 547 #elif defined(CONFIG_MPC823)
 548         volatile immap_t *immr = (immap_t *) CONFIG_SYS_IMMR;
 549         volatile cpm8xx_t *cp = &(immr->im_cpm);
 550 #endif
 551
 552         debug ("Logo: width %d  height %d  colors %d  cmap %d\n",
 553                 BMP_LOGO_WIDTH, BMP_LOGO_HEIGHT, BMP_LOGO_COLORS,
 554                 (int)(sizeof(bmp_logo_palette)/(sizeof(ushort))));
 555
 556         bmap = &bmp_logo_bitmap[0];
 557         fb   = (uchar *)(lcd_base + y * lcd_line_length + x);
 558
 559         if (NBITS(panel_info.vl_bpix) < 12) {
 560                 /* Leave room for default color map */
 561 #if defined(CONFIG_PXA250)
 562                 cmap = (ushort *)fbi->palette;
 563 #elif defined(CONFIG_MPC823)
 564                 cmap = (ushort *)&(cp->lcd_cmap[BMP_LOGO_OFFSET*sizeof(ushort)]);
 565 #elif defined(CONFIG_ATMEL_LCD)
 566                 cmap = (uint *) (panel_info.mmio + ATMEL_LCDC_LUT(0));
 567 #endif
 568
 569                 WATCHDOG_RESET();
 570
 571                 /* Set color map */
 572                 for (i=0; i<(sizeof(bmp_logo_palette)/(sizeof(ushort))); ++i) {
 573                         ushort colreg = bmp_logo_palette[i];
 574 #ifdef CONFIG_ATMEL_LCD
 575                         uint lut_entry;
 576 #ifdef CONFIG_ATMEL_LCD_BGR555
 577                         lut_entry = ((colreg & 0x000F) << 11) |
 578                                     ((colreg & 0x00F0) <<  2) |
 579                                     ((colreg & 0x0F00) >>  7);
 580 #else /* CONFIG_ATMEL_LCD_RGB565 */
 581                         lut_entry = ((colreg & 0x000F) << 1) |
 582                                     ((colreg & 0x00F0) << 3) |
 583                                     ((colreg & 0x0F00) << 4);
 584 #endif
 585                         *(cmap + BMP_LOGO_OFFSET) = lut_entry;
 586                         cmap++;
 587 #else /* !CONFIG_ATMEL_LCD */
 588 #ifdef  CONFIG_SYS_INVERT_COLORS
 589                         *cmap++ = 0xffff - colreg;
 590 #else
 591                         *cmap++ = colreg;
 592 #endif
 593 #endif /* CONFIG_ATMEL_LCD */
 594                 }
 595
 596                 WATCHDOG_RESET();
 597
 598                 for (i=0; i<BMP_LOGO_HEIGHT; ++i) {
 599                         memcpy (fb, bmap, BMP_LOGO_WIDTH);
 600                         bmap += BMP_LOGO_WIDTH;
 601                         fb   += panel_info.vl_col;
 602                 }
 603         }
 604         else { /* true color mode */
 605                 fb16 = (ushort *)(lcd_base + y * lcd_line_length + x);
 606                 for (i=0; i<BMP_LOGO_HEIGHT; ++i) {
 607                         for (j=0; j<BMP_LOGO_WIDTH; j++) {
 608                                 fb16[j] = bmp_logo_palette[(bmap[j])];
 609                                 }
 610                         bmap += BMP_LOGO_WIDTH;
 611                         fb16 += panel_info.vl_col;
 612                 }
 613         }
 614
 615         WATCHDOG_RESET();
 616 }
 617 #endif /* CONFIG_LCD_LOGO */
 618
 619 /*----------------------------------------------------------------------*/
 620 #if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN)
 621 /*
 622  * Display the BMP file located at address bmp_image.
 623  * Only uncompressed.
 624  */
 625 int lcd_display_bitmap(ulong bmp_image, int x, int y)
 626 {
 627 #ifdef CONFIG_ATMEL_LCD
 628         uint *cmap;
 629 #elif !defined(CONFIG_MCC200)
 630         ushort *cmap;
 631 #endif
 632         ushort i, j;
 633         uchar *fb;
 634         bmp_image_t *bmp=(bmp_image_t *)bmp_image;
 635         uchar *bmap;
 636         ushort padded_line;
 637         unsigned long width, height;
 638         unsigned long pwidth = panel_info.vl_col;
 639         unsigned colors,bpix;
 640         unsigned long compression;
 641 #if defined(CONFIG_PXA250)
 642         struct pxafb_info *fbi = &panel_info.pxa;
 643 #elif defined(CONFIG_MPC823)
 644         volatile immap_t *immr = (immap_t *) CONFIG_SYS_IMMR;
 645         volatile cpm8xx_t *cp = &(immr->im_cpm);
 646 #endif
 647
 648         if (!((bmp->header.signature[0]=='B') &&
 649                 (bmp->header.signature[1]=='M'))) {
 650                 printf ("Error: no valid bmp image at %lx\n", bmp_image);
 651                 return 1;
 652 }
 653
 654         width = le32_to_cpu (bmp->header.width);
 655         height = le32_to_cpu (bmp->header.height);
 656         colors = 1<<le16_to_cpu (bmp->header.bit_count);
 657         compression = le32_to_cpu (bmp->header.compression);
 658
 659         bpix = NBITS(panel_info.vl_bpix);
 660
 661         if ((bpix != 1) && (bpix != 8)) {
 662                 printf ("Error: %d bit/pixel mode not supported by U-Boot\n",
 663                         bpix);
 664                 return 1;
 665         }
 666
 667         if (bpix != le16_to_cpu(bmp->header.bit_count)) {
 668                 printf ("Error: %d bit/pixel mode, but BMP has %d bit/pixel\n",
 669                         bpix,
 670                         le16_to_cpu(bmp->header.bit_count));
 671                 return 1;
 672         }
 673
 674         debug ("Display-bmp: %d x %d  with %d colors\n",
 675                 (int)width, (int)height, (int)colors);
 676
 677 #if !defined(CONFIG_MCC200)
 678         /* MCC200 LCD doesn't need CMAP, supports 1bpp b&w only */
 679         if (bpix==8) {
 680 #if defined(CONFIG_PXA250)
 681                 cmap = (ushort *)fbi->palette;
 682 #elif defined(CONFIG_MPC823)
 683                 cmap = (ushort *)&(cp->lcd_cmap[255*sizeof(ushort)]);
 684 #elif defined(CONFIG_ATMEL_LCD)
 685                 cmap = (uint *) (panel_info.mmio + ATMEL_LCDC_LUT(0));
 686 #else
 687 # error "Don't know location of color map"
 688 #endif
 689
 690                 /* Set color map */
 691                 for (i=0; i<colors; ++i) {
 692                         bmp_color_table_entry_t cte = bmp->color_table[i];
 693 #if !defined(CONFIG_ATMEL_LCD)
 694                         ushort colreg =
 695                                 ( ((cte.red)   << 8) & 0xf800) |
 696                                 ( ((cte.green) << 3) & 0x07e0) |
 697                                 ( ((cte.blue)  >> 3) & 0x001f) ;
 698 #ifdef CONFIG_SYS_INVERT_COLORS
 699                         *cmap = 0xffff - colreg;
 700 #else
 701                         *cmap = colreg;
 702 #endif
 703 #if defined(CONFIG_PXA250)
 704                         cmap++;
 705 #elif defined(CONFIG_MPC823)
 706                         cmap--;
 707 #endif
 708 #else /* CONFIG_ATMEL_LCD */
 709                         lcd_setcolreg(i, cte.red, cte.green, cte.blue);
 710 #endif
 711                 }
 712         }
 713 #endif
 714
 715         /*
 716          *  BMP format for Monochrome assumes that the state of a
 717          * pixel is described on a per Bit basis, not per Byte.
 718          *  So, in case of Monochrome BMP we should align widths
 719          * on a byte boundary and convert them from Bit to Byte
 720          * units.
 721          *  Probably, PXA250 and MPC823 process 1bpp BMP images in
 722          * their own ways, so make the converting to be MCC200
 723          * specific.
 724          */
 725 #if defined(CONFIG_MCC200)
 726         if (bpix==1)
 727         {
 728                 width = ((width + 7) & ~7) >> 3;
 729                 x     = ((x + 7) & ~7) >> 3;
 730                 pwidth= ((pwidth + 7) & ~7) >> 3;
 731         }
 732 #endif
 733
 734         padded_line = (width&0x3) ? ((width&~0x3)+4) : (width);
 735         if ((x + width)>pwidth)
 736                 width = pwidth - x;
 737         if ((y + height)>panel_info.vl_row)
 738                 height = panel_info.vl_row - y;
 739
 740         bmap = (uchar *)bmp + le32_to_cpu (bmp->header.data_offset);
 741         fb   = (uchar *) (lcd_base +
 742                 (y + height - 1) * lcd_line_length + x);
 743         for (i = 0; i < height; ++i) {
 744                 WATCHDOG_RESET();
 745                 for (j = 0; j < width ; j++)
 746 #if defined(CONFIG_PXA250) || defined(CONFIG_ATMEL_LCD)
 747                         *(fb++) = *(bmap++);
 748 #elif defined(CONFIG_MPC823) || defined(CONFIG_MCC200)
 749                         *(fb++)=255-*(bmap++);
 750 #endif
 751                 bmap += (width - padded_line);
 752                 fb   -= (width + lcd_line_length);
 753         }
 754
 755         return (0);
 756 }
 757 #endif
 758
 759 #ifdef CONFIG_VIDEO_BMP_GZIP
 760 extern bmp_image_t *gunzip_bmp(unsigned long addr, unsigned long *lenp);
 761 #endif
 762
 763 static void *lcd_logo (void)
 764 {
 765 #ifdef CONFIG_LCD_INFO
 766         char info[80];
 767         char temp[32];
 768 #ifdef CONFIG_ATMEL_LCD
 769         int i;
 770         ulong dram_size, nand_size;
 771 #endif
 772 #endif /* CONFIG_LCD_INFO */
 773
 774 #ifdef CONFIG_SPLASH_SCREEN
 775         char *s;
 776         ulong addr;
 777         static int do_splash = 1;
 778
 779         if (do_splash && (s = getenv("splashimage")) != NULL) {
 780                 addr = simple_strtoul(s, NULL, 16);
 781                 do_splash = 0;
 782
 783 #ifdef CONFIG_VIDEO_BMP_GZIP
 784                 bmp_image_t *bmp = (bmp_image_t *)addr;
 785                 unsigned long len;
 786
 787                 if (!((bmp->header.signature[0]=='B') &&
 788                       (bmp->header.signature[1]=='M'))) {
 789                         addr = (ulong)gunzip_bmp(addr, &len);
 790                 }
 791 #endif
 792
 793                 if (lcd_display_bitmap (addr, 0, 0) == 0) {
 794                         return ((void *)lcd_base);
 795                 }
 796         }
 797 #endif /* CONFIG_SPLASH_SCREEN */
 798
 799 #ifdef CONFIG_LCD_LOGO
 800         bitmap_plot (0, 0);
 801 #endif /* CONFIG_LCD_LOGO */
 802
 803 #ifdef CONFIG_MPC823
 804 # ifdef CONFIG_LCD_INFO
 805         sprintf (info, "%s (%s - %s) ", U_BOOT_VERSION, __DATE__, __TIME__);
 806         lcd_drawchars (LCD_INFO_X, LCD_INFO_Y, (uchar *)info, strlen(info));
 807
 808         sprintf (info, "(C) 2008 DENX Software Engineering GmbH");
 809         lcd_drawchars (LCD_INFO_X, LCD_INFO_Y + VIDEO_FONT_HEIGHT,
 810                                         (uchar *)info, strlen(info));
 811
 812         sprintf (info, "    Wolfgang DENK, wd@denx.de");
 813         lcd_drawchars (LCD_INFO_X, LCD_INFO_Y + VIDEO_FONT_HEIGHT * 2,
 814                                         (uchar *)info, strlen(info));
 815 #  ifdef CONFIG_LCD_INFO_BELOW_LOGO
 816         sprintf (info, "MPC823 CPU at %s MHz",
 817                 strmhz(temp, gd->cpu_clk));
 818         lcd_drawchars (LCD_INFO_X, LCD_INFO_Y + VIDEO_FONT_HEIGHT * 3,
 819                                         info, strlen(info));
 820         sprintf (info, "  %ld MB RAM, %ld MB Flash",
 821                 gd->ram_size >> 20,
 822                 gd->bd->bi_flashsize >> 20 );
 823         lcd_drawchars (LCD_INFO_X, LCD_INFO_Y + VIDEO_FONT_HEIGHT * 4,
 824                                         info, strlen(info));
 825 #  else
 826         /* leave one blank line */
 827
 828         sprintf (info, "MPC823 CPU at %s MHz, %ld MB RAM, %ld MB Flash",
 829                 strmhz(temp, gd->cpu_clk),
 830                 gd->ram_size >> 20,
 831                 gd->bd->bi_flashsize >> 20 );
 832         lcd_drawchars (LCD_INFO_X, LCD_INFO_Y + VIDEO_FONT_HEIGHT * 4,
 833                                         (uchar *)info, strlen(info));
 834
 835 #  endif /* CONFIG_LCD_INFO_BELOW_LOGO */
 836 # endif /* CONFIG_LCD_INFO */
 837 #endif /* CONFIG_MPC823 */
 838
 839 #ifdef CONFIG_ATMEL_LCD
 840 # ifdef CONFIG_LCD_INFO
 841         sprintf (info, "%s", U_BOOT_VERSION);
 842         lcd_drawchars (LCD_INFO_X, LCD_INFO_Y, (uchar *)info, strlen(info));
 843
 844         sprintf (info, "(C) 2008 ATMEL Corp");
 845         lcd_drawchars (LCD_INFO_X, LCD_INFO_Y + VIDEO_FONT_HEIGHT,
 846                                         (uchar *)info, strlen(info));
 847
 848         sprintf (info, "at91support@atmel.com");
 849         lcd_drawchars (LCD_INFO_X, LCD_INFO_Y + VIDEO_FONT_HEIGHT * 2,
 850                                         (uchar *)info, strlen(info));
 851
 852         sprintf (info, "%s CPU at %s MHz",
 853                 AT91_CPU_NAME,
 854                 strmhz(temp, AT91_MAIN_CLOCK));
 855         lcd_drawchars (LCD_INFO_X, LCD_INFO_Y + VIDEO_FONT_HEIGHT * 3,
 856                                         (uchar *)info, strlen(info));
 857
 858         dram_size = 0;
 859         for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++)
 860                 dram_size += gd->bd->bi_dram[i].size;
 861         nand_size = 0;
 862         for (i = 0; i < CONFIG_SYS_MAX_NAND_DEVICE; i++)
 863                 nand_size += nand_info[i].size;
 864         sprintf (info, "  %ld MB SDRAM, %ld MB NAND",
 865                 dram_size >> 20,
 866                 nand_size >> 20 );
 867         lcd_drawchars (LCD_INFO_X, LCD_INFO_Y + VIDEO_FONT_HEIGHT * 4,
 868                                         (uchar *)info, strlen(info));
 869 # endif /* CONFIG_LCD_INFO */
 870 #endif /* CONFIG_ATMEL_LCD */
 871
 872
 873 #if defined(CONFIG_LCD_LOGO) && !defined(CONFIG_LCD_INFO_BELOW_LOGO)
 874         return ((void *)((ulong)lcd_base + BMP_LOGO_HEIGHT * lcd_line_length));
 875 #else
 876         return ((void *)lcd_base);
 877 #endif /* CONFIG_LCD_LOGO && !CONFIG_LCD_INFO_BELOW_LOGO */
 878 }
 879
 880 /************************************************************************/
 881 /************************************************************************/