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