blob: 51705adeaf79918bce59a374a3319c6cb98a3cce [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 Glass676d3192012-10-17 13:24:54 +000034#ifndef CONFIG_LCD_ALIGNMENT
35#define CONFIG_LCD_ALIGNMENT PAGE_SIZE
36#endif
37
Nikita Kiryanova7de2952014-12-08 17:14:42 +020038#if (LCD_BPP != LCD_COLOR8) && (LCD_BPP != LCD_COLOR16) && \
39 (LCD_BPP != LCD_COLOR32)
Nikita Kiryanovc8d2feb2015-02-03 13:32:29 +020040#error Unsupported LCD BPP.
Jeroen Hofsteea5796c52013-01-12 12:07:59 +000041#endif
42
Wolfgang Denkd87080b2006-03-31 18:32:53 +020043DECLARE_GLOBAL_DATA_PTR;
wdenk8655b6f2004-10-09 23:25:58 +000044
Nikita Kiryanov8f47d912012-05-24 01:42:38 +000045static int lcd_init(void *lcdbase);
Nikita Kiryanov7bf71d12015-02-03 13:32:32 +020046static void lcd_logo(void);
Nikita Kiryanov8f47d912012-05-24 01:42:38 +000047static void lcd_setfgcolor(int color);
48static void lcd_setbgcolor(int color);
wdenk8655b6f2004-10-09 23:25:58 +000049
Wolfgang Denk46d1d5d2013-01-05 09:45:48 +000050static int lcd_color_fg;
51static int lcd_color_bg;
Jeroen Hofsteef1d205a2013-01-22 10:44:11 +000052int lcd_line_length;
wdenk8655b6f2004-10-09 23:25:58 +000053char lcd_is_enabled = 0;
Jeroen Hofstee00a0ca52013-01-22 10:44:12 +000054static void *lcd_base; /* Start of framebuffer memory */
Simon Glass9a8efc42012-10-30 13:40:18 +000055static char lcd_flush_dcache; /* 1 to flush dcache after each lcd update */
56
Simon Glass9a8efc42012-10-30 13:40:18 +000057/* Flush LCD activity to the caches */
58void 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
74void lcd_set_flush_dcache(int flush)
75{
76 lcd_flush_dcache = (flush != 0);
77}
78
Simon Glass709ea542014-07-23 06:54:59 -060079static void lcd_stub_putc(struct stdio_dev *dev, const char c)
80{
81 lcd_putc(c);
82}
83
Simon Glass709ea542014-07-23 06:54:59 -060084static void lcd_stub_puts(struct stdio_dev *dev, const char *s)
85{
86 lcd_puts(s);
87}
88
Nikita Kiryanovc8d2feb2015-02-03 13:32:29 +020089/* Small utility to check that you got the colours right */
wdenk8655b6f2004-10-09 23:25:58 +000090#ifdef LCD_TEST_PATTERN
91
Andreas Neubachere32951b2016-01-21 13:06:32 +010092#if LCD_BPP == LCD_COLOR8
wdenk8655b6f2004-10-09 23:25:58 +000093#define N_BLK_VERT 2
94#define N_BLK_HOR 3
95
Jeroen Hofstee6b035142013-01-12 12:07:56 +000096static int test_colors[N_BLK_HOR * N_BLK_VERT] = {
wdenk8655b6f2004-10-09 23:25:58 +000097 CONSOLE_COLOR_RED, CONSOLE_COLOR_GREEN, CONSOLE_COLOR_YELLOW,
98 CONSOLE_COLOR_BLUE, CONSOLE_COLOR_MAGENTA, CONSOLE_COLOR_CYAN,
Andreas Neubachere32951b2016-01-21 13:06:32 +010099}; /*LCD_BPP == LCD_COLOR8 */
100
101#elif LCD_BPP == LCD_COLOR16
102#define N_BLK_VERT 2
103#define N_BLK_HOR 4
104
105static 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,
wdenk8655b6f2004-10-09 23:25:58 +0000108};
Andreas Neubachere32951b2016-01-21 13:06:32 +0100109#endif /*LCD_BPP == LCD_COLOR16 */
wdenk8655b6f2004-10-09 23:25:58 +0000110
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;
Andreas Neubachere32951b2016-01-21 13:06:32 +0100118#if LCD_BPP == LCD_COLOR8
wdenk8655b6f2004-10-09 23:25:58 +0000119 uchar *pix = (uchar *)lcd_base;
Andreas Neubachere32951b2016-01-21 13:06:32 +0100120#elif LCD_BPP == LCD_COLOR16
121 ushort *pix = (ushort *)lcd_base;
122#endif
wdenk8655b6f2004-10-09 23:25:58 +0000123
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000124 printf("[LCD] Test Pattern: %d x %d [%d x %d]\n",
wdenk8655b6f2004-10-09 23:25:58 +0000125 h_max, v_max, h_step, v_step);
126
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000127 for (v = 0; v < v_max; ++v) {
wdenk8655b6f2004-10-09 23:25:58 +0000128 uchar iy = v / v_step;
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000129 for (h = 0; h < h_max; ++h) {
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000130 uchar ix = N_BLK_HOR * iy + h / h_step;
wdenk8655b6f2004-10-09 23:25:58 +0000131 *pix++ = test_colors[ix];
132 }
133 }
134}
135#endif /* LCD_TEST_PATTERN */
136
Anatolij Gustschincefa4712013-11-09 11:00:09 +0100137/*
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)
Simon Glass676d3192012-10-17 13:24:54 +0000144{
145 *line_length = (panel_info.vl_col * NBITS(panel_info.vl_bpix)) / 8;
146 return *line_length * panel_info.vl_row;
147}
148
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000149int drv_lcd_init(void)
wdenk8655b6f2004-10-09 23:25:58 +0000150{
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200151 struct stdio_dev lcddev;
wdenk8655b6f2004-10-09 23:25:58 +0000152 int rc;
153
Simon Glass7d95f2a2014-02-27 13:26:19 -0700154 lcd_base = map_sysmem(gd->fb_base, 0);
wdenk8655b6f2004-10-09 23:25:58 +0000155
Nikita Kiryanovc8d2feb2015-02-03 13:32:29 +0200156 lcd_init(lcd_base);
wdenk8655b6f2004-10-09 23:25:58 +0000157
158 /* Device initialization */
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000159 memset(&lcddev, 0, sizeof(lcddev));
wdenk8655b6f2004-10-09 23:25:58 +0000160
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000161 strcpy(lcddev.name, "lcd");
wdenk8655b6f2004-10-09 23:25:58 +0000162 lcddev.ext = 0; /* No extensions */
163 lcddev.flags = DEV_FLAGS_OUTPUT; /* Output only */
Simon Glass709ea542014-07-23 06:54:59 -0600164 lcddev.putc = lcd_stub_putc; /* 'putc' function */
165 lcddev.puts = lcd_stub_puts; /* 'puts' function */
wdenk8655b6f2004-10-09 23:25:58 +0000166
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000167 rc = stdio_register(&lcddev);
wdenk8655b6f2004-10-09 23:25:58 +0000168
169 return (rc == 0) ? 1 : rc;
170}
171
Che-Liang Chiou02110902011-10-20 23:07:03 +0000172void lcd_clear(void)
wdenk8655b6f2004-10-09 23:25:58 +0000173{
Nikita Kiryanov4d036342014-12-08 17:14:43 +0200174 int bg_color;
Nikita Kiryanov7bf71d12015-02-03 13:32:32 +0200175 char *s;
176 ulong addr;
177 static int do_splash = 1;
Nikita Kiryanovf4469f52014-12-08 17:14:38 +0200178#if LCD_BPP == LCD_COLOR8
wdenk8655b6f2004-10-09 23:25:58 +0000179 /* Setting the palette */
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000180 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);
wdenk8655b6f2004-10-09 23:25:58 +0000189#endif
190
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200191#ifndef CONFIG_SYS_WHITE_ON_BLACK
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000192 lcd_setfgcolor(CONSOLE_COLOR_BLACK);
193 lcd_setbgcolor(CONSOLE_COLOR_WHITE);
Nikita Kiryanov4d036342014-12-08 17:14:43 +0200194 bg_color = CONSOLE_COLOR_WHITE;
wdenk8655b6f2004-10-09 23:25:58 +0000195#else
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000196 lcd_setfgcolor(CONSOLE_COLOR_WHITE);
197 lcd_setbgcolor(CONSOLE_COLOR_BLACK);
Nikita Kiryanov4d036342014-12-08 17:14:43 +0200198 bg_color = CONSOLE_COLOR_BLACK;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200199#endif /* CONFIG_SYS_WHITE_ON_BLACK */
wdenk8655b6f2004-10-09 23:25:58 +0000200
201#ifdef LCD_TEST_PATTERN
202 test_pattern();
203#else
204 /* set framebuffer to background color */
Hannes Petermaier57d76a82014-03-07 18:55:40 +0100205#if (LCD_BPP != LCD_COLOR32)
Nikita Kiryanov4d036342014-12-08 17:14:43 +0200206 memset((char *)lcd_base, bg_color, lcd_line_length * panel_info.vl_row);
Hannes Petermaier57d76a82014-03-07 18:55:40 +0100207#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++) {
Nikita Kiryanov4d036342014-12-08 17:14:43 +0200213 *ppix++ = bg_color;
Hannes Petermaier57d76a82014-03-07 18:55:40 +0100214 }
215#endif
wdenk8655b6f2004-10-09 23:25:58 +0000216#endif
Hannes Petermaier604c7d42015-03-27 08:01:38 +0100217 /* 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);
wdenk8655b6f2004-10-09 23:25:58 +0000223 /* Paint the logo and retrieve LCD base address */
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000224 debug("[LCD] Drawing the logo...\n");
Nikita Kiryanov7bf71d12015-02-03 13:32:32 +0200225 if (do_splash) {
226 s = getenv("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;
Marcel Ziswiler3b96b902015-08-04 15:49:50 +0200240 lcd_init_console((void *)addr, panel_info.vl_col,
241 panel_info.vl_row, panel_info.vl_rot);
Nikita Kiryanov7bf71d12015-02-03 13:32:32 +0200242#endif
Simon Glass9a8efc42012-10-30 13:40:18 +0000243 lcd_sync();
244}
245
246static int do_lcd_clear(cmd_tbl_t *cmdtp, int flag, int argc,
247 char *const argv[])
248{
249 lcd_clear();
250 return 0;
wdenk8655b6f2004-10-09 23:25:58 +0000251}
Nikita Kiryanovc8d2feb2015-02-03 13:32:29 +0200252U_BOOT_CMD(cls, 1, 1, do_lcd_clear, "clear screen", "");
wdenk8655b6f2004-10-09 23:25:58 +0000253
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000254static int lcd_init(void *lcdbase)
wdenk8655b6f2004-10-09 23:25:58 +0000255{
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000256 debug("[LCD] Initializing LCD frambuffer at %p\n", lcdbase);
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000257 lcd_ctrl_init(lcdbase);
Anatolij Gustschin1d3dea12013-03-29 14:00:13 +0100258
259 /*
Stephen Warren9316e142014-11-19 20:41:03 -0700260 * lcd_ctrl_init() of some drivers (i.e. bcm2835 on rpi) ignores
Anatolij Gustschin1d3dea12013-03-29 14:00:13 +0100261 * 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 */
Simon Glass7d95f2a2014-02-27 13:26:19 -0700265 if (map_to_sysmem(lcdbase) != gd->fb_base)
266 lcd_base = map_sysmem(gd->fb_base, 0);
Anatolij Gustschin1d3dea12013-03-29 14:00:13 +0100267
268 debug("[LCD] Using LCD frambuffer at %p\n", lcd_base);
269
Stephen Warren6d330712013-01-29 16:37:38 +0000270 lcd_get_size(&lcd_line_length);
Haavard Skinnemoen6f93d2b2008-09-01 16:21:21 +0200271 lcd_is_enabled = 1;
Che-Liang Chiou02110902011-10-20 23:07:03 +0000272 lcd_clear();
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000273 lcd_enable();
wdenk8655b6f2004-10-09 23:25:58 +0000274
275 /* Initialize the console */
Nikita Kiryanov140beb92014-12-08 17:14:41 +0200276 lcd_set_col(0);
wdenk88804d12005-07-04 00:03:16 +0000277#ifdef CONFIG_LCD_INFO_BELOW_LOGO
Nikita Kiryanov140beb92014-12-08 17:14:41 +0200278 lcd_set_row(7 + BMP_LOGO_HEIGHT / VIDEO_FONT_HEIGHT);
wdenk8655b6f2004-10-09 23:25:58 +0000279#else
Nikita Kiryanov140beb92014-12-08 17:14:41 +0200280 lcd_set_row(1); /* leave 1 blank line below logo */
wdenk8655b6f2004-10-09 23:25:58 +0000281#endif
wdenk8655b6f2004-10-09 23:25:58 +0000282
283 return 0;
284}
285
wdenk8655b6f2004-10-09 23:25:58 +0000286/*
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 */
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000293ulong lcd_setmem(ulong addr)
wdenk8655b6f2004-10-09 23:25:58 +0000294{
295 ulong size;
Simon Glass676d3192012-10-17 13:24:54 +0000296 int line_length;
wdenk8655b6f2004-10-09 23:25:58 +0000297
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000298 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));
wdenk8655b6f2004-10-09 23:25:58 +0000300
Simon Glass676d3192012-10-17 13:24:54 +0000301 size = lcd_get_size(&line_length);
wdenk8655b6f2004-10-09 23:25:58 +0000302
Simon Glass676d3192012-10-17 13:24:54 +0000303 /* 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);
wdenk8655b6f2004-10-09 23:25:58 +0000306
307 /* Allocate pages for the frame buffer. */
308 addr -= size;
309
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000310 debug("Reserving %ldk for LCD Framebuffer at: %08lx\n",
311 size >> 10, addr);
wdenk8655b6f2004-10-09 23:25:58 +0000312
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000313 return addr;
wdenk8655b6f2004-10-09 23:25:58 +0000314}
315
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000316static void lcd_setfgcolor(int color)
wdenk8655b6f2004-10-09 23:25:58 +0000317{
Stelian Pop39cf4802008-05-09 21:57:18 +0200318 lcd_color_fg = color;
wdenk8655b6f2004-10-09 23:25:58 +0000319}
320
Nikita Kiryanov4d036342014-12-08 17:14:43 +0200321int lcd_getfgcolor(void)
322{
323 return lcd_color_fg;
324}
325
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000326static void lcd_setbgcolor(int color)
wdenk8655b6f2004-10-09 23:25:58 +0000327{
Stelian Pop39cf4802008-05-09 21:57:18 +0200328 lcd_color_bg = color;
wdenk8655b6f2004-10-09 23:25:58 +0000329}
330
Nikita Kiryanov4d036342014-12-08 17:14:43 +0200331int lcd_getbgcolor(void)
332{
333 return lcd_color_bg;
334}
335
wdenk8655b6f2004-10-09 23:25:58 +0000336#ifdef CONFIG_LCD_LOGO
Nikita Kiryanova02e9482015-02-03 13:32:24 +0200337__weak void lcd_logo_set_cmap(void)
338{
Nikita Kiryanov23064572015-02-03 13:32:26 +0200339 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];
Nikita Kiryanova02e9482015-02-03 13:32:24 +0200344}
345
Nikita Kiryanovbf21a5d2015-02-03 13:32:30 +0200346void lcd_logo_plot(int x, int y)
wdenk8655b6f2004-10-09 23:25:58 +0000347{
wdenk8655b6f2004-10-09 23:25:58 +0000348 ushort i, j;
Nikita Kiryanovc8d2feb2015-02-03 13:32:29 +0200349 uchar *bmap = &bmp_logo_bitmap[0];
Andre Renaud317461c2013-02-13 17:48:00 +0000350 unsigned bpix = NBITS(panel_info.vl_bpix);
Nikita Kiryanovc8d2feb2015-02-03 13:32:29 +0200351 uchar *fb = (uchar *)(lcd_base + y * lcd_line_length + x * bpix / 8);
352 ushort *fb16;
wdenk8655b6f2004-10-09 23:25:58 +0000353
Nikita Kiryanov23064572015-02-03 13:32:26 +0200354 debug("Logo: width %d height %d colors %d\n",
355 BMP_LOGO_WIDTH, BMP_LOGO_HEIGHT, BMP_LOGO_COLORS);
wdenk8655b6f2004-10-09 23:25:58 +0000356
Andre Renaud317461c2013-02-13 17:48:00 +0000357 if (bpix < 12) {
wdenk8655b6f2004-10-09 23:25:58 +0000358 WATCHDOG_RESET();
Nikita Kiryanova02e9482015-02-03 13:32:24 +0200359 lcd_logo_set_cmap();
wdenk8655b6f2004-10-09 23:25:58 +0000360 WATCHDOG_RESET();
361
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000362 for (i = 0; i < BMP_LOGO_HEIGHT; ++i) {
363 memcpy(fb, bmap, BMP_LOGO_WIDTH);
wdenk8655b6f2004-10-09 23:25:58 +0000364 bmap += BMP_LOGO_WIDTH;
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000365 fb += panel_info.vl_col;
wdenk8655b6f2004-10-09 23:25:58 +0000366 }
367 }
368 else { /* true color mode */
Alessandro Rubiniacb13862010-03-13 17:44:08 +0100369 u16 col16;
Andre Renaud317461c2013-02-13 17:48:00 +0000370 fb16 = (ushort *)fb;
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000371 for (i = 0; i < BMP_LOGO_HEIGHT; ++i) {
372 for (j = 0; j < BMP_LOGO_WIDTH; j++) {
Alessandro Rubiniacb13862010-03-13 17:44:08 +0100373 col16 = bmp_logo_palette[(bmap[j]-16)];
374 fb16[j] =
375 ((col16 & 0x000F) << 1) |
376 ((col16 & 0x00F0) << 3) |
377 ((col16 & 0x0F00) << 4);
wdenk8655b6f2004-10-09 23:25:58 +0000378 }
379 bmap += BMP_LOGO_WIDTH;
380 fb16 += panel_info.vl_col;
381 }
382 }
383
384 WATCHDOG_RESET();
Simon Glass9a8efc42012-10-30 13:40:18 +0000385 lcd_sync();
wdenk8655b6f2004-10-09 23:25:58 +0000386}
Anatolij Gustschin2b5cb3d2012-04-27 04:41:27 +0000387#else
Nikita Kiryanovbf21a5d2015-02-03 13:32:30 +0200388static inline void lcd_logo_plot(int x, int y) {}
wdenk8655b6f2004-10-09 23:25:58 +0000389#endif /* CONFIG_LCD_LOGO */
390
Jon Loeligerc3517f92007-07-08 18:10:08 -0500391#if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN)
Matthias Weisser1ca298c2009-07-09 16:07:30 +0200392#ifdef CONFIG_SPLASH_SCREEN_ALIGN
393#define BMP_ALIGN_CENTER 0x7FFF
Nikita Kiryanov7c7e2802012-08-09 00:14:51 +0000394
395static 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
Masahiro Yamadab4141192014-11-07 03:03:31 +0900408 *axis = max(0, (int)axis_alignment);
Nikita Kiryanov7c7e2802012-08-09 00:14:51 +0000409}
Matthias Weisser1ca298c2009-07-09 16:07:30 +0200410#endif
411
Tom Wai-Hong Tam45d7f522012-09-28 15:11:16 +0000412#ifdef CONFIG_LCD_BMP_RLE8
Tom Wai-Hong Tam45d7f522012-09-28 15:11:16 +0000413#define BMP_RLE8_ESCAPE 0
414#define BMP_RLE8_EOL 0
415#define BMP_RLE8_EOBMP 1
416#define BMP_RLE8_DELTA 2
417
418static 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
427static 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 }
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000448 *fbp = fb;
Tom Wai-Hong Tam45d7f522012-09-28 15:11:16 +0000449}
450
451/*
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000452 * Do not call this function directly, must be called from lcd_display_bitmap.
Tom Wai-Hong Tam45d7f522012-09-28 15:11:16 +0000453 */
Simon Glass1c3dbe52015-05-13 07:02:27 -0600454static void lcd_display_rle8_bitmap(struct bmp_image *bmp, ushort *cmap,
455 uchar *fb, int x_off, int y_off)
Tom Wai-Hong Tam45d7f522012-09-28 15:11:16 +0000456{
457 uchar *bmap;
458 ulong width, height;
459 ulong cnt, runlen;
460 int x, y;
461 int decode = 1;
462
Przemyslaw Marczakdca2a1c2014-01-22 11:24:13 +0100463 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);
Tom Wai-Hong Tam45d7f522012-09-28 15:11:16 +0000466
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
Nikita Kiryanov27fad012015-02-03 13:32:23 +0200541__weak void fb_put_byte(uchar **fb, uchar **from)
542{
543 *(*fb)++ = *(*from)++;
544}
Nikita Kiryanovbfdcc652012-08-09 00:14:53 +0000545
546#if defined(CONFIG_BMP_16BPP)
Nikita Kiryanovb3d12e92015-02-03 13:32:22 +0200547__weak void fb_put_word(uchar **fb, uchar **from)
Nikita Kiryanovbfdcc652012-08-09 00:14:53 +0000548{
549 *(*fb)++ = *(*from)++;
550 *(*fb)++ = *(*from)++;
551}
Nikita Kiryanovbfdcc652012-08-09 00:14:53 +0000552#endif /* CONFIG_BMP_16BPP */
553
Simon Glass1c3dbe52015-05-13 07:02:27 -0600554__weak void lcd_set_cmap(struct bmp_image *bmp, unsigned colors)
Nikita Kiryanov0b29a892015-02-03 13:32:27 +0200555{
556 int i;
Simon Glass1c3dbe52015-05-13 07:02:27 -0600557 struct bmp_color_table_entry cte;
Nikita Kiryanov0b29a892015-02-03 13:32:27 +0200558 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#if defined(CONFIG_MPC823)
566 cmap--;
567#else
568 cmap++;
569#endif
570 }
571}
572
wdenk8655b6f2004-10-09 23:25:58 +0000573int lcd_display_bitmap(ulong bmp_image, int x, int y)
574{
Anatolij Gustschin00cc5592009-02-25 20:28:13 +0100575 ushort *cmap_base = NULL;
wdenk8655b6f2004-10-09 23:25:58 +0000576 ushort i, j;
577 uchar *fb;
Simon Glass1c3dbe52015-05-13 07:02:27 -0600578 struct bmp_image *bmp = (struct bmp_image *)map_sysmem(bmp_image, 0);
wdenk8655b6f2004-10-09 23:25:58 +0000579 uchar *bmap;
Tom Wai-Hong Tamfecac462012-09-28 15:11:14 +0000580 ushort padded_width;
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100581 unsigned long width, height, byte_width;
Wolfgang Denke8143e72006-08-30 23:09:00 +0200582 unsigned long pwidth = panel_info.vl_col;
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100583 unsigned colors, bpix, bmp_bpix;
Simon Glass8d379f12015-05-13 07:02:28 -0600584 int hdr_size;
585 struct bmp_color_table_entry *palette = bmp->color_table;
wdenk8655b6f2004-10-09 23:25:58 +0000586
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000587 if (!bmp || !(bmp->header.signature[0] == 'B' &&
588 bmp->header.signature[1] == 'M')) {
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000589 printf("Error: no valid bmp image at %lx\n", bmp_image);
590
wdenk8655b6f2004-10-09 23:25:58 +0000591 return 1;
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100592 }
wdenk8655b6f2004-10-09 23:25:58 +0000593
Przemyslaw Marczakdca2a1c2014-01-22 11:24:13 +0100594 width = get_unaligned_le32(&bmp->header.width);
595 height = get_unaligned_le32(&bmp->header.height);
596 bmp_bpix = get_unaligned_le16(&bmp->header.bit_count);
Simon Glass8d379f12015-05-13 07:02:28 -0600597 hdr_size = get_unaligned_le16(&bmp->header.size);
598 debug("hdr_size=%d, bmp_bpix=%d\n", hdr_size, bmp_bpix);
Przemyslaw Marczakdca2a1c2014-01-22 11:24:13 +0100599
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100600 colors = 1 << bmp_bpix;
wdenk8655b6f2004-10-09 23:25:58 +0000601
602 bpix = NBITS(panel_info.vl_bpix);
603
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000604 if (bpix != 1 && bpix != 8 && bpix != 16 && bpix != 32) {
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100605 printf ("Error: %d bit/pixel mode, but BMP has %d bit/pixel\n",
606 bpix, bmp_bpix);
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000607
wdenk8655b6f2004-10-09 23:25:58 +0000608 return 1;
609 }
610
Hannes Petermaiera305fb12014-07-15 16:28:46 +0200611 /*
612 * We support displaying 8bpp BMPs on 16bpp LCDs
613 * and displaying 24bpp BMPs on 32bpp LCDs
614 * */
615 if (bpix != bmp_bpix &&
616 !(bmp_bpix == 8 && bpix == 16) &&
617 !(bmp_bpix == 24 && bpix == 32)) {
wdenk8655b6f2004-10-09 23:25:58 +0000618 printf ("Error: %d bit/pixel mode, but BMP has %d bit/pixel\n",
Przemyslaw Marczakdca2a1c2014-01-22 11:24:13 +0100619 bpix, get_unaligned_le16(&bmp->header.bit_count));
wdenk8655b6f2004-10-09 23:25:58 +0000620 return 1;
621 }
622
Simon Glass8d379f12015-05-13 07:02:28 -0600623 debug("Display-bmp: %d x %d with %d colors, display %d\n",
624 (int)width, (int)height, (int)colors, 1 << bpix);
wdenk8655b6f2004-10-09 23:25:58 +0000625
Nikita Kiryanov0b29a892015-02-03 13:32:27 +0200626 if (bmp_bpix == 8)
627 lcd_set_cmap(bmp, colors);
Wolfgang Denke8143e72006-08-30 23:09:00 +0200628
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000629 padded_width = (width & 0x3 ? (width & ~0x3) + 4 : width);
Matthias Weisser1ca298c2009-07-09 16:07:30 +0200630
631#ifdef CONFIG_SPLASH_SCREEN_ALIGN
Nikita Kiryanov7c7e2802012-08-09 00:14:51 +0000632 splash_align_axis(&x, pwidth, width);
633 splash_align_axis(&y, panel_info.vl_row, height);
Matthias Weisser1ca298c2009-07-09 16:07:30 +0200634#endif /* CONFIG_SPLASH_SCREEN_ALIGN */
635
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000636 if ((x + width) > pwidth)
Wolfgang Denke8143e72006-08-30 23:09:00 +0200637 width = pwidth - x;
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000638 if ((y + height) > panel_info.vl_row)
wdenk8655b6f2004-10-09 23:25:58 +0000639 height = panel_info.vl_row - y;
640
Przemyslaw Marczakdca2a1c2014-01-22 11:24:13 +0100641 bmap = (uchar *)bmp + get_unaligned_le32(&bmp->header.data_offset);
642 fb = (uchar *)(lcd_base +
Liu Ying8d46d5b2011-01-11 15:29:58 +0800643 (y + height - 1) * lcd_line_length + x * bpix / 8);
Mark Jacksona303dfb2009-02-06 10:37:49 +0100644
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100645 switch (bmp_bpix) {
Nikita Kiryanovc8d2feb2015-02-03 13:32:29 +0200646 case 1:
Simon Glass01564442014-10-15 04:53:04 -0600647 case 8: {
Nikita Kiryanov0b29a892015-02-03 13:32:27 +0200648 cmap_base = configuration_get_cmap();
Tom Wai-Hong Tam45d7f522012-09-28 15:11:16 +0000649#ifdef CONFIG_LCD_BMP_RLE8
Przemyslaw Marczakdca2a1c2014-01-22 11:24:13 +0100650 u32 compression = get_unaligned_le32(&bmp->header.compression);
Simon Glass8d379f12015-05-13 07:02:28 -0600651 debug("compressed %d %d\n", compression, BMP_BI_RLE8);
Przemyslaw Marczakdca2a1c2014-01-22 11:24:13 +0100652 if (compression == BMP_BI_RLE8) {
Tom Wai-Hong Tam45d7f522012-09-28 15:11:16 +0000653 if (bpix != 16) {
654 /* TODO implement render code for bpix != 16 */
655 printf("Error: only support 16 bpix");
656 return 1;
657 }
658 lcd_display_rle8_bitmap(bmp, cmap_base, fb, x, y);
659 break;
660 }
661#endif
662
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100663 if (bpix != 16)
664 byte_width = width;
665 else
666 byte_width = width * 2;
667
Mark Jacksona303dfb2009-02-06 10:37:49 +0100668 for (i = 0; i < height; ++i) {
669 WATCHDOG_RESET();
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100670 for (j = 0; j < width; j++) {
671 if (bpix != 16) {
Nikita Kiryanov27fad012015-02-03 13:32:23 +0200672 fb_put_byte(&fb, &bmap);
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100673 } else {
Simon Glass8d379f12015-05-13 07:02:28 -0600674 struct bmp_color_table_entry *entry;
675 uint val;
676
677 if (cmap_base) {
678 val = cmap_base[*bmap];
679 } else {
680 entry = &palette[*bmap];
681 val = entry->blue >> 3 |
682 entry->green >> 2 << 5 |
683 entry->red >> 3 << 11;
684 }
685 *(uint16_t *)fb = val;
686 bmap++;
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100687 fb += sizeof(uint16_t) / sizeof(*fb);
688 }
689 }
Tom Wai-Hong Tamfecac462012-09-28 15:11:14 +0000690 bmap += (padded_width - width);
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000691 fb -= byte_width + lcd_line_length;
Mark Jacksona303dfb2009-02-06 10:37:49 +0100692 }
693 break;
Simon Glass01564442014-10-15 04:53:04 -0600694 }
Mark Jacksona303dfb2009-02-06 10:37:49 +0100695#if defined(CONFIG_BMP_16BPP)
696 case 16:
697 for (i = 0; i < height; ++i) {
698 WATCHDOG_RESET();
Nikita Kiryanovbfdcc652012-08-09 00:14:53 +0000699 for (j = 0; j < width; j++)
700 fb_put_word(&fb, &bmap);
701
Tom Wai-Hong Tamfecac462012-09-28 15:11:14 +0000702 bmap += (padded_width - width) * 2;
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000703 fb -= width * 2 + lcd_line_length;
Mark Jacksona303dfb2009-02-06 10:37:49 +0100704 }
705 break;
706#endif /* CONFIG_BMP_16BPP */
Hannes Petermaiera305fb12014-07-15 16:28:46 +0200707#if defined(CONFIG_BMP_24BMP)
708 case 24:
709 for (i = 0; i < height; ++i) {
710 for (j = 0; j < width; j++) {
711 *(fb++) = *(bmap++);
712 *(fb++) = *(bmap++);
713 *(fb++) = *(bmap++);
714 *(fb++) = 0;
715 }
716 fb -= lcd_line_length + width * (bpix / 8);
717 }
718 break;
719#endif /* CONFIG_BMP_24BMP */
Donghwa Leefb6a9aa2012-05-09 19:23:37 +0000720#if defined(CONFIG_BMP_32BPP)
721 case 32:
722 for (i = 0; i < height; ++i) {
723 for (j = 0; j < width; j++) {
724 *(fb++) = *(bmap++);
725 *(fb++) = *(bmap++);
726 *(fb++) = *(bmap++);
727 *(fb++) = *(bmap++);
728 }
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000729 fb -= lcd_line_length + width * (bpix / 8);
Donghwa Leefb6a9aa2012-05-09 19:23:37 +0000730 }
731 break;
732#endif /* CONFIG_BMP_32BPP */
Mark Jacksona303dfb2009-02-06 10:37:49 +0100733 default:
734 break;
735 };
wdenk8655b6f2004-10-09 23:25:58 +0000736
Simon Glass9a8efc42012-10-30 13:40:18 +0000737 lcd_sync();
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000738 return 0;
wdenk8655b6f2004-10-09 23:25:58 +0000739}
Jon Loeligerc3517f92007-07-08 18:10:08 -0500740#endif
wdenk8655b6f2004-10-09 23:25:58 +0000741
Nikita Kiryanov7bf71d12015-02-03 13:32:32 +0200742static void lcd_logo(void)
wdenk8655b6f2004-10-09 23:25:58 +0000743{
Nikita Kiryanovbf21a5d2015-02-03 13:32:30 +0200744 lcd_logo_plot(0, 0);
wdenk8655b6f2004-10-09 23:25:58 +0000745
Haavard Skinnemoen6b59e032008-09-01 16:21:22 +0200746#ifdef CONFIG_LCD_INFO
Nikita Kiryanov140beb92014-12-08 17:14:41 +0200747 lcd_set_col(LCD_INFO_X / VIDEO_FONT_WIDTH);
748 lcd_set_row(LCD_INFO_Y / VIDEO_FONT_HEIGHT);
Haavard Skinnemoen6b59e032008-09-01 16:21:22 +0200749 lcd_show_board_info();
750#endif /* CONFIG_LCD_INFO */
wdenk8655b6f2004-10-09 23:25:58 +0000751}
752
Nikita Kiryanovc0880482013-02-24 21:28:43 +0000753#ifdef CONFIG_SPLASHIMAGE_GUARD
754static int on_splashimage(const char *name, const char *value, enum env_op op,
755 int flags)
756{
757 ulong addr;
758 int aligned;
759
760 if (op == env_op_delete)
761 return 0;
762
763 addr = simple_strtoul(value, NULL, 16);
764 /* See README.displaying-bmps */
765 aligned = (addr % 4 == 2);
766 if (!aligned) {
767 printf("Invalid splashimage value. Value must be 16 bit aligned, but not 32 bit aligned\n");
768 return -1;
769 }
770
771 return 0;
772}
773
774U_BOOT_ENV_CALLBACK(splashimage, on_splashimage);
775#endif
776
Vadim Bendebury395166c2012-09-28 15:11:13 +0000777int lcd_get_pixel_width(void)
778{
779 return panel_info.vl_col;
780}
781
782int lcd_get_pixel_height(void)
783{
784 return panel_info.vl_row;
785}