1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32#include <config.h>
33#include <common.h>
34#include <command.h>
35#include <stdarg.h>
36#include <search.h>
37#include <env_callback.h>
38#include <linux/types.h>
39#include <stdio_dev.h>
40#if defined(CONFIG_POST)
41#include <post.h>
42#endif
43#include <lcd.h>
44#include <watchdog.h>
45
46#if defined(CONFIG_CPU_PXA25X) || defined(CONFIG_CPU_PXA27X) || \
47 defined(CONFIG_CPU_MONAHANS)
48#define CONFIG_CPU_PXA
49#include <asm/byteorder.h>
50#endif
51
52#if defined(CONFIG_MPC823)
53#include <lcdvideo.h>
54#endif
55
56#if defined(CONFIG_ATMEL_LCD)
57#include <atmel_lcdc.h>
58#endif
59
60
61
62
63#include <video_font.h>
64#include <video_font_data.h>
65
66
67
68
69#ifdef CONFIG_LCD_LOGO
70# include <bmp_logo.h>
71# include <bmp_logo_data.h>
72# if (CONSOLE_COLOR_WHITE >= BMP_LOGO_OFFSET) && (LCD_BPP != LCD_COLOR16)
73# error Default Color Map overlaps with Logo Color Map
74# endif
75#endif
76
77#ifndef CONFIG_LCD_ALIGNMENT
78#define CONFIG_LCD_ALIGNMENT PAGE_SIZE
79#endif
80
81
82#ifndef CONFIG_CONSOLE_SCROLL_LINES
83#define CONFIG_CONSOLE_SCROLL_LINES 1
84#endif
85
86
87
88
89#if defined(CONFIG_LCD_LOGO) && !defined(CONFIG_LCD_INFO_BELOW_LOGO)
90# define CONSOLE_ROWS ((panel_info.vl_row-BMP_LOGO_HEIGHT) \
91 / VIDEO_FONT_HEIGHT)
92#else
93# define CONSOLE_ROWS (panel_info.vl_row / VIDEO_FONT_HEIGHT)
94#endif
95
96#define CONSOLE_COLS (panel_info.vl_col / VIDEO_FONT_WIDTH)
97#define CONSOLE_ROW_SIZE (VIDEO_FONT_HEIGHT * lcd_line_length)
98#define CONSOLE_ROW_FIRST lcd_console_address
99#define CONSOLE_ROW_SECOND (lcd_console_address + CONSOLE_ROW_SIZE)
100#define CONSOLE_ROW_LAST (lcd_console_address + CONSOLE_SIZE \
101 - CONSOLE_ROW_SIZE)
102#define CONSOLE_SIZE (CONSOLE_ROW_SIZE * CONSOLE_ROWS)
103#define CONSOLE_SCROLL_SIZE (CONSOLE_SIZE - CONSOLE_ROW_SIZE)
104
105#if LCD_BPP == LCD_MONOCHROME
106# define COLOR_MASK(c) ((c) | (c) << 1 | (c) << 2 | (c) << 3 | \
107 (c) << 4 | (c) << 5 | (c) << 6 | (c) << 7)
108#elif (LCD_BPP == LCD_COLOR8) || (LCD_BPP == LCD_COLOR16)
109# define COLOR_MASK(c) (c)
110#else
111# error Unsupported LCD BPP.
112#endif
113
114DECLARE_GLOBAL_DATA_PTR;
115
116static void lcd_drawchars(ushort x, ushort y, uchar *str, int count);
117static inline void lcd_puts_xy(ushort x, ushort y, uchar *s);
118static inline void lcd_putc_xy(ushort x, ushort y, uchar c);
119
120static int lcd_init(void *lcdbase);
121
122static void *lcd_logo(void);
123
124static int lcd_getbgcolor(void);
125static void lcd_setfgcolor(int color);
126static void lcd_setbgcolor(int color);
127
128static int lcd_color_fg;
129static int lcd_color_bg;
130int lcd_line_length;
131
132char lcd_is_enabled = 0;
133
134static short console_col;
135static short console_row;
136
137static void *lcd_console_address;
138static void *lcd_base;
139
140static char lcd_flush_dcache;
141
142
143
144
145void lcd_sync(void)
146{
147
148
149
150
151
152#if defined(CONFIG_ARM) && !defined(CONFIG_SYS_DCACHE_OFF)
153 int line_length;
154
155 if (lcd_flush_dcache)
156 flush_dcache_range((u32)lcd_base,
157 (u32)(lcd_base + lcd_get_size(&line_length)));
158#endif
159}
160
161void lcd_set_flush_dcache(int flush)
162{
163 lcd_flush_dcache = (flush != 0);
164}
165
166
167
168static void console_scrollup(void)
169{
170 const int rows = CONFIG_CONSOLE_SCROLL_LINES;
171
172
173 memcpy(CONSOLE_ROW_FIRST,
174 lcd_console_address + CONSOLE_ROW_SIZE * rows,
175 CONSOLE_SIZE - CONSOLE_ROW_SIZE * rows);
176
177
178 memset(lcd_console_address + CONSOLE_SIZE - CONSOLE_ROW_SIZE * rows,
179 COLOR_MASK(lcd_color_bg),
180 CONSOLE_ROW_SIZE * rows);
181
182 lcd_sync();
183 console_row -= rows;
184}
185
186
187
188static inline void console_back(void)
189{
190 if (--console_col < 0) {
191 console_col = CONSOLE_COLS-1 ;
192 if (--console_row < 0)
193 console_row = 0;
194 }
195
196 lcd_putc_xy(console_col * VIDEO_FONT_WIDTH,
197 console_row * VIDEO_FONT_HEIGHT, ' ');
198}
199
200
201
202static inline void console_newline(void)
203{
204 console_col = 0;
205
206
207 if (++console_row >= CONSOLE_ROWS)
208 console_scrollup();
209 else
210 lcd_sync();
211}
212
213
214
215void lcd_putc(const char c)
216{
217 if (!lcd_is_enabled) {
218 serial_putc(c);
219
220 return;
221 }
222
223 switch (c) {
224 case '\r':
225 console_col = 0;
226
227 return;
228 case '\n':
229 console_newline();
230
231 return;
232 case '\t':
233 console_col += 8;
234 console_col &= ~7;
235
236 if (console_col >= CONSOLE_COLS)
237 console_newline();
238
239 return;
240 case '\b':
241 console_back();
242
243 return;
244 default:
245 lcd_putc_xy(console_col * VIDEO_FONT_WIDTH,
246 console_row * VIDEO_FONT_HEIGHT, c);
247 if (++console_col >= CONSOLE_COLS)
248 console_newline();
249 }
250}
251
252
253
254void lcd_puts(const char *s)
255{
256 if (!lcd_is_enabled) {
257 serial_puts(s);
258
259 return;
260 }
261
262 while (*s)
263 lcd_putc(*s++);
264
265 lcd_sync();
266}
267
268
269
270void lcd_printf(const char *fmt, ...)
271{
272 va_list args;
273 char buf[CONFIG_SYS_PBSIZE];
274
275 va_start(args, fmt);
276 vsprintf(buf, fmt, args);
277 va_end(args);
278
279 lcd_puts(buf);
280}
281
282
283
284
285
286static void lcd_drawchars(ushort x, ushort y, uchar *str, int count)
287{
288 uchar *dest;
289 ushort row;
290
291#if defined(CONFIG_LCD_LOGO) && !defined(CONFIG_LCD_INFO_BELOW_LOGO)
292 y += BMP_LOGO_HEIGHT;
293#endif
294
295#if LCD_BPP == LCD_MONOCHROME
296 ushort off = x * (1 << LCD_BPP) % 8;
297#endif
298
299 dest = (uchar *)(lcd_base + y * lcd_line_length + x * (1 << LCD_BPP) / 8);
300
301 for (row = 0; row < VIDEO_FONT_HEIGHT; ++row, dest += lcd_line_length) {
302 uchar *s = str;
303 int i;
304#if LCD_BPP == LCD_COLOR16
305 ushort *d = (ushort *)dest;
306#else
307 uchar *d = dest;
308#endif
309
310#if LCD_BPP == LCD_MONOCHROME
311 uchar rest = *d & -(1 << (8 - off));
312 uchar sym;
313#endif
314 for (i = 0; i < count; ++i) {
315 uchar c, bits;
316
317 c = *s++;
318 bits = video_fontdata[c * VIDEO_FONT_HEIGHT + row];
319
320#if LCD_BPP == LCD_MONOCHROME
321 sym = (COLOR_MASK(lcd_color_fg) & bits) |
322 (COLOR_MASK(lcd_color_bg) & ~bits);
323
324 *d++ = rest | (sym >> off);
325 rest = sym << (8-off);
326#elif LCD_BPP == LCD_COLOR8
327 for (c = 0; c < 8; ++c) {
328 *d++ = (bits & 0x80) ?
329 lcd_color_fg : lcd_color_bg;
330 bits <<= 1;
331 }
332#elif LCD_BPP == LCD_COLOR16
333 for (c = 0; c < 8; ++c) {
334 *d++ = (bits & 0x80) ?
335 lcd_color_fg : lcd_color_bg;
336 bits <<= 1;
337 }
338#endif
339 }
340#if LCD_BPP == LCD_MONOCHROME
341 *d = rest | (*d & ((1 << (8 - off)) - 1));
342#endif
343 }
344}
345
346
347
348static inline void lcd_puts_xy(ushort x, ushort y, uchar *s)
349{
350 lcd_drawchars(x, y, s, strlen((char *)s));
351}
352
353
354
355static inline void lcd_putc_xy(ushort x, ushort y, uchar c)
356{
357 lcd_drawchars(x, y, &c, 1);
358}
359
360
361
362
363#ifdef LCD_TEST_PATTERN
364
365#define N_BLK_VERT 2
366#define N_BLK_HOR 3
367
368static int test_colors[N_BLK_HOR * N_BLK_VERT] = {
369 CONSOLE_COLOR_RED, CONSOLE_COLOR_GREEN, CONSOLE_COLOR_YELLOW,
370 CONSOLE_COLOR_BLUE, CONSOLE_COLOR_MAGENTA, CONSOLE_COLOR_CYAN,
371};
372
373static void test_pattern(void)
374{
375 ushort v_max = panel_info.vl_row;
376 ushort h_max = panel_info.vl_col;
377 ushort v_step = (v_max + N_BLK_VERT - 1) / N_BLK_VERT;
378 ushort h_step = (h_max + N_BLK_HOR - 1) / N_BLK_HOR;
379 ushort v, h;
380 uchar *pix = (uchar *)lcd_base;
381
382 printf("[LCD] Test Pattern: %d x %d [%d x %d]\n",
383 h_max, v_max, h_step, v_step);
384
385
386 for (v = 0; v < v_max; ++v) {
387 uchar iy = v / v_step;
388 for (h = 0; h < h_max; ++h) {
389 uchar ix = N_BLK_HOR * iy + h / h_step;
390 *pix++ = test_colors[ix];
391 }
392 }
393}
394#endif
395
396
397
398
399
400
401int lcd_get_size(int *line_length)
402{
403 *line_length = (panel_info.vl_col * NBITS(panel_info.vl_bpix)) / 8;
404 return *line_length * panel_info.vl_row;
405}
406
407int drv_lcd_init(void)
408{
409 struct stdio_dev lcddev;
410 int rc;
411
412 lcd_base = (void *) gd->fb_base;
413
414 lcd_init(lcd_base);
415
416
417 memset(&lcddev, 0, sizeof(lcddev));
418
419 strcpy(lcddev.name, "lcd");
420 lcddev.ext = 0;
421 lcddev.flags = DEV_FLAGS_OUTPUT;
422 lcddev.putc = lcd_putc;
423 lcddev.puts = lcd_puts;
424
425 rc = stdio_register(&lcddev);
426
427 return (rc == 0) ? 1 : rc;
428}
429
430
431void lcd_clear(void)
432{
433#if LCD_BPP == LCD_MONOCHROME
434
435 lcd_initcolregs();
436
437#elif LCD_BPP == LCD_COLOR8
438
439 lcd_setcolreg(CONSOLE_COLOR_BLACK, 0, 0, 0);
440 lcd_setcolreg(CONSOLE_COLOR_RED, 0xFF, 0, 0);
441 lcd_setcolreg(CONSOLE_COLOR_GREEN, 0, 0xFF, 0);
442 lcd_setcolreg(CONSOLE_COLOR_YELLOW, 0xFF, 0xFF, 0);
443 lcd_setcolreg(CONSOLE_COLOR_BLUE, 0, 0, 0xFF);
444 lcd_setcolreg(CONSOLE_COLOR_MAGENTA, 0xFF, 0, 0xFF);
445 lcd_setcolreg(CONSOLE_COLOR_CYAN, 0, 0xFF, 0xFF);
446 lcd_setcolreg(CONSOLE_COLOR_GREY, 0xAA, 0xAA, 0xAA);
447 lcd_setcolreg(CONSOLE_COLOR_WHITE, 0xFF, 0xFF, 0xFF);
448#endif
449
450#ifndef CONFIG_SYS_WHITE_ON_BLACK
451 lcd_setfgcolor(CONSOLE_COLOR_BLACK);
452 lcd_setbgcolor(CONSOLE_COLOR_WHITE);
453#else
454 lcd_setfgcolor(CONSOLE_COLOR_WHITE);
455 lcd_setbgcolor(CONSOLE_COLOR_BLACK);
456#endif
457
458#ifdef LCD_TEST_PATTERN
459 test_pattern();
460#else
461
462 memset((char *)lcd_base,
463 COLOR_MASK(lcd_getbgcolor()),
464 lcd_line_length * panel_info.vl_row);
465#endif
466
467 debug("[LCD] Drawing the logo...\n");
468 lcd_console_address = lcd_logo();
469
470 console_col = 0;
471 console_row = 0;
472 lcd_sync();
473}
474
475static int do_lcd_clear(cmd_tbl_t *cmdtp, int flag, int argc,
476 char *const argv[])
477{
478 lcd_clear();
479 return 0;
480}
481
482U_BOOT_CMD(
483 cls, 1, 1, do_lcd_clear,
484 "clear screen",
485 ""
486);
487
488
489
490static int lcd_init(void *lcdbase)
491{
492
493 debug("[LCD] Initializing LCD frambuffer at %p\n", lcdbase);
494
495 lcd_ctrl_init(lcdbase);
496
497
498
499
500
501
502
503 if ((unsigned long)lcdbase != gd->fb_base)
504 lcd_base = (void *)gd->fb_base;
505
506 debug("[LCD] Using LCD frambuffer at %p\n", lcd_base);
507
508 lcd_get_size(&lcd_line_length);
509 lcd_line_length = (panel_info.vl_col * NBITS(panel_info.vl_bpix)) / 8;
510 lcd_is_enabled = 1;
511 lcd_clear();
512 lcd_enable();
513
514
515 console_col = 0;
516#ifdef CONFIG_LCD_INFO_BELOW_LOGO
517 console_row = 7 + BMP_LOGO_HEIGHT / VIDEO_FONT_HEIGHT;
518#else
519 console_row = 1;
520#endif
521
522 return 0;
523}
524
525
526
527
528
529
530
531
532
533
534
535
536ulong lcd_setmem(ulong addr)
537{
538 ulong size;
539 int line_length;
540
541 debug("LCD panel info: %d x %d, %d bit/pix\n", panel_info.vl_col,
542 panel_info.vl_row, NBITS(panel_info.vl_bpix));
543
544 size = lcd_get_size(&line_length);
545
546
547 size = ALIGN(size, CONFIG_LCD_ALIGNMENT);
548 addr = ALIGN(addr - CONFIG_LCD_ALIGNMENT + 1, CONFIG_LCD_ALIGNMENT);
549
550
551 addr -= size;
552
553 debug("Reserving %ldk for LCD Framebuffer at: %08lx\n",
554 size >> 10, addr);
555
556 return addr;
557}
558
559
560
561static void lcd_setfgcolor(int color)
562{
563 lcd_color_fg = color;
564}
565
566
567
568static void lcd_setbgcolor(int color)
569{
570 lcd_color_bg = color;
571}
572
573
574
575int lcd_getfgcolor(void)
576{
577 return lcd_color_fg;
578}
579
580
581
582static int lcd_getbgcolor(void)
583{
584 return lcd_color_bg;
585}
586
587
588
589
590static inline ushort *configuration_get_cmap(void)
591{
592#if defined CONFIG_CPU_PXA
593 struct pxafb_info *fbi = &panel_info.pxa;
594 return (ushort *)fbi->palette;
595#elif defined(CONFIG_MPC823)
596 immap_t *immr = (immap_t *) CONFIG_SYS_IMMR;
597 cpm8xx_t *cp = &(immr->im_cpm);
598 return (ushort *)&(cp->lcd_cmap[255 * sizeof(ushort)]);
599#elif defined(CONFIG_ATMEL_LCD)
600 return (ushort *)(panel_info.mmio + ATMEL_LCDC_LUT(0));
601#elif !defined(CONFIG_ATMEL_HLCD) && !defined(CONFIG_EXYNOS_FB)
602 return panel_info.cmap;
603#elif defined(CONFIG_LCD_LOGO)
604 return bmp_logo_palette;
605#else
606 return NULL;
607#endif
608}
609
610#ifdef CONFIG_LCD_LOGO
611void bitmap_plot(int x, int y)
612{
613#ifdef CONFIG_ATMEL_LCD
614 uint *cmap = (uint *)bmp_logo_palette;
615#else
616 ushort *cmap = (ushort *)bmp_logo_palette;
617#endif
618 ushort i, j;
619 uchar *bmap;
620 uchar *fb;
621 ushort *fb16;
622#if defined(CONFIG_MPC823)
623 immap_t *immr = (immap_t *) CONFIG_SYS_IMMR;
624 cpm8xx_t *cp = &(immr->im_cpm);
625#endif
626 unsigned bpix = NBITS(panel_info.vl_bpix);
627
628 debug("Logo: width %d height %d colors %d cmap %d\n",
629 BMP_LOGO_WIDTH, BMP_LOGO_HEIGHT, BMP_LOGO_COLORS,
630 ARRAY_SIZE(bmp_logo_palette));
631
632 bmap = &bmp_logo_bitmap[0];
633 fb = (uchar *)(lcd_base + y * lcd_line_length + x * bpix / 8);
634
635 if (bpix < 12) {
636
637
638
639
640
641#if defined(CONFIG_MPC823)
642 cmap = (ushort *) &(cp->lcd_cmap[BMP_LOGO_OFFSET * sizeof(ushort)]);
643#elif defined(CONFIG_ATMEL_LCD)
644 cmap = (uint *)configuration_get_cmap();
645#else
646 cmap = configuration_get_cmap();
647#endif
648
649 WATCHDOG_RESET();
650
651
652 for (i = 0; i < ARRAY_SIZE(bmp_logo_palette); ++i) {
653 ushort colreg = bmp_logo_palette[i];
654#ifdef CONFIG_ATMEL_LCD
655 uint lut_entry;
656#ifdef CONFIG_ATMEL_LCD_BGR555
657 lut_entry = ((colreg & 0x000F) << 11) |
658 ((colreg & 0x00F0) << 2) |
659 ((colreg & 0x0F00) >> 7);
660#else
661 lut_entry = ((colreg & 0x000F) << 1) |
662 ((colreg & 0x00F0) << 3) |
663 ((colreg & 0x0F00) << 4);
664#endif
665 *(cmap + BMP_LOGO_OFFSET) = lut_entry;
666 cmap++;
667#else
668#ifdef CONFIG_SYS_INVERT_COLORS
669 *cmap++ = 0xffff - colreg;
670#else
671 *cmap++ = colreg;
672#endif
673#endif
674 }
675
676 WATCHDOG_RESET();
677
678 for (i = 0; i < BMP_LOGO_HEIGHT; ++i) {
679 memcpy(fb, bmap, BMP_LOGO_WIDTH);
680 bmap += BMP_LOGO_WIDTH;
681 fb += panel_info.vl_col;
682 }
683 }
684 else {
685 u16 col16;
686 fb16 = (ushort *)fb;
687 for (i = 0; i < BMP_LOGO_HEIGHT; ++i) {
688 for (j = 0; j < BMP_LOGO_WIDTH; j++) {
689 col16 = bmp_logo_palette[(bmap[j]-16)];
690 fb16[j] =
691 ((col16 & 0x000F) << 1) |
692 ((col16 & 0x00F0) << 3) |
693 ((col16 & 0x0F00) << 4);
694 }
695 bmap += BMP_LOGO_WIDTH;
696 fb16 += panel_info.vl_col;
697 }
698 }
699
700 WATCHDOG_RESET();
701 lcd_sync();
702}
703#else
704static inline void bitmap_plot(int x, int y) {}
705#endif
706
707
708#if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN)
709
710
711
712
713
714#ifdef CONFIG_SPLASH_SCREEN_ALIGN
715#define BMP_ALIGN_CENTER 0x7FFF
716
717static void splash_align_axis(int *axis, unsigned long panel_size,
718 unsigned long picture_size)
719{
720 unsigned long panel_picture_delta = panel_size - picture_size;
721 unsigned long axis_alignment;
722
723 if (*axis == BMP_ALIGN_CENTER)
724 axis_alignment = panel_picture_delta / 2;
725 else if (*axis < 0)
726 axis_alignment = panel_picture_delta + *axis + 1;
727 else
728 return;
729
730 *axis = max(0, axis_alignment);
731}
732#endif
733
734
735#ifdef CONFIG_LCD_BMP_RLE8
736
737#define BMP_RLE8_ESCAPE 0
738#define BMP_RLE8_EOL 0
739#define BMP_RLE8_EOBMP 1
740#define BMP_RLE8_DELTA 2
741
742static void draw_unencoded_bitmap(ushort **fbp, uchar *bmap, ushort *cmap,
743 int cnt)
744{
745 while (cnt > 0) {
746 *(*fbp)++ = cmap[*bmap++];
747 cnt--;
748 }
749}
750
751static void draw_encoded_bitmap(ushort **fbp, ushort c, int cnt)
752{
753 ushort *fb = *fbp;
754 int cnt_8copy = cnt >> 3;
755
756 cnt -= cnt_8copy << 3;
757 while (cnt_8copy > 0) {
758 *fb++ = c;
759 *fb++ = c;
760 *fb++ = c;
761 *fb++ = c;
762 *fb++ = c;
763 *fb++ = c;
764 *fb++ = c;
765 *fb++ = c;
766 cnt_8copy--;
767 }
768 while (cnt > 0) {
769 *fb++ = c;
770 cnt--;
771 }
772 *fbp = fb;
773}
774
775
776
777
778static void lcd_display_rle8_bitmap(bmp_image_t *bmp, ushort *cmap, uchar *fb,
779 int x_off, int y_off)
780{
781 uchar *bmap;
782 ulong width, height;
783 ulong cnt, runlen;
784 int x, y;
785 int decode = 1;
786
787 width = le32_to_cpu(bmp->header.width);
788 height = le32_to_cpu(bmp->header.height);
789 bmap = (uchar *)bmp + le32_to_cpu(bmp->header.data_offset);
790
791 x = 0;
792 y = height - 1;
793
794 while (decode) {
795 if (bmap[0] == BMP_RLE8_ESCAPE) {
796 switch (bmap[1]) {
797 case BMP_RLE8_EOL:
798
799 bmap += 2;
800 x = 0;
801 y--;
802
803 fb -= (width * 2 + lcd_line_length);
804 break;
805 case BMP_RLE8_EOBMP:
806
807 decode = 0;
808 break;
809 case BMP_RLE8_DELTA:
810
811 x += bmap[2];
812 y -= bmap[3];
813
814 fb = (uchar *) (lcd_base + (y + y_off - 1)
815 * lcd_line_length + (x + x_off) * 2);
816 bmap += 4;
817 break;
818 default:
819
820 runlen = bmap[1];
821 bmap += 2;
822 if (y < height) {
823 if (x < width) {
824 if (x + runlen > width)
825 cnt = width - x;
826 else
827 cnt = runlen;
828 draw_unencoded_bitmap(
829 (ushort **)&fb,
830 bmap, cmap, cnt);
831 }
832 x += runlen;
833 }
834 bmap += runlen;
835 if (runlen & 1)
836 bmap++;
837 }
838 } else {
839
840 if (y < height) {
841 runlen = bmap[0];
842 if (x < width) {
843
844 while (bmap[0] == 0xff &&
845 bmap[2] != BMP_RLE8_ESCAPE &&
846 bmap[1] == bmap[3]) {
847 runlen += bmap[2];
848 bmap += 2;
849 }
850 if (x + runlen > width)
851 cnt = width - x;
852 else
853 cnt = runlen;
854 draw_encoded_bitmap((ushort **)&fb,
855 cmap[bmap[1]], cnt);
856 }
857 x += runlen;
858 }
859 bmap += 2;
860 }
861 }
862}
863#endif
864
865#if defined(CONFIG_MPC823) || defined(CONFIG_MCC200)
866#define FB_PUT_BYTE(fb, from) *(fb)++ = (255 - *(from)++)
867#else
868#define FB_PUT_BYTE(fb, from) *(fb)++ = *(from)++
869#endif
870
871#if defined(CONFIG_BMP_16BPP)
872#if defined(CONFIG_ATMEL_LCD_BGR555)
873static inline void fb_put_word(uchar **fb, uchar **from)
874{
875 *(*fb)++ = (((*from)[0] & 0x1f) << 2) | ((*from)[1] & 0x03);
876 *(*fb)++ = ((*from)[0] & 0xe0) | (((*from)[1] & 0x7c) >> 2);
877 *from += 2;
878}
879#else
880static inline void fb_put_word(uchar **fb, uchar **from)
881{
882 *(*fb)++ = *(*from)++;
883 *(*fb)++ = *(*from)++;
884}
885#endif
886#endif
887
888int lcd_display_bitmap(ulong bmp_image, int x, int y)
889{
890#if !defined(CONFIG_MCC200)
891 ushort *cmap = NULL;
892#endif
893 ushort *cmap_base = NULL;
894 ushort i, j;
895 uchar *fb;
896 bmp_image_t *bmp=(bmp_image_t *)bmp_image;
897 uchar *bmap;
898 ushort padded_width;
899 unsigned long width, height, byte_width;
900 unsigned long pwidth = panel_info.vl_col;
901 unsigned colors, bpix, bmp_bpix;
902
903 if (!bmp || !(bmp->header.signature[0] == 'B' &&
904 bmp->header.signature[1] == 'M')) {
905 printf("Error: no valid bmp image at %lx\n", bmp_image);
906
907 return 1;
908 }
909
910 width = le32_to_cpu(bmp->header.width);
911 height = le32_to_cpu(bmp->header.height);
912 bmp_bpix = le16_to_cpu(bmp->header.bit_count);
913 colors = 1 << bmp_bpix;
914
915 bpix = NBITS(panel_info.vl_bpix);
916
917 if (bpix != 1 && bpix != 8 && bpix != 16 && bpix != 32) {
918 printf ("Error: %d bit/pixel mode, but BMP has %d bit/pixel\n",
919 bpix, bmp_bpix);
920
921 return 1;
922 }
923
924
925 if (bpix != bmp_bpix && !(bmp_bpix == 8 && bpix == 16)) {
926 printf ("Error: %d bit/pixel mode, but BMP has %d bit/pixel\n",
927 bpix,
928 le16_to_cpu(bmp->header.bit_count));
929
930 return 1;
931 }
932
933 debug("Display-bmp: %d x %d with %d colors\n",
934 (int)width, (int)height, (int)colors);
935
936#if !defined(CONFIG_MCC200)
937
938 if (bmp_bpix == 8) {
939 cmap = configuration_get_cmap();
940 cmap_base = cmap;
941
942
943 for (i = 0; i < colors; ++i) {
944 bmp_color_table_entry_t cte = bmp->color_table[i];
945#if !defined(CONFIG_ATMEL_LCD)
946 ushort colreg =
947 ( ((cte.red) << 8) & 0xf800) |
948 ( ((cte.green) << 3) & 0x07e0) |
949 ( ((cte.blue) >> 3) & 0x001f) ;
950#ifdef CONFIG_SYS_INVERT_COLORS
951 *cmap = 0xffff - colreg;
952#else
953 *cmap = colreg;
954#endif
955#if defined(CONFIG_MPC823)
956 cmap--;
957#else
958 cmap++;
959#endif
960#else
961 lcd_setcolreg(i, cte.red, cte.green, cte.blue);
962#endif
963 }
964 }
965#endif
966
967
968
969
970
971
972
973
974
975
976
977#if defined(CONFIG_MCC200)
978 if (bpix == 1) {
979 width = ((width + 7) & ~7) >> 3;
980 x = ((x + 7) & ~7) >> 3;
981 pwidth= ((pwidth + 7) & ~7) >> 3;
982 }
983#endif
984
985 padded_width = (width & 0x3 ? (width & ~0x3) + 4 : width);
986
987#ifdef CONFIG_SPLASH_SCREEN_ALIGN
988 splash_align_axis(&x, pwidth, width);
989 splash_align_axis(&y, panel_info.vl_row, height);
990#endif
991
992 if ((x + width) > pwidth)
993 width = pwidth - x;
994 if ((y + height) > panel_info.vl_row)
995 height = panel_info.vl_row - y;
996
997 bmap = (uchar *) bmp + le32_to_cpu(bmp->header.data_offset);
998 fb = (uchar *) (lcd_base +
999 (y + height - 1) * lcd_line_length + x * bpix / 8);
1000
1001 switch (bmp_bpix) {
1002 case 1:
1003 case 8:
1004#ifdef CONFIG_LCD_BMP_RLE8
1005 if (le32_to_cpu(bmp->header.compression) == BMP_BI_RLE8) {
1006 if (bpix != 16) {
1007
1008 printf("Error: only support 16 bpix");
1009 return 1;
1010 }
1011 lcd_display_rle8_bitmap(bmp, cmap_base, fb, x, y);
1012 break;
1013 }
1014#endif
1015
1016 if (bpix != 16)
1017 byte_width = width;
1018 else
1019 byte_width = width * 2;
1020
1021 for (i = 0; i < height; ++i) {
1022 WATCHDOG_RESET();
1023 for (j = 0; j < width; j++) {
1024 if (bpix != 16) {
1025 FB_PUT_BYTE(fb, bmap);
1026 } else {
1027 *(uint16_t *)fb = cmap_base[*(bmap++)];
1028 fb += sizeof(uint16_t) / sizeof(*fb);
1029 }
1030 }
1031 bmap += (padded_width - width);
1032 fb -= byte_width + lcd_line_length;
1033 }
1034 break;
1035
1036#if defined(CONFIG_BMP_16BPP)
1037 case 16:
1038 for (i = 0; i < height; ++i) {
1039 WATCHDOG_RESET();
1040 for (j = 0; j < width; j++)
1041 fb_put_word(&fb, &bmap);
1042
1043 bmap += (padded_width - width) * 2;
1044 fb -= width * 2 + lcd_line_length;
1045 }
1046 break;
1047#endif
1048
1049#if defined(CONFIG_BMP_32BPP)
1050 case 32:
1051 for (i = 0; i < height; ++i) {
1052 for (j = 0; j < width; j++) {
1053 *(fb++) = *(bmap++);
1054 *(fb++) = *(bmap++);
1055 *(fb++) = *(bmap++);
1056 *(fb++) = *(bmap++);
1057 }
1058 fb -= lcd_line_length + width * (bpix / 8);
1059 }
1060 break;
1061#endif
1062 default:
1063 break;
1064 };
1065
1066 lcd_sync();
1067 return 0;
1068}
1069#endif
1070
1071#ifdef CONFIG_SPLASH_SCREEN_PREPARE
1072static inline int splash_screen_prepare(void)
1073{
1074 return board_splash_screen_prepare();
1075}
1076#else
1077static inline int splash_screen_prepare(void)
1078{
1079 return 0;
1080}
1081#endif
1082
1083static void *lcd_logo(void)
1084{
1085#ifdef CONFIG_SPLASH_SCREEN
1086 char *s;
1087 ulong addr;
1088 static int do_splash = 1;
1089
1090 if (do_splash && (s = getenv("splashimage")) != NULL) {
1091 int x = 0, y = 0;
1092 do_splash = 0;
1093
1094 if (splash_screen_prepare())
1095 return (void *)gd->fb_base;
1096
1097 addr = simple_strtoul (s, NULL, 16);
1098#ifdef CONFIG_SPLASH_SCREEN_ALIGN
1099 s = getenv("splashpos");
1100 if (s != NULL) {
1101 if (s[0] == 'm')
1102 x = BMP_ALIGN_CENTER;
1103 else
1104 x = simple_strtol(s, NULL, 0);
1105
1106 s = strchr(s + 1, ',');
1107 if (s != NULL) {
1108 if (s[1] == 'm')
1109 y = BMP_ALIGN_CENTER;
1110 else
1111 y = simple_strtol (s + 1, NULL, 0);
1112 }
1113 }
1114#endif
1115
1116 if (bmp_display(addr, x, y) == 0)
1117 return (void *)lcd_base;
1118 }
1119#endif
1120
1121 bitmap_plot(0, 0);
1122
1123#ifdef CONFIG_LCD_INFO
1124 console_col = LCD_INFO_X / VIDEO_FONT_WIDTH;
1125 console_row = LCD_INFO_Y / VIDEO_FONT_HEIGHT;
1126 lcd_show_board_info();
1127#endif
1128
1129#if defined(CONFIG_LCD_LOGO) && !defined(CONFIG_LCD_INFO_BELOW_LOGO)
1130 return (void *)((ulong)lcd_base + BMP_LOGO_HEIGHT * lcd_line_length);
1131#else
1132 return (void *)lcd_base;
1133#endif
1134}
1135
1136#ifdef CONFIG_SPLASHIMAGE_GUARD
1137static int on_splashimage(const char *name, const char *value, enum env_op op,
1138 int flags)
1139{
1140 ulong addr;
1141 int aligned;
1142
1143 if (op == env_op_delete)
1144 return 0;
1145
1146 addr = simple_strtoul(value, NULL, 16);
1147
1148 aligned = (addr % 4 == 2);
1149 if (!aligned) {
1150 printf("Invalid splashimage value. Value must be 16 bit aligned, but not 32 bit aligned\n");
1151 return -1;
1152 }
1153
1154 return 0;
1155}
1156
1157U_BOOT_ENV_CALLBACK(splashimage, on_splashimage);
1158#endif
1159
1160void lcd_position_cursor(unsigned col, unsigned row)
1161{
1162 console_col = min(col, CONSOLE_COLS - 1);
1163 console_row = min(row, CONSOLE_ROWS - 1);
1164}
1165
1166int lcd_get_pixel_width(void)
1167{
1168 return panel_info.vl_col;
1169}
1170
1171int lcd_get_pixel_height(void)
1172{
1173 return panel_info.vl_row;
1174}
1175
1176int lcd_get_screen_rows(void)
1177{
1178 return CONSOLE_ROWS;
1179}
1180
1181int lcd_get_screen_columns(void)
1182{
1183 return CONSOLE_COLS;
1184}
1185