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