blob: 055c366b191e32469c100c2d010fa9ba401526ef [file] [log] [blame]
wdenk8655b6f2004-10-09 23:25:58 +00001/*
Nikita Kiryanovc8d2feb2015-02-03 13:32:29 +02002 * Common LCD routines
wdenk8655b6f2004-10-09 23:25:58 +00003 *
4 * (C) Copyright 2001-2002
5 * Wolfgang Denk, DENX Software Engineering -- wd@denx.de
6 *
Wolfgang Denk3765b3e2013-10-07 13:07:26 +02007 * SPDX-License-Identifier: GPL-2.0+
wdenk8655b6f2004-10-09 23:25:58 +00008 */
9
wdenk8655b6f2004-10-09 23:25:58 +000010/* #define DEBUG */
wdenk8655b6f2004-10-09 23:25:58 +000011#include <config.h>
12#include <common.h>
13#include <command.h>
Nikita Kiryanovc0880482013-02-24 21:28:43 +000014#include <env_callback.h>
wdenk8655b6f2004-10-09 23:25:58 +000015#include <linux/types.h>
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +020016#include <stdio_dev.h>
wdenk8655b6f2004-10-09 23:25:58 +000017#include <lcd.h>
Joe Hershberger0eb25b62015-03-22 17:08:59 -050018#include <mapmem.h>
wdenk8b0bfc62005-04-03 23:11:38 +000019#include <watchdog.h>
Przemyslaw Marczakdca2a1c2014-01-22 11:24:13 +010020#include <asm/unaligned.h>
Robert Winklerdd4425e2013-06-17 11:31:29 -070021#include <splash.h>
Simon Glass7d95f2a2014-02-27 13:26:19 -070022#include <asm/io.h>
23#include <asm/unaligned.h>
Nikita Kiryanovc8d2feb2015-02-03 13:32:29 +020024#include <video_font.h>
Robert Winklerdd4425e2013-06-17 11:31:29 -070025
wdenk88804d12005-07-04 00:03:16 +000026#ifdef CONFIG_LCD_LOGO
Nikita Kiryanovc8d2feb2015-02-03 13:32:29 +020027#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
wdenk88804d12005-07-04 00:03:16 +000032#endif
wdenk8655b6f2004-10-09 23:25:58 +000033
Simon Glass7d95f2a2014-02-27 13:26:19 -070034#ifdef CONFIG_SANDBOX
35#include <asm/sdl.h>
36#endif
37
Simon Glass676d3192012-10-17 13:24:54 +000038#ifndef CONFIG_LCD_ALIGNMENT
39#define CONFIG_LCD_ALIGNMENT PAGE_SIZE
40#endif
41
Nikita Kiryanova7de2952014-12-08 17:14:42 +020042#if (LCD_BPP != LCD_COLOR8) && (LCD_BPP != LCD_COLOR16) && \
43 (LCD_BPP != LCD_COLOR32)
Nikita Kiryanovc8d2feb2015-02-03 13:32:29 +020044#error Unsupported LCD BPP.
Jeroen Hofsteea5796c52013-01-12 12:07:59 +000045#endif
46
Wolfgang Denkd87080b2006-03-31 18:32:53 +020047DECLARE_GLOBAL_DATA_PTR;
wdenk8655b6f2004-10-09 23:25:58 +000048
Nikita Kiryanov8f47d912012-05-24 01:42:38 +000049static int lcd_init(void *lcdbase);
Nikita Kiryanov7bf71d12015-02-03 13:32:32 +020050static void lcd_logo(void);
Nikita Kiryanov8f47d912012-05-24 01:42:38 +000051static void lcd_setfgcolor(int color);
52static void lcd_setbgcolor(int color);
wdenk8655b6f2004-10-09 23:25:58 +000053
Wolfgang Denk46d1d5d2013-01-05 09:45:48 +000054static int lcd_color_fg;
55static int lcd_color_bg;
Jeroen Hofsteef1d205a2013-01-22 10:44:11 +000056int lcd_line_length;
wdenk8655b6f2004-10-09 23:25:58 +000057char lcd_is_enabled = 0;
Jeroen Hofstee00a0ca52013-01-22 10:44:12 +000058static void *lcd_base; /* Start of framebuffer memory */
Simon Glass9a8efc42012-10-30 13:40:18 +000059static char lcd_flush_dcache; /* 1 to flush dcache after each lcd update */
60
Simon Glass9a8efc42012-10-30 13:40:18 +000061/* Flush LCD activity to the caches */
62void lcd_sync(void)
63{
64 /*
65 * flush_dcache_range() is declared in common.h but it seems that some
66 * architectures do not actually implement it. Is there a way to find
67 * out whether it exists? For now, ARM is safe.
68 */
69#if defined(CONFIG_ARM) && !defined(CONFIG_SYS_DCACHE_OFF)
70 int line_length;
71
72 if (lcd_flush_dcache)
73 flush_dcache_range((u32)lcd_base,
74 (u32)(lcd_base + lcd_get_size(&line_length)));
Simon Glass7d95f2a2014-02-27 13:26:19 -070075#elif defined(CONFIG_SANDBOX) && defined(CONFIG_VIDEO_SANDBOX_SDL)
76 static ulong last_sync;
77
78 if (get_timer(last_sync) > 10) {
79 sandbox_sdl_sync(lcd_base);
80 last_sync = get_timer(0);
81 }
Simon Glass9a8efc42012-10-30 13:40:18 +000082#endif
83}
84
85void lcd_set_flush_dcache(int flush)
86{
87 lcd_flush_dcache = (flush != 0);
88}
89
Simon Glass709ea542014-07-23 06:54:59 -060090static void lcd_stub_putc(struct stdio_dev *dev, const char c)
91{
92 lcd_putc(c);
93}
94
Simon Glass709ea542014-07-23 06:54:59 -060095static void lcd_stub_puts(struct stdio_dev *dev, const char *s)
96{
97 lcd_puts(s);
98}
99
Nikita Kiryanovc8d2feb2015-02-03 13:32:29 +0200100/* Small utility to check that you got the colours right */
wdenk8655b6f2004-10-09 23:25:58 +0000101#ifdef LCD_TEST_PATTERN
102
103#define N_BLK_VERT 2
104#define N_BLK_HOR 3
105
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000106static int test_colors[N_BLK_HOR * N_BLK_VERT] = {
wdenk8655b6f2004-10-09 23:25:58 +0000107 CONSOLE_COLOR_RED, CONSOLE_COLOR_GREEN, CONSOLE_COLOR_YELLOW,
108 CONSOLE_COLOR_BLUE, CONSOLE_COLOR_MAGENTA, CONSOLE_COLOR_CYAN,
109};
110
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000111static void test_pattern(void)
wdenk8655b6f2004-10-09 23:25:58 +0000112{
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 uchar *pix = (uchar *)lcd_base;
119
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000120 printf("[LCD] Test Pattern: %d x %d [%d x %d]\n",
wdenk8655b6f2004-10-09 23:25:58 +0000121 h_max, v_max, h_step, v_step);
122
123 /* WARNING: Code silently assumes 8bit/pixel */
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000124 for (v = 0; v < v_max; ++v) {
wdenk8655b6f2004-10-09 23:25:58 +0000125 uchar iy = v / v_step;
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000126 for (h = 0; h < h_max; ++h) {
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000127 uchar ix = N_BLK_HOR * iy + h / h_step;
wdenk8655b6f2004-10-09 23:25:58 +0000128 *pix++ = test_colors[ix];
129 }
130 }
131}
132#endif /* LCD_TEST_PATTERN */
133
Anatolij Gustschincefa4712013-11-09 11:00:09 +0100134/*
135 * With most lcd drivers the line length is set up
136 * by calculating it from panel_info parameters. Some
137 * drivers need to calculate the line length differently,
138 * so make the function weak to allow overriding it.
139 */
140__weak int lcd_get_size(int *line_length)
Simon Glass676d3192012-10-17 13:24:54 +0000141{
142 *line_length = (panel_info.vl_col * NBITS(panel_info.vl_bpix)) / 8;
143 return *line_length * panel_info.vl_row;
144}
145
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000146int drv_lcd_init(void)
wdenk8655b6f2004-10-09 23:25:58 +0000147{
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200148 struct stdio_dev lcddev;
wdenk8655b6f2004-10-09 23:25:58 +0000149 int rc;
150
Simon Glass7d95f2a2014-02-27 13:26:19 -0700151 lcd_base = map_sysmem(gd->fb_base, 0);
wdenk8655b6f2004-10-09 23:25:58 +0000152
Nikita Kiryanovc8d2feb2015-02-03 13:32:29 +0200153 lcd_init(lcd_base);
wdenk8655b6f2004-10-09 23:25:58 +0000154
155 /* Device initialization */
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000156 memset(&lcddev, 0, sizeof(lcddev));
wdenk8655b6f2004-10-09 23:25:58 +0000157
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000158 strcpy(lcddev.name, "lcd");
wdenk8655b6f2004-10-09 23:25:58 +0000159 lcddev.ext = 0; /* No extensions */
160 lcddev.flags = DEV_FLAGS_OUTPUT; /* Output only */
Simon Glass709ea542014-07-23 06:54:59 -0600161 lcddev.putc = lcd_stub_putc; /* 'putc' function */
162 lcddev.puts = lcd_stub_puts; /* 'puts' function */
wdenk8655b6f2004-10-09 23:25:58 +0000163
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000164 rc = stdio_register(&lcddev);
wdenk8655b6f2004-10-09 23:25:58 +0000165
166 return (rc == 0) ? 1 : rc;
167}
168
Che-Liang Chiou02110902011-10-20 23:07:03 +0000169void lcd_clear(void)
wdenk8655b6f2004-10-09 23:25:58 +0000170{
Nikita Kiryanov4d036342014-12-08 17:14:43 +0200171 int bg_color;
Nikita Kiryanov7bf71d12015-02-03 13:32:32 +0200172 char *s;
173 ulong addr;
174 static int do_splash = 1;
Nikita Kiryanovf4469f52014-12-08 17:14:38 +0200175#if LCD_BPP == LCD_COLOR8
wdenk8655b6f2004-10-09 23:25:58 +0000176 /* Setting the palette */
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000177 lcd_setcolreg(CONSOLE_COLOR_BLACK, 0, 0, 0);
178 lcd_setcolreg(CONSOLE_COLOR_RED, 0xFF, 0, 0);
179 lcd_setcolreg(CONSOLE_COLOR_GREEN, 0, 0xFF, 0);
180 lcd_setcolreg(CONSOLE_COLOR_YELLOW, 0xFF, 0xFF, 0);
181 lcd_setcolreg(CONSOLE_COLOR_BLUE, 0, 0, 0xFF);
182 lcd_setcolreg(CONSOLE_COLOR_MAGENTA, 0xFF, 0, 0xFF);
183 lcd_setcolreg(CONSOLE_COLOR_CYAN, 0, 0xFF, 0xFF);
184 lcd_setcolreg(CONSOLE_COLOR_GREY, 0xAA, 0xAA, 0xAA);
185 lcd_setcolreg(CONSOLE_COLOR_WHITE, 0xFF, 0xFF, 0xFF);
wdenk8655b6f2004-10-09 23:25:58 +0000186#endif
187
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200188#ifndef CONFIG_SYS_WHITE_ON_BLACK
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000189 lcd_setfgcolor(CONSOLE_COLOR_BLACK);
190 lcd_setbgcolor(CONSOLE_COLOR_WHITE);
Nikita Kiryanov4d036342014-12-08 17:14:43 +0200191 bg_color = CONSOLE_COLOR_WHITE;
wdenk8655b6f2004-10-09 23:25:58 +0000192#else
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000193 lcd_setfgcolor(CONSOLE_COLOR_WHITE);
194 lcd_setbgcolor(CONSOLE_COLOR_BLACK);
Nikita Kiryanov4d036342014-12-08 17:14:43 +0200195 bg_color = CONSOLE_COLOR_BLACK;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200196#endif /* CONFIG_SYS_WHITE_ON_BLACK */
wdenk8655b6f2004-10-09 23:25:58 +0000197
198#ifdef LCD_TEST_PATTERN
199 test_pattern();
200#else
201 /* set framebuffer to background color */
Hannes Petermaier57d76a82014-03-07 18:55:40 +0100202#if (LCD_BPP != LCD_COLOR32)
Nikita Kiryanov4d036342014-12-08 17:14:43 +0200203 memset((char *)lcd_base, bg_color, lcd_line_length * panel_info.vl_row);
Hannes Petermaier57d76a82014-03-07 18:55:40 +0100204#else
205 u32 *ppix = lcd_base;
206 u32 i;
207 for (i = 0;
208 i < (lcd_line_length * panel_info.vl_row)/NBYTES(panel_info.vl_bpix);
209 i++) {
Nikita Kiryanov4d036342014-12-08 17:14:43 +0200210 *ppix++ = bg_color;
Hannes Petermaier57d76a82014-03-07 18:55:40 +0100211 }
212#endif
wdenk8655b6f2004-10-09 23:25:58 +0000213#endif
Hannes Petermaier604c7d42015-03-27 08:01:38 +0100214 /* setup text-console */
215 debug("[LCD] setting up console...\n");
216 lcd_init_console(lcd_base,
217 panel_info.vl_col,
218 panel_info.vl_row,
219 panel_info.vl_rot);
wdenk8655b6f2004-10-09 23:25:58 +0000220 /* Paint the logo and retrieve LCD base address */
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000221 debug("[LCD] Drawing the logo...\n");
Nikita Kiryanov7bf71d12015-02-03 13:32:32 +0200222 if (do_splash) {
223 s = getenv("splashimage");
224 if (s) {
225 do_splash = 0;
226 addr = simple_strtoul(s, NULL, 16);
227 if (lcd_splash(addr) == 0) {
228 lcd_sync();
229 return;
230 }
231 }
232 }
233
234 lcd_logo();
235#if defined(CONFIG_LCD_LOGO) && !defined(CONFIG_LCD_INFO_BELOW_LOGO)
236 addr = (ulong)lcd_base + BMP_LOGO_HEIGHT * lcd_line_length;
Hannes Petermaier604c7d42015-03-27 08:01:38 +0100237 lcd_init_console((void *)addr, panel_info.vl_row,
238 panel_info.vl_col, panel_info.vl_rot);
Nikita Kiryanov7bf71d12015-02-03 13:32:32 +0200239#endif
Simon Glass9a8efc42012-10-30 13:40:18 +0000240 lcd_sync();
241}
242
243static int do_lcd_clear(cmd_tbl_t *cmdtp, int flag, int argc,
244 char *const argv[])
245{
246 lcd_clear();
247 return 0;
wdenk8655b6f2004-10-09 23:25:58 +0000248}
Nikita Kiryanovc8d2feb2015-02-03 13:32:29 +0200249U_BOOT_CMD(cls, 1, 1, do_lcd_clear, "clear screen", "");
wdenk8655b6f2004-10-09 23:25:58 +0000250
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000251static int lcd_init(void *lcdbase)
wdenk8655b6f2004-10-09 23:25:58 +0000252{
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000253 debug("[LCD] Initializing LCD frambuffer at %p\n", lcdbase);
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000254 lcd_ctrl_init(lcdbase);
Anatolij Gustschin1d3dea12013-03-29 14:00:13 +0100255
256 /*
Stephen Warren9316e142014-11-19 20:41:03 -0700257 * lcd_ctrl_init() of some drivers (i.e. bcm2835 on rpi) ignores
Anatolij Gustschin1d3dea12013-03-29 14:00:13 +0100258 * the 'lcdbase' argument and uses custom lcd base address
259 * by setting up gd->fb_base. Check for this condition and fixup
260 * 'lcd_base' address.
261 */
Simon Glass7d95f2a2014-02-27 13:26:19 -0700262 if (map_to_sysmem(lcdbase) != gd->fb_base)
263 lcd_base = map_sysmem(gd->fb_base, 0);
Anatolij Gustschin1d3dea12013-03-29 14:00:13 +0100264
265 debug("[LCD] Using LCD frambuffer at %p\n", lcd_base);
266
Stephen Warren6d330712013-01-29 16:37:38 +0000267 lcd_get_size(&lcd_line_length);
Haavard Skinnemoen6f93d2b2008-09-01 16:21:21 +0200268 lcd_is_enabled = 1;
Che-Liang Chiou02110902011-10-20 23:07:03 +0000269 lcd_clear();
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000270 lcd_enable();
wdenk8655b6f2004-10-09 23:25:58 +0000271
272 /* Initialize the console */
Nikita Kiryanov140beb92014-12-08 17:14:41 +0200273 lcd_set_col(0);
wdenk88804d12005-07-04 00:03:16 +0000274#ifdef CONFIG_LCD_INFO_BELOW_LOGO
Nikita Kiryanov140beb92014-12-08 17:14:41 +0200275 lcd_set_row(7 + BMP_LOGO_HEIGHT / VIDEO_FONT_HEIGHT);
wdenk8655b6f2004-10-09 23:25:58 +0000276#else
Nikita Kiryanov140beb92014-12-08 17:14:41 +0200277 lcd_set_row(1); /* leave 1 blank line below logo */
wdenk8655b6f2004-10-09 23:25:58 +0000278#endif
wdenk8655b6f2004-10-09 23:25:58 +0000279
280 return 0;
281}
282
wdenk8655b6f2004-10-09 23:25:58 +0000283/*
284 * This is called early in the system initialization to grab memory
285 * for the LCD controller.
286 * Returns new address for monitor, after reserving LCD buffer memory
287 *
288 * Note that this is running from ROM, so no write access to global data.
289 */
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000290ulong lcd_setmem(ulong addr)
wdenk8655b6f2004-10-09 23:25:58 +0000291{
292 ulong size;
Simon Glass676d3192012-10-17 13:24:54 +0000293 int line_length;
wdenk8655b6f2004-10-09 23:25:58 +0000294
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000295 debug("LCD panel info: %d x %d, %d bit/pix\n", panel_info.vl_col,
296 panel_info.vl_row, NBITS(panel_info.vl_bpix));
wdenk8655b6f2004-10-09 23:25:58 +0000297
Simon Glass676d3192012-10-17 13:24:54 +0000298 size = lcd_get_size(&line_length);
wdenk8655b6f2004-10-09 23:25:58 +0000299
Simon Glass676d3192012-10-17 13:24:54 +0000300 /* Round up to nearest full page, or MMU section if defined */
301 size = ALIGN(size, CONFIG_LCD_ALIGNMENT);
302 addr = ALIGN(addr - CONFIG_LCD_ALIGNMENT + 1, CONFIG_LCD_ALIGNMENT);
wdenk8655b6f2004-10-09 23:25:58 +0000303
304 /* Allocate pages for the frame buffer. */
305 addr -= size;
306
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000307 debug("Reserving %ldk for LCD Framebuffer at: %08lx\n",
308 size >> 10, addr);
wdenk8655b6f2004-10-09 23:25:58 +0000309
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000310 return addr;
wdenk8655b6f2004-10-09 23:25:58 +0000311}
312
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000313static void lcd_setfgcolor(int color)
wdenk8655b6f2004-10-09 23:25:58 +0000314{
Stelian Pop39cf4802008-05-09 21:57:18 +0200315 lcd_color_fg = color;
wdenk8655b6f2004-10-09 23:25:58 +0000316}
317
Nikita Kiryanov4d036342014-12-08 17:14:43 +0200318int lcd_getfgcolor(void)
319{
320 return lcd_color_fg;
321}
322
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000323static void lcd_setbgcolor(int color)
wdenk8655b6f2004-10-09 23:25:58 +0000324{
Stelian Pop39cf4802008-05-09 21:57:18 +0200325 lcd_color_bg = color;
wdenk8655b6f2004-10-09 23:25:58 +0000326}
327
Nikita Kiryanov4d036342014-12-08 17:14:43 +0200328int lcd_getbgcolor(void)
329{
330 return lcd_color_bg;
331}
332
wdenk8655b6f2004-10-09 23:25:58 +0000333#ifdef CONFIG_LCD_LOGO
Nikita Kiryanova02e9482015-02-03 13:32:24 +0200334__weak void lcd_logo_set_cmap(void)
335{
Nikita Kiryanov23064572015-02-03 13:32:26 +0200336 int i;
337 ushort *cmap = configuration_get_cmap();
338
339 for (i = 0; i < ARRAY_SIZE(bmp_logo_palette); ++i)
340 *cmap++ = bmp_logo_palette[i];
Nikita Kiryanova02e9482015-02-03 13:32:24 +0200341}
342
Nikita Kiryanovbf21a5d2015-02-03 13:32:30 +0200343void lcd_logo_plot(int x, int y)
wdenk8655b6f2004-10-09 23:25:58 +0000344{
wdenk8655b6f2004-10-09 23:25:58 +0000345 ushort i, j;
Nikita Kiryanovc8d2feb2015-02-03 13:32:29 +0200346 uchar *bmap = &bmp_logo_bitmap[0];
Andre Renaud317461c2013-02-13 17:48:00 +0000347 unsigned bpix = NBITS(panel_info.vl_bpix);
Nikita Kiryanovc8d2feb2015-02-03 13:32:29 +0200348 uchar *fb = (uchar *)(lcd_base + y * lcd_line_length + x * bpix / 8);
349 ushort *fb16;
wdenk8655b6f2004-10-09 23:25:58 +0000350
Nikita Kiryanov23064572015-02-03 13:32:26 +0200351 debug("Logo: width %d height %d colors %d\n",
352 BMP_LOGO_WIDTH, BMP_LOGO_HEIGHT, BMP_LOGO_COLORS);
wdenk8655b6f2004-10-09 23:25:58 +0000353
Andre Renaud317461c2013-02-13 17:48:00 +0000354 if (bpix < 12) {
wdenk8655b6f2004-10-09 23:25:58 +0000355 WATCHDOG_RESET();
Nikita Kiryanova02e9482015-02-03 13:32:24 +0200356 lcd_logo_set_cmap();
wdenk8655b6f2004-10-09 23:25:58 +0000357 WATCHDOG_RESET();
358
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000359 for (i = 0; i < BMP_LOGO_HEIGHT; ++i) {
360 memcpy(fb, bmap, BMP_LOGO_WIDTH);
wdenk8655b6f2004-10-09 23:25:58 +0000361 bmap += BMP_LOGO_WIDTH;
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000362 fb += panel_info.vl_col;
wdenk8655b6f2004-10-09 23:25:58 +0000363 }
364 }
365 else { /* true color mode */
Alessandro Rubiniacb13862010-03-13 17:44:08 +0100366 u16 col16;
Andre Renaud317461c2013-02-13 17:48:00 +0000367 fb16 = (ushort *)fb;
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000368 for (i = 0; i < BMP_LOGO_HEIGHT; ++i) {
369 for (j = 0; j < BMP_LOGO_WIDTH; j++) {
Alessandro Rubiniacb13862010-03-13 17:44:08 +0100370 col16 = bmp_logo_palette[(bmap[j]-16)];
371 fb16[j] =
372 ((col16 & 0x000F) << 1) |
373 ((col16 & 0x00F0) << 3) |
374 ((col16 & 0x0F00) << 4);
wdenk8655b6f2004-10-09 23:25:58 +0000375 }
376 bmap += BMP_LOGO_WIDTH;
377 fb16 += panel_info.vl_col;
378 }
379 }
380
381 WATCHDOG_RESET();
Simon Glass9a8efc42012-10-30 13:40:18 +0000382 lcd_sync();
wdenk8655b6f2004-10-09 23:25:58 +0000383}
Anatolij Gustschin2b5cb3d2012-04-27 04:41:27 +0000384#else
Nikita Kiryanovbf21a5d2015-02-03 13:32:30 +0200385static inline void lcd_logo_plot(int x, int y) {}
wdenk8655b6f2004-10-09 23:25:58 +0000386#endif /* CONFIG_LCD_LOGO */
387
Jon Loeligerc3517f92007-07-08 18:10:08 -0500388#if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN)
Matthias Weisser1ca298c2009-07-09 16:07:30 +0200389#ifdef CONFIG_SPLASH_SCREEN_ALIGN
390#define BMP_ALIGN_CENTER 0x7FFF
Nikita Kiryanov7c7e2802012-08-09 00:14:51 +0000391
392static void splash_align_axis(int *axis, unsigned long panel_size,
393 unsigned long picture_size)
394{
395 unsigned long panel_picture_delta = panel_size - picture_size;
396 unsigned long axis_alignment;
397
398 if (*axis == BMP_ALIGN_CENTER)
399 axis_alignment = panel_picture_delta / 2;
400 else if (*axis < 0)
401 axis_alignment = panel_picture_delta + *axis + 1;
402 else
403 return;
404
Masahiro Yamadab4141192014-11-07 03:03:31 +0900405 *axis = max(0, (int)axis_alignment);
Nikita Kiryanov7c7e2802012-08-09 00:14:51 +0000406}
Matthias Weisser1ca298c2009-07-09 16:07:30 +0200407#endif
408
Tom Wai-Hong Tam45d7f522012-09-28 15:11:16 +0000409#ifdef CONFIG_LCD_BMP_RLE8
Tom Wai-Hong Tam45d7f522012-09-28 15:11:16 +0000410#define BMP_RLE8_ESCAPE 0
411#define BMP_RLE8_EOL 0
412#define BMP_RLE8_EOBMP 1
413#define BMP_RLE8_DELTA 2
414
415static void draw_unencoded_bitmap(ushort **fbp, uchar *bmap, ushort *cmap,
416 int cnt)
417{
418 while (cnt > 0) {
419 *(*fbp)++ = cmap[*bmap++];
420 cnt--;
421 }
422}
423
424static void draw_encoded_bitmap(ushort **fbp, ushort c, int cnt)
425{
426 ushort *fb = *fbp;
427 int cnt_8copy = cnt >> 3;
428
429 cnt -= cnt_8copy << 3;
430 while (cnt_8copy > 0) {
431 *fb++ = c;
432 *fb++ = c;
433 *fb++ = c;
434 *fb++ = c;
435 *fb++ = c;
436 *fb++ = c;
437 *fb++ = c;
438 *fb++ = c;
439 cnt_8copy--;
440 }
441 while (cnt > 0) {
442 *fb++ = c;
443 cnt--;
444 }
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000445 *fbp = fb;
Tom Wai-Hong Tam45d7f522012-09-28 15:11:16 +0000446}
447
448/*
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000449 * Do not call this function directly, must be called from lcd_display_bitmap.
Tom Wai-Hong Tam45d7f522012-09-28 15:11:16 +0000450 */
451static void lcd_display_rle8_bitmap(bmp_image_t *bmp, ushort *cmap, uchar *fb,
452 int x_off, int y_off)
453{
454 uchar *bmap;
455 ulong width, height;
456 ulong cnt, runlen;
457 int x, y;
458 int decode = 1;
459
Przemyslaw Marczakdca2a1c2014-01-22 11:24:13 +0100460 width = get_unaligned_le32(&bmp->header.width);
461 height = get_unaligned_le32(&bmp->header.height);
462 bmap = (uchar *)bmp + get_unaligned_le32(&bmp->header.data_offset);
Tom Wai-Hong Tam45d7f522012-09-28 15:11:16 +0000463
464 x = 0;
465 y = height - 1;
466
467 while (decode) {
468 if (bmap[0] == BMP_RLE8_ESCAPE) {
469 switch (bmap[1]) {
470 case BMP_RLE8_EOL:
471 /* end of line */
472 bmap += 2;
473 x = 0;
474 y--;
475 /* 16bpix, 2-byte per pixel, width should *2 */
476 fb -= (width * 2 + lcd_line_length);
477 break;
478 case BMP_RLE8_EOBMP:
479 /* end of bitmap */
480 decode = 0;
481 break;
482 case BMP_RLE8_DELTA:
483 /* delta run */
484 x += bmap[2];
485 y -= bmap[3];
486 /* 16bpix, 2-byte per pixel, x should *2 */
487 fb = (uchar *) (lcd_base + (y + y_off - 1)
488 * lcd_line_length + (x + x_off) * 2);
489 bmap += 4;
490 break;
491 default:
492 /* unencoded run */
493 runlen = bmap[1];
494 bmap += 2;
495 if (y < height) {
496 if (x < width) {
497 if (x + runlen > width)
498 cnt = width - x;
499 else
500 cnt = runlen;
501 draw_unencoded_bitmap(
502 (ushort **)&fb,
503 bmap, cmap, cnt);
504 }
505 x += runlen;
506 }
507 bmap += runlen;
508 if (runlen & 1)
509 bmap++;
510 }
511 } else {
512 /* encoded run */
513 if (y < height) {
514 runlen = bmap[0];
515 if (x < width) {
516 /* aggregate the same code */
517 while (bmap[0] == 0xff &&
518 bmap[2] != BMP_RLE8_ESCAPE &&
519 bmap[1] == bmap[3]) {
520 runlen += bmap[2];
521 bmap += 2;
522 }
523 if (x + runlen > width)
524 cnt = width - x;
525 else
526 cnt = runlen;
527 draw_encoded_bitmap((ushort **)&fb,
528 cmap[bmap[1]], cnt);
529 }
530 x += runlen;
531 }
532 bmap += 2;
533 }
534 }
535}
536#endif
537
Nikita Kiryanov27fad012015-02-03 13:32:23 +0200538__weak void fb_put_byte(uchar **fb, uchar **from)
539{
540 *(*fb)++ = *(*from)++;
541}
Nikita Kiryanovbfdcc652012-08-09 00:14:53 +0000542
543#if defined(CONFIG_BMP_16BPP)
Nikita Kiryanovb3d12e92015-02-03 13:32:22 +0200544__weak void fb_put_word(uchar **fb, uchar **from)
Nikita Kiryanovbfdcc652012-08-09 00:14:53 +0000545{
546 *(*fb)++ = *(*from)++;
547 *(*fb)++ = *(*from)++;
548}
Nikita Kiryanovbfdcc652012-08-09 00:14:53 +0000549#endif /* CONFIG_BMP_16BPP */
550
Nikita Kiryanov0b29a892015-02-03 13:32:27 +0200551__weak void lcd_set_cmap(bmp_image_t *bmp, unsigned colors)
552{
553 int i;
554 bmp_color_table_entry_t cte;
555 ushort *cmap = configuration_get_cmap();
556
557 for (i = 0; i < colors; ++i) {
558 cte = bmp->color_table[i];
559 *cmap = (((cte.red) << 8) & 0xf800) |
560 (((cte.green) << 3) & 0x07e0) |
561 (((cte.blue) >> 3) & 0x001f);
562#if defined(CONFIG_MPC823)
563 cmap--;
564#else
565 cmap++;
566#endif
567 }
568}
569
wdenk8655b6f2004-10-09 23:25:58 +0000570int lcd_display_bitmap(ulong bmp_image, int x, int y)
571{
Anatolij Gustschin00cc5592009-02-25 20:28:13 +0100572 ushort *cmap_base = NULL;
wdenk8655b6f2004-10-09 23:25:58 +0000573 ushort i, j;
574 uchar *fb;
Simon Glass7d95f2a2014-02-27 13:26:19 -0700575 bmp_image_t *bmp = (bmp_image_t *)map_sysmem(bmp_image, 0);
wdenk8655b6f2004-10-09 23:25:58 +0000576 uchar *bmap;
Tom Wai-Hong Tamfecac462012-09-28 15:11:14 +0000577 ushort padded_width;
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100578 unsigned long width, height, byte_width;
Wolfgang Denke8143e72006-08-30 23:09:00 +0200579 unsigned long pwidth = panel_info.vl_col;
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100580 unsigned colors, bpix, bmp_bpix;
wdenk8655b6f2004-10-09 23:25:58 +0000581
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000582 if (!bmp || !(bmp->header.signature[0] == 'B' &&
583 bmp->header.signature[1] == 'M')) {
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000584 printf("Error: no valid bmp image at %lx\n", bmp_image);
585
wdenk8655b6f2004-10-09 23:25:58 +0000586 return 1;
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100587 }
wdenk8655b6f2004-10-09 23:25:58 +0000588
Przemyslaw Marczakdca2a1c2014-01-22 11:24:13 +0100589 width = get_unaligned_le32(&bmp->header.width);
590 height = get_unaligned_le32(&bmp->header.height);
591 bmp_bpix = get_unaligned_le16(&bmp->header.bit_count);
592
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100593 colors = 1 << bmp_bpix;
wdenk8655b6f2004-10-09 23:25:58 +0000594
595 bpix = NBITS(panel_info.vl_bpix);
596
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000597 if (bpix != 1 && bpix != 8 && bpix != 16 && bpix != 32) {
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100598 printf ("Error: %d bit/pixel mode, but BMP has %d bit/pixel\n",
599 bpix, bmp_bpix);
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000600
wdenk8655b6f2004-10-09 23:25:58 +0000601 return 1;
602 }
603
Hannes Petermaiera305fb12014-07-15 16:28:46 +0200604 /*
605 * We support displaying 8bpp BMPs on 16bpp LCDs
606 * and displaying 24bpp BMPs on 32bpp LCDs
607 * */
608 if (bpix != bmp_bpix &&
609 !(bmp_bpix == 8 && bpix == 16) &&
610 !(bmp_bpix == 24 && bpix == 32)) {
wdenk8655b6f2004-10-09 23:25:58 +0000611 printf ("Error: %d bit/pixel mode, but BMP has %d bit/pixel\n",
Przemyslaw Marczakdca2a1c2014-01-22 11:24:13 +0100612 bpix, get_unaligned_le16(&bmp->header.bit_count));
wdenk8655b6f2004-10-09 23:25:58 +0000613 return 1;
614 }
615
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000616 debug("Display-bmp: %d x %d with %d colors\n",
wdenk8655b6f2004-10-09 23:25:58 +0000617 (int)width, (int)height, (int)colors);
618
Nikita Kiryanov0b29a892015-02-03 13:32:27 +0200619 if (bmp_bpix == 8)
620 lcd_set_cmap(bmp, colors);
Wolfgang Denke8143e72006-08-30 23:09:00 +0200621
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000622 padded_width = (width & 0x3 ? (width & ~0x3) + 4 : width);
Matthias Weisser1ca298c2009-07-09 16:07:30 +0200623
624#ifdef CONFIG_SPLASH_SCREEN_ALIGN
Nikita Kiryanov7c7e2802012-08-09 00:14:51 +0000625 splash_align_axis(&x, pwidth, width);
626 splash_align_axis(&y, panel_info.vl_row, height);
Matthias Weisser1ca298c2009-07-09 16:07:30 +0200627#endif /* CONFIG_SPLASH_SCREEN_ALIGN */
628
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000629 if ((x + width) > pwidth)
Wolfgang Denke8143e72006-08-30 23:09:00 +0200630 width = pwidth - x;
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000631 if ((y + height) > panel_info.vl_row)
wdenk8655b6f2004-10-09 23:25:58 +0000632 height = panel_info.vl_row - y;
633
Przemyslaw Marczakdca2a1c2014-01-22 11:24:13 +0100634 bmap = (uchar *)bmp + get_unaligned_le32(&bmp->header.data_offset);
635 fb = (uchar *)(lcd_base +
Liu Ying8d46d5b2011-01-11 15:29:58 +0800636 (y + height - 1) * lcd_line_length + x * bpix / 8);
Mark Jacksona303dfb2009-02-06 10:37:49 +0100637
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100638 switch (bmp_bpix) {
Nikita Kiryanovc8d2feb2015-02-03 13:32:29 +0200639 case 1:
Simon Glass01564442014-10-15 04:53:04 -0600640 case 8: {
Nikita Kiryanov0b29a892015-02-03 13:32:27 +0200641 cmap_base = configuration_get_cmap();
Tom Wai-Hong Tam45d7f522012-09-28 15:11:16 +0000642#ifdef CONFIG_LCD_BMP_RLE8
Przemyslaw Marczakdca2a1c2014-01-22 11:24:13 +0100643 u32 compression = get_unaligned_le32(&bmp->header.compression);
644 if (compression == BMP_BI_RLE8) {
Tom Wai-Hong Tam45d7f522012-09-28 15:11:16 +0000645 if (bpix != 16) {
646 /* TODO implement render code for bpix != 16 */
647 printf("Error: only support 16 bpix");
648 return 1;
649 }
650 lcd_display_rle8_bitmap(bmp, cmap_base, fb, x, y);
651 break;
652 }
653#endif
654
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100655 if (bpix != 16)
656 byte_width = width;
657 else
658 byte_width = width * 2;
659
Mark Jacksona303dfb2009-02-06 10:37:49 +0100660 for (i = 0; i < height; ++i) {
661 WATCHDOG_RESET();
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100662 for (j = 0; j < width; j++) {
663 if (bpix != 16) {
Nikita Kiryanov27fad012015-02-03 13:32:23 +0200664 fb_put_byte(&fb, &bmap);
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100665 } else {
666 *(uint16_t *)fb = cmap_base[*(bmap++)];
667 fb += sizeof(uint16_t) / sizeof(*fb);
668 }
669 }
Tom Wai-Hong Tamfecac462012-09-28 15:11:14 +0000670 bmap += (padded_width - width);
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000671 fb -= byte_width + lcd_line_length;
Mark Jacksona303dfb2009-02-06 10:37:49 +0100672 }
673 break;
Simon Glass01564442014-10-15 04:53:04 -0600674 }
Mark Jacksona303dfb2009-02-06 10:37:49 +0100675#if defined(CONFIG_BMP_16BPP)
676 case 16:
677 for (i = 0; i < height; ++i) {
678 WATCHDOG_RESET();
Nikita Kiryanovbfdcc652012-08-09 00:14:53 +0000679 for (j = 0; j < width; j++)
680 fb_put_word(&fb, &bmap);
681
Tom Wai-Hong Tamfecac462012-09-28 15:11:14 +0000682 bmap += (padded_width - width) * 2;
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000683 fb -= width * 2 + lcd_line_length;
Mark Jacksona303dfb2009-02-06 10:37:49 +0100684 }
685 break;
686#endif /* CONFIG_BMP_16BPP */
Hannes Petermaiera305fb12014-07-15 16:28:46 +0200687#if defined(CONFIG_BMP_24BMP)
688 case 24:
689 for (i = 0; i < height; ++i) {
690 for (j = 0; j < width; j++) {
691 *(fb++) = *(bmap++);
692 *(fb++) = *(bmap++);
693 *(fb++) = *(bmap++);
694 *(fb++) = 0;
695 }
696 fb -= lcd_line_length + width * (bpix / 8);
697 }
698 break;
699#endif /* CONFIG_BMP_24BMP */
Donghwa Leefb6a9aa2012-05-09 19:23:37 +0000700#if defined(CONFIG_BMP_32BPP)
701 case 32:
702 for (i = 0; i < height; ++i) {
703 for (j = 0; j < width; j++) {
704 *(fb++) = *(bmap++);
705 *(fb++) = *(bmap++);
706 *(fb++) = *(bmap++);
707 *(fb++) = *(bmap++);
708 }
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000709 fb -= lcd_line_length + width * (bpix / 8);
Donghwa Leefb6a9aa2012-05-09 19:23:37 +0000710 }
711 break;
712#endif /* CONFIG_BMP_32BPP */
Mark Jacksona303dfb2009-02-06 10:37:49 +0100713 default:
714 break;
715 };
wdenk8655b6f2004-10-09 23:25:58 +0000716
Simon Glass9a8efc42012-10-30 13:40:18 +0000717 lcd_sync();
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000718 return 0;
wdenk8655b6f2004-10-09 23:25:58 +0000719}
Jon Loeligerc3517f92007-07-08 18:10:08 -0500720#endif
wdenk8655b6f2004-10-09 23:25:58 +0000721
Nikita Kiryanov7bf71d12015-02-03 13:32:32 +0200722static void lcd_logo(void)
wdenk8655b6f2004-10-09 23:25:58 +0000723{
Nikita Kiryanovbf21a5d2015-02-03 13:32:30 +0200724 lcd_logo_plot(0, 0);
wdenk8655b6f2004-10-09 23:25:58 +0000725
Haavard Skinnemoen6b59e032008-09-01 16:21:22 +0200726#ifdef CONFIG_LCD_INFO
Nikita Kiryanov140beb92014-12-08 17:14:41 +0200727 lcd_set_col(LCD_INFO_X / VIDEO_FONT_WIDTH);
728 lcd_set_row(LCD_INFO_Y / VIDEO_FONT_HEIGHT);
Haavard Skinnemoen6b59e032008-09-01 16:21:22 +0200729 lcd_show_board_info();
730#endif /* CONFIG_LCD_INFO */
wdenk8655b6f2004-10-09 23:25:58 +0000731}
732
Nikita Kiryanovc0880482013-02-24 21:28:43 +0000733#ifdef CONFIG_SPLASHIMAGE_GUARD
734static int on_splashimage(const char *name, const char *value, enum env_op op,
735 int flags)
736{
737 ulong addr;
738 int aligned;
739
740 if (op == env_op_delete)
741 return 0;
742
743 addr = simple_strtoul(value, NULL, 16);
744 /* See README.displaying-bmps */
745 aligned = (addr % 4 == 2);
746 if (!aligned) {
747 printf("Invalid splashimage value. Value must be 16 bit aligned, but not 32 bit aligned\n");
748 return -1;
749 }
750
751 return 0;
752}
753
754U_BOOT_ENV_CALLBACK(splashimage, on_splashimage);
755#endif
756
Vadim Bendebury395166c2012-09-28 15:11:13 +0000757int lcd_get_pixel_width(void)
758{
759 return panel_info.vl_col;
760}
761
762int lcd_get_pixel_height(void)
763{
764 return panel_info.vl_row;
765}