1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Common LCD routines
4 *
5 * (C) Copyright 2001-2002
6 * Wolfgang Denk, DENX Software Engineering -- wd@denx.de
7 */
8
9 /* #define DEBUG */
10 #include <config.h>
11 #include <common.h>
12 #include <command.h>
13 #include <env_callback.h>
14 #include <linux/types.h>
15 #include <stdio_dev.h>
16 #include <lcd.h>
17 #include <mapmem.h>
18 #include <watchdog.h>
19 #include <asm/unaligned.h>
20 #include <splash.h>
21 #include <asm/io.h>
22 #include <asm/unaligned.h>
23 #include <video_font.h>
24
25 #ifdef CONFIG_LCD_LOGO
26 #include <bmp_logo.h>
27 #include <bmp_logo_data.h>
28 #if (CONSOLE_COLOR_WHITE >= BMP_LOGO_OFFSET) && (LCD_BPP != LCD_COLOR16)
29 #error Default Color Map overlaps with Logo Color Map
30 #endif
31 #endif
32
33 #ifndef CONFIG_LCD_ALIGNMENT
34 #define CONFIG_LCD_ALIGNMENT PAGE_SIZE
35 #endif
36
37 #if (LCD_BPP != LCD_COLOR8) && (LCD_BPP != LCD_COLOR16) && \
38 (LCD_BPP != LCD_COLOR32)
39 #error Unsupported LCD BPP.
40 #endif
41
42 DECLARE_GLOBAL_DATA_PTR;
43
44 static int lcd_init(void *lcdbase);
45 static void lcd_logo(void);
46 static void lcd_setfgcolor(int color);
47 static void lcd_setbgcolor(int color);
48
49 static int lcd_color_fg;
50 static int lcd_color_bg;
51 int lcd_line_length;
52 char lcd_is_enabled = 0;
53 static void *lcd_base; /* Start of framebuffer memory */
54 static char lcd_flush_dcache; /* 1 to flush dcache after each lcd update */
55
56 /* Flush LCD activity to the caches */
lcd_sync(void)57 void lcd_sync(void)
58 {
59 /*
60 * flush_dcache_range() is declared in common.h but it seems that some
61 * architectures do not actually implement it. Is there a way to find
62 * out whether it exists? For now, ARM is safe.
63 */
64 #if defined(CONFIG_ARM) && !defined(CONFIG_SYS_DCACHE_OFF)
65 int line_length;
66
67 if (lcd_flush_dcache)
68 flush_dcache_range((ulong)lcd_base,
69 (ulong)(lcd_base + lcd_get_size(&line_length)));
70 #endif
71 }
72
lcd_set_flush_dcache(int flush)73 void lcd_set_flush_dcache(int flush)
74 {
75 lcd_flush_dcache = (flush != 0);
76 }
77
lcd_stub_putc(struct stdio_dev * dev,const char c)78 static void lcd_stub_putc(struct stdio_dev *dev, const char c)
79 {
80 lcd_putc(c);
81 }
82
lcd_stub_puts(struct stdio_dev * dev,const char * s)83 static void lcd_stub_puts(struct stdio_dev *dev, const char *s)
84 {
85 lcd_puts(s);
86 }
87
88 /* Small utility to check that you got the colours right */
89 #ifdef LCD_TEST_PATTERN
90
91 #if LCD_BPP == LCD_COLOR8
92 #define N_BLK_VERT 2
93 #define N_BLK_HOR 3
94
95 static int test_colors[N_BLK_HOR * N_BLK_VERT] = {
96 CONSOLE_COLOR_RED, CONSOLE_COLOR_GREEN, CONSOLE_COLOR_YELLOW,
97 CONSOLE_COLOR_BLUE, CONSOLE_COLOR_MAGENTA, CONSOLE_COLOR_CYAN,
98 }; /*LCD_BPP == LCD_COLOR8 */
99
100 #elif LCD_BPP == LCD_COLOR16
101 #define N_BLK_VERT 2
102 #define N_BLK_HOR 4
103
104 static int test_colors[N_BLK_HOR * N_BLK_VERT] = {
105 CONSOLE_COLOR_RED, CONSOLE_COLOR_GREEN, CONSOLE_COLOR_YELLOW, CONSOLE_COLOR_BLUE,
106 CONSOLE_COLOR_MAGENTA, CONSOLE_COLOR_CYAN, CONSOLE_COLOR_GREY, CONSOLE_COLOR_WHITE,
107 };
108 #endif /*LCD_BPP == LCD_COLOR16 */
109
test_pattern(void)110 static void test_pattern(void)
111 {
112 ushort v_max = panel_info.vl_row;
113 ushort h_max = panel_info.vl_col;
114 ushort v_step = (v_max + N_BLK_VERT - 1) / N_BLK_VERT;
115 ushort h_step = (h_max + N_BLK_HOR - 1) / N_BLK_HOR;
116 ushort v, h;
117 #if LCD_BPP == LCD_COLOR8
118 uchar *pix = (uchar *)lcd_base;
119 #elif LCD_BPP == LCD_COLOR16
120 ushort *pix = (ushort *)lcd_base;
121 #endif
122
123 printf("[LCD] Test Pattern: %d x %d [%d x %d]\n",
124 h_max, v_max, h_step, v_step);
125
126 for (v = 0; v < v_max; ++v) {
127 uchar iy = v / v_step;
128 for (h = 0; h < h_max; ++h) {
129 uchar ix = N_BLK_HOR * iy + h / h_step;
130 *pix++ = test_colors[ix];
131 }
132 }
133 }
134 #endif /* LCD_TEST_PATTERN */
135
136 /*
137 * With most lcd drivers the line length is set up
138 * by calculating it from panel_info parameters. Some
139 * drivers need to calculate the line length differently,
140 * so make the function weak to allow overriding it.
141 */
lcd_get_size(int * line_length)142 __weak int lcd_get_size(int *line_length)
143 {
144 *line_length = (panel_info.vl_col * NBITS(panel_info.vl_bpix)) / 8;
145 return *line_length * panel_info.vl_row;
146 }
147
drv_lcd_init(void)148 int drv_lcd_init(void)
149 {
150 struct stdio_dev lcddev;
151 int rc;
152
153 lcd_base = map_sysmem(gd->fb_base, 0);
154
155 lcd_init(lcd_base);
156
157 /* Device initialization */
158 memset(&lcddev, 0, sizeof(lcddev));
159
160 strcpy(lcddev.name, "lcd");
161 lcddev.ext = 0; /* No extensions */
162 lcddev.flags = DEV_FLAGS_OUTPUT; /* Output only */
163 lcddev.putc = lcd_stub_putc; /* 'putc' function */
164 lcddev.puts = lcd_stub_puts; /* 'puts' function */
165
166 rc = stdio_register(&lcddev);
167
168 return (rc == 0) ? 1 : rc;
169 }
170
lcd_clear(void)171 void lcd_clear(void)
172 {
173 int bg_color;
174 char *s;
175 ulong addr;
176 static int do_splash = 1;
177 #if LCD_BPP == LCD_COLOR8
178 /* Setting the palette */
179 lcd_setcolreg(CONSOLE_COLOR_BLACK, 0, 0, 0);
180 lcd_setcolreg(CONSOLE_COLOR_RED, 0xFF, 0, 0);
181 lcd_setcolreg(CONSOLE_COLOR_GREEN, 0, 0xFF, 0);
182 lcd_setcolreg(CONSOLE_COLOR_YELLOW, 0xFF, 0xFF, 0);
183 lcd_setcolreg(CONSOLE_COLOR_BLUE, 0, 0, 0xFF);
184 lcd_setcolreg(CONSOLE_COLOR_MAGENTA, 0xFF, 0, 0xFF);
185 lcd_setcolreg(CONSOLE_COLOR_CYAN, 0, 0xFF, 0xFF);
186 lcd_setcolreg(CONSOLE_COLOR_GREY, 0xAA, 0xAA, 0xAA);
187 lcd_setcolreg(CONSOLE_COLOR_WHITE, 0xFF, 0xFF, 0xFF);
188 #endif
189
190 #ifndef CONFIG_SYS_WHITE_ON_BLACK
191 lcd_setfgcolor(CONSOLE_COLOR_BLACK);
192 lcd_setbgcolor(CONSOLE_COLOR_WHITE);
193 bg_color = CONSOLE_COLOR_WHITE;
194 #else
195 lcd_setfgcolor(CONSOLE_COLOR_WHITE);
196 lcd_setbgcolor(CONSOLE_COLOR_BLACK);
197 bg_color = CONSOLE_COLOR_BLACK;
198 #endif /* CONFIG_SYS_WHITE_ON_BLACK */
199
200 #ifdef LCD_TEST_PATTERN
201 test_pattern();
202 #else
203 /* set framebuffer to background color */
204 #if (LCD_BPP != LCD_COLOR32)
205 memset((char *)lcd_base, bg_color, lcd_line_length * panel_info.vl_row);
206 #else
207 u32 *ppix = lcd_base;
208 u32 i;
209 for (i = 0;
210 i < (lcd_line_length * panel_info.vl_row)/NBYTES(panel_info.vl_bpix);
211 i++) {
212 *ppix++ = bg_color;
213 }
214 #endif
215 #endif
216 /* setup text-console */
217 debug("[LCD] setting up console...\n");
218 lcd_init_console(lcd_base,
219 panel_info.vl_col,
220 panel_info.vl_row,
221 panel_info.vl_rot);
222 /* Paint the logo and retrieve LCD base address */
223 debug("[LCD] Drawing the logo...\n");
224 if (do_splash) {
225 s = env_get("splashimage");
226 if (s) {
227 do_splash = 0;
228 addr = simple_strtoul(s, NULL, 16);
229 if (lcd_splash(addr) == 0) {
230 lcd_sync();
231 return;
232 }
233 }
234 }
235
236 lcd_logo();
237 #if defined(CONFIG_LCD_LOGO) && !defined(CONFIG_LCD_INFO_BELOW_LOGO)
238 addr = (ulong)lcd_base + BMP_LOGO_HEIGHT * lcd_line_length;
239 lcd_init_console((void *)addr, panel_info.vl_col,
240 panel_info.vl_row, panel_info.vl_rot);
241 #endif
242 lcd_sync();
243 }
244
do_lcd_clear(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])245 static int do_lcd_clear(cmd_tbl_t *cmdtp, int flag, int argc,
246 char *const argv[])
247 {
248 lcd_clear();
249 return 0;
250 }
251 U_BOOT_CMD(cls, 1, 1, do_lcd_clear, "clear screen", "");
252
lcd_init(void * lcdbase)253 static int lcd_init(void *lcdbase)
254 {
255 debug("[LCD] Initializing LCD frambuffer at %p\n", lcdbase);
256 lcd_ctrl_init(lcdbase);
257
258 /*
259 * lcd_ctrl_init() of some drivers (i.e. bcm2835 on rpi) ignores
260 * the 'lcdbase' argument and uses custom lcd base address
261 * by setting up gd->fb_base. Check for this condition and fixup
262 * 'lcd_base' address.
263 */
264 if (map_to_sysmem(lcdbase) != gd->fb_base)
265 lcd_base = map_sysmem(gd->fb_base, 0);
266
267 debug("[LCD] Using LCD frambuffer at %p\n", lcd_base);
268
269 lcd_get_size(&lcd_line_length);
270 lcd_is_enabled = 1;
271 lcd_clear();
272 lcd_enable();
273
274 /* Initialize the console */
275 lcd_set_col(0);
276 #ifdef CONFIG_LCD_INFO_BELOW_LOGO
277 lcd_set_row(7 + BMP_LOGO_HEIGHT / VIDEO_FONT_HEIGHT);
278 #else
279 lcd_set_row(1); /* leave 1 blank line below logo */
280 #endif
281
282 return 0;
283 }
284
285 /*
286 * This is called early in the system initialization to grab memory
287 * for the LCD controller.
288 * Returns new address for monitor, after reserving LCD buffer memory
289 *
290 * Note that this is running from ROM, so no write access to global data.
291 */
lcd_setmem(ulong addr)292 ulong lcd_setmem(ulong addr)
293 {
294 ulong size;
295 int line_length;
296
297 debug("LCD panel info: %d x %d, %d bit/pix\n", panel_info.vl_col,
298 panel_info.vl_row, NBITS(panel_info.vl_bpix));
299
300 size = lcd_get_size(&line_length);
301
302 /* Round up to nearest full page, or MMU section if defined */
303 size = ALIGN(size, CONFIG_LCD_ALIGNMENT);
304 addr = ALIGN(addr - CONFIG_LCD_ALIGNMENT + 1, CONFIG_LCD_ALIGNMENT);
305
306 /* Allocate pages for the frame buffer. */
307 addr -= size;
308
309 debug("Reserving %ldk for LCD Framebuffer at: %08lx\n",
310 size >> 10, addr);
311
312 return addr;
313 }
314
lcd_setfgcolor(int color)315 static void lcd_setfgcolor(int color)
316 {
317 lcd_color_fg = color;
318 }
319
lcd_getfgcolor(void)320 int lcd_getfgcolor(void)
321 {
322 return lcd_color_fg;
323 }
324
lcd_setbgcolor(int color)325 static void lcd_setbgcolor(int color)
326 {
327 lcd_color_bg = color;
328 }
329
lcd_getbgcolor(void)330 int lcd_getbgcolor(void)
331 {
332 return lcd_color_bg;
333 }
334
335 #ifdef CONFIG_LCD_LOGO
lcd_logo_set_cmap(void)336 __weak void lcd_logo_set_cmap(void)
337 {
338 int i;
339 ushort *cmap = configuration_get_cmap();
340
341 for (i = 0; i < ARRAY_SIZE(bmp_logo_palette); ++i)
342 *cmap++ = bmp_logo_palette[i];
343 }
344
lcd_logo_plot(int x,int y)345 void lcd_logo_plot(int x, int y)
346 {
347 ushort i, j;
348 uchar *bmap = &bmp_logo_bitmap[0];
349 unsigned bpix = NBITS(panel_info.vl_bpix);
350 uchar *fb = (uchar *)(lcd_base + y * lcd_line_length + x * bpix / 8);
351 ushort *fb16;
352
353 debug("Logo: width %d height %d colors %d\n",
354 BMP_LOGO_WIDTH, BMP_LOGO_HEIGHT, BMP_LOGO_COLORS);
355
356 if (bpix < 12) {
357 WATCHDOG_RESET();
358 lcd_logo_set_cmap();
359 WATCHDOG_RESET();
360
361 for (i = 0; i < BMP_LOGO_HEIGHT; ++i) {
362 memcpy(fb, bmap, BMP_LOGO_WIDTH);
363 bmap += BMP_LOGO_WIDTH;
364 fb += panel_info.vl_col;
365 }
366 }
367 else { /* true color mode */
368 u16 col16;
369 fb16 = (ushort *)fb;
370 for (i = 0; i < BMP_LOGO_HEIGHT; ++i) {
371 for (j = 0; j < BMP_LOGO_WIDTH; j++) {
372 col16 = bmp_logo_palette[(bmap[j]-16)];
373 fb16[j] =
374 ((col16 & 0x000F) << 1) |
375 ((col16 & 0x00F0) << 3) |
376 ((col16 & 0x0F00) << 4);
377 }
378 bmap += BMP_LOGO_WIDTH;
379 fb16 += panel_info.vl_col;
380 }
381 }
382
383 WATCHDOG_RESET();
384 lcd_sync();
385 }
386 #else
lcd_logo_plot(int x,int y)387 static inline void lcd_logo_plot(int x, int y) {}
388 #endif /* CONFIG_LCD_LOGO */
389
390 #if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN)
391 #ifdef CONFIG_SPLASH_SCREEN_ALIGN
392 #define BMP_ALIGN_CENTER 0x7FFF
393
splash_align_axis(int * axis,unsigned long panel_size,unsigned long picture_size)394 static void splash_align_axis(int *axis, unsigned long panel_size,
395 unsigned long picture_size)
396 {
397 unsigned long panel_picture_delta = panel_size - picture_size;
398 unsigned long axis_alignment;
399
400 if (*axis == BMP_ALIGN_CENTER)
401 axis_alignment = panel_picture_delta / 2;
402 else if (*axis < 0)
403 axis_alignment = panel_picture_delta + *axis + 1;
404 else
405 return;
406
407 *axis = max(0, (int)axis_alignment);
408 }
409 #endif
410
411 #ifdef CONFIG_LCD_BMP_RLE8
412 #define BMP_RLE8_ESCAPE 0
413 #define BMP_RLE8_EOL 0
414 #define BMP_RLE8_EOBMP 1
415 #define BMP_RLE8_DELTA 2
416
draw_unencoded_bitmap(ushort ** fbp,uchar * bmap,ushort * cmap,int cnt)417 static void draw_unencoded_bitmap(ushort **fbp, uchar *bmap, ushort *cmap,
418 int cnt)
419 {
420 while (cnt > 0) {
421 *(*fbp)++ = cmap[*bmap++];
422 cnt--;
423 }
424 }
425
draw_encoded_bitmap(ushort ** fbp,ushort c,int cnt)426 static void draw_encoded_bitmap(ushort **fbp, ushort c, int cnt)
427 {
428 ushort *fb = *fbp;
429 int cnt_8copy = cnt >> 3;
430
431 cnt -= cnt_8copy << 3;
432 while (cnt_8copy > 0) {
433 *fb++ = c;
434 *fb++ = c;
435 *fb++ = c;
436 *fb++ = c;
437 *fb++ = c;
438 *fb++ = c;
439 *fb++ = c;
440 *fb++ = c;
441 cnt_8copy--;
442 }
443 while (cnt > 0) {
444 *fb++ = c;
445 cnt--;
446 }
447 *fbp = fb;
448 }
449
450 /*
451 * Do not call this function directly, must be called from lcd_display_bitmap.
452 */
lcd_display_rle8_bitmap(struct bmp_image * bmp,ushort * cmap,uchar * fb,int x_off,int y_off)453 static void lcd_display_rle8_bitmap(struct bmp_image *bmp, ushort *cmap,
454 uchar *fb, int x_off, int y_off)
455 {
456 uchar *bmap;
457 ulong width, height;
458 ulong cnt, runlen;
459 int x, y;
460 int decode = 1;
461
462 width = get_unaligned_le32(&bmp->header.width);
463 height = get_unaligned_le32(&bmp->header.height);
464 bmap = (uchar *)bmp + get_unaligned_le32(&bmp->header.data_offset);
465
466 x = 0;
467 y = height - 1;
468
469 while (decode) {
470 if (bmap[0] == BMP_RLE8_ESCAPE) {
471 switch (bmap[1]) {
472 case BMP_RLE8_EOL:
473 /* end of line */
474 bmap += 2;
475 x = 0;
476 y--;
477 /* 16bpix, 2-byte per pixel, width should *2 */
478 fb -= (width * 2 + lcd_line_length);
479 break;
480 case BMP_RLE8_EOBMP:
481 /* end of bitmap */
482 decode = 0;
483 break;
484 case BMP_RLE8_DELTA:
485 /* delta run */
486 x += bmap[2];
487 y -= bmap[3];
488 /* 16bpix, 2-byte per pixel, x should *2 */
489 fb = (uchar *) (lcd_base + (y + y_off - 1)
490 * lcd_line_length + (x + x_off) * 2);
491 bmap += 4;
492 break;
493 default:
494 /* unencoded run */
495 runlen = bmap[1];
496 bmap += 2;
497 if (y < height) {
498 if (x < width) {
499 if (x + runlen > width)
500 cnt = width - x;
501 else
502 cnt = runlen;
503 draw_unencoded_bitmap(
504 (ushort **)&fb,
505 bmap, cmap, cnt);
506 }
507 x += runlen;
508 }
509 bmap += runlen;
510 if (runlen & 1)
511 bmap++;
512 }
513 } else {
514 /* encoded run */
515 if (y < height) {
516 runlen = bmap[0];
517 if (x < width) {
518 /* aggregate the same code */
519 while (bmap[0] == 0xff &&
520 bmap[2] != BMP_RLE8_ESCAPE &&
521 bmap[1] == bmap[3]) {
522 runlen += bmap[2];
523 bmap += 2;
524 }
525 if (x + runlen > width)
526 cnt = width - x;
527 else
528 cnt = runlen;
529 draw_encoded_bitmap((ushort **)&fb,
530 cmap[bmap[1]], cnt);
531 }
532 x += runlen;
533 }
534 bmap += 2;
535 }
536 }
537 }
538 #endif
539
fb_put_byte(uchar ** fb,uchar ** from)540 __weak void fb_put_byte(uchar **fb, uchar **from)
541 {
542 *(*fb)++ = *(*from)++;
543 }
544
545 #if defined(CONFIG_BMP_16BPP)
fb_put_word(uchar ** fb,uchar ** from)546 __weak void fb_put_word(uchar **fb, uchar **from)
547 {
548 *(*fb)++ = *(*from)++;
549 *(*fb)++ = *(*from)++;
550 }
551 #endif /* CONFIG_BMP_16BPP */
552
lcd_set_cmap(struct bmp_image * bmp,unsigned colors)553 __weak void lcd_set_cmap(struct bmp_image *bmp, unsigned colors)
554 {
555 int i;
556 struct bmp_color_table_entry cte;
557 ushort *cmap = configuration_get_cmap();
558
559 for (i = 0; i < colors; ++i) {
560 cte = bmp->color_table[i];
561 *cmap = (((cte.red) << 8) & 0xf800) |
562 (((cte.green) << 3) & 0x07e0) |
563 (((cte.blue) >> 3) & 0x001f);
564 cmap++;
565 }
566 }
567
lcd_display_bitmap(ulong bmp_image,int x,int y)568 int lcd_display_bitmap(ulong bmp_image, int x, int y)
569 {
570 ushort *cmap_base = NULL;
571 ushort i, j;
572 uchar *fb;
573 struct bmp_image *bmp = (struct bmp_image *)map_sysmem(bmp_image, 0);
574 uchar *bmap;
575 ushort padded_width;
576 unsigned long width, height, byte_width;
577 unsigned long pwidth = panel_info.vl_col;
578 unsigned colors, bpix, bmp_bpix;
579 int hdr_size;
580 struct bmp_color_table_entry *palette;
581
582 if (!bmp || !(bmp->header.signature[0] == 'B' &&
583 bmp->header.signature[1] == 'M')) {
584 printf("Error: no valid bmp image at %lx\n", bmp_image);
585
586 return 1;
587 }
588
589 palette = bmp->color_table;
590 width = get_unaligned_le32(&bmp->header.width);
591 height = get_unaligned_le32(&bmp->header.height);
592 bmp_bpix = get_unaligned_le16(&bmp->header.bit_count);
593 hdr_size = get_unaligned_le16(&bmp->header.size);
594 debug("hdr_size=%d, bmp_bpix=%d\n", hdr_size, bmp_bpix);
595
596 colors = 1 << bmp_bpix;
597
598 bpix = NBITS(panel_info.vl_bpix);
599
600 if (bpix != 1 && bpix != 8 && bpix != 16 && bpix != 32) {
601 printf ("Error: %d bit/pixel mode, but BMP has %d bit/pixel\n",
602 bpix, bmp_bpix);
603
604 return 1;
605 }
606
607 /*
608 * We support displaying 8bpp BMPs on 16bpp LCDs
609 * and displaying 24bpp BMPs on 32bpp LCDs
610 * */
611 if (bpix != bmp_bpix &&
612 !(bmp_bpix == 8 && bpix == 16) &&
613 !(bmp_bpix == 24 && bpix == 32)) {
614 printf ("Error: %d bit/pixel mode, but BMP has %d bit/pixel\n",
615 bpix, get_unaligned_le16(&bmp->header.bit_count));
616 return 1;
617 }
618
619 debug("Display-bmp: %d x %d with %d colors, display %d\n",
620 (int)width, (int)height, (int)colors, 1 << bpix);
621
622 if (bmp_bpix == 8)
623 lcd_set_cmap(bmp, colors);
624
625 padded_width = (width & 0x3 ? (width & ~0x3) + 4 : width);
626
627 #ifdef CONFIG_SPLASH_SCREEN_ALIGN
628 splash_align_axis(&x, pwidth, width);
629 splash_align_axis(&y, panel_info.vl_row, height);
630 #endif /* CONFIG_SPLASH_SCREEN_ALIGN */
631
632 if ((x + width) > pwidth)
633 width = pwidth - x;
634 if ((y + height) > panel_info.vl_row)
635 height = panel_info.vl_row - y;
636
637 bmap = (uchar *)bmp + get_unaligned_le32(&bmp->header.data_offset);
638 fb = (uchar *)(lcd_base +
639 (y + height - 1) * lcd_line_length + x * bpix / 8);
640
641 switch (bmp_bpix) {
642 case 1:
643 case 8: {
644 cmap_base = configuration_get_cmap();
645 #ifdef CONFIG_LCD_BMP_RLE8
646 u32 compression = get_unaligned_le32(&bmp->header.compression);
647 debug("compressed %d %d\n", compression, BMP_BI_RLE8);
648 if (compression == BMP_BI_RLE8) {
649 if (bpix != 16) {
650 /* TODO implement render code for bpix != 16 */
651 printf("Error: only support 16 bpix");
652 return 1;
653 }
654 lcd_display_rle8_bitmap(bmp, cmap_base, fb, x, y);
655 break;
656 }
657 #endif
658
659 if (bpix != 16)
660 byte_width = width;
661 else
662 byte_width = width * 2;
663
664 for (i = 0; i < height; ++i) {
665 WATCHDOG_RESET();
666 for (j = 0; j < width; j++) {
667 if (bpix != 16) {
668 fb_put_byte(&fb, &bmap);
669 } else {
670 struct bmp_color_table_entry *entry;
671 uint val;
672
673 if (cmap_base) {
674 val = cmap_base[*bmap];
675 } else {
676 entry = &palette[*bmap];
677 val = entry->blue >> 3 |
678 entry->green >> 2 << 5 |
679 entry->red >> 3 << 11;
680 }
681 *(uint16_t *)fb = val;
682 bmap++;
683 fb += sizeof(uint16_t) / sizeof(*fb);
684 }
685 }
686 bmap += (padded_width - width);
687 fb -= byte_width + lcd_line_length;
688 }
689 break;
690 }
691 #if defined(CONFIG_BMP_16BPP)
692 case 16:
693 for (i = 0; i < height; ++i) {
694 WATCHDOG_RESET();
695 for (j = 0; j < width; j++)
696 fb_put_word(&fb, &bmap);
697
698 bmap += (padded_width - width) * 2;
699 fb -= width * 2 + lcd_line_length;
700 }
701 break;
702 #endif /* CONFIG_BMP_16BPP */
703 #if defined(CONFIG_BMP_24BPP)
704 case 24:
705 for (i = 0; i < height; ++i) {
706 for (j = 0; j < width; j++) {
707 *(fb++) = *(bmap++);
708 *(fb++) = *(bmap++);
709 *(fb++) = *(bmap++);
710 *(fb++) = 0;
711 }
712 fb -= lcd_line_length + width * (bpix / 8);
713 }
714 break;
715 #endif /* CONFIG_BMP_24BPP */
716 #if defined(CONFIG_BMP_32BPP)
717 case 32:
718 for (i = 0; i < height; ++i) {
719 for (j = 0; j < width; j++) {
720 *(fb++) = *(bmap++);
721 *(fb++) = *(bmap++);
722 *(fb++) = *(bmap++);
723 *(fb++) = *(bmap++);
724 }
725 fb -= lcd_line_length + width * (bpix / 8);
726 }
727 break;
728 #endif /* CONFIG_BMP_32BPP */
729 default:
730 break;
731 };
732
733 lcd_sync();
734 return 0;
735 }
736 #endif
737
lcd_logo(void)738 static void lcd_logo(void)
739 {
740 lcd_logo_plot(0, 0);
741
742 #ifdef CONFIG_LCD_INFO
743 lcd_set_col(LCD_INFO_X / VIDEO_FONT_WIDTH);
744 lcd_set_row(LCD_INFO_Y / VIDEO_FONT_HEIGHT);
745 lcd_show_board_info();
746 #endif /* CONFIG_LCD_INFO */
747 }
748
749 #ifdef CONFIG_SPLASHIMAGE_GUARD
on_splashimage(const char * name,const char * value,enum env_op op,int flags)750 static int on_splashimage(const char *name, const char *value, enum env_op op,
751 int flags)
752 {
753 ulong addr;
754 int aligned;
755
756 if (op == env_op_delete)
757 return 0;
758
759 addr = simple_strtoul(value, NULL, 16);
760 /* See README.displaying-bmps */
761 aligned = (addr % 4 == 2);
762 if (!aligned) {
763 printf("Invalid splashimage value. Value must be 16 bit aligned, but not 32 bit aligned\n");
764 return -1;
765 }
766
767 return 0;
768 }
769
770 U_BOOT_ENV_CALLBACK(splashimage, on_splashimage);
771 #endif
772
lcd_get_pixel_width(void)773 int lcd_get_pixel_width(void)
774 {
775 return panel_info.vl_col;
776 }
777
lcd_get_pixel_height(void)778 int lcd_get_pixel_height(void)
779 {
780 return panel_info.vl_row;
781 }
782