blob: 217ec9dbd2e9ec3cefdaea4a63e5be2725b445dc [file] [log] [blame]
wdenk8655b6f2004-10-09 23:25:58 +00001/*
2 * Common LCD routines for supported CPUs
3 *
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
10/************************************************************************/
11/* ** HEADER FILES */
12/************************************************************************/
13
14/* #define DEBUG */
15
16#include <config.h>
17#include <common.h>
18#include <command.h>
wdenk8655b6f2004-10-09 23:25:58 +000019#include <stdarg.h>
Nikita Kiryanovc0880482013-02-24 21:28:43 +000020#include <search.h>
21#include <env_callback.h>
wdenk8655b6f2004-10-09 23:25:58 +000022#include <linux/types.h>
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +020023#include <stdio_dev.h>
wdenk8655b6f2004-10-09 23:25:58 +000024#if defined(CONFIG_POST)
25#include <post.h>
26#endif
27#include <lcd.h>
wdenk8b0bfc62005-04-03 23:11:38 +000028#include <watchdog.h>
Przemyslaw Marczakdca2a1c2014-01-22 11:24:13 +010029#include <asm/unaligned.h>
Robert Winklerdd4425e2013-06-17 11:31:29 -070030#include <splash.h>
Simon Glass7d95f2a2014-02-27 13:26:19 -070031#include <asm/io.h>
32#include <asm/unaligned.h>
Robert Winklerdd4425e2013-06-17 11:31:29 -070033
Marek Vasutabc20ab2011-11-26 07:20:07 +010034#if defined(CONFIG_CPU_PXA25X) || defined(CONFIG_CPU_PXA27X) || \
35 defined(CONFIG_CPU_MONAHANS)
36#define CONFIG_CPU_PXA
wdenk8655b6f2004-10-09 23:25:58 +000037#include <asm/byteorder.h>
38#endif
39
40#if defined(CONFIG_MPC823)
wdenk8655b6f2004-10-09 23:25:58 +000041#include <lcdvideo.h>
42#endif
43
Stelian Pop39cf4802008-05-09 21:57:18 +020044#if defined(CONFIG_ATMEL_LCD)
45#include <atmel_lcdc.h>
Stelian Pop39cf4802008-05-09 21:57:18 +020046#endif
47
Stephen Warren6a195d22013-05-27 18:31:17 +000048#if defined(CONFIG_LCD_DT_SIMPLEFB)
49#include <libfdt.h>
50#endif
51
wdenk8655b6f2004-10-09 23:25:58 +000052/************************************************************************/
53/* ** FONT DATA */
54/************************************************************************/
55#include <video_font.h> /* Get font data, width and height */
56
wdenk88804d12005-07-04 00:03:16 +000057/************************************************************************/
58/* ** LOGO DATA */
59/************************************************************************/
60#ifdef CONFIG_LCD_LOGO
61# include <bmp_logo.h> /* Get logo data, width and height */
Che-Liang Chiouc2707302011-10-20 23:04:20 +000062# include <bmp_logo_data.h>
Alessandro Rubiniacb13862010-03-13 17:44:08 +010063# if (CONSOLE_COLOR_WHITE >= BMP_LOGO_OFFSET) && (LCD_BPP != LCD_COLOR16)
wdenk88804d12005-07-04 00:03:16 +000064# error Default Color Map overlaps with Logo Color Map
65# endif
66#endif
wdenk8655b6f2004-10-09 23:25:58 +000067
Simon Glass7d95f2a2014-02-27 13:26:19 -070068#ifdef CONFIG_SANDBOX
69#include <asm/sdl.h>
70#endif
71
Simon Glass676d3192012-10-17 13:24:54 +000072#ifndef CONFIG_LCD_ALIGNMENT
73#define CONFIG_LCD_ALIGNMENT PAGE_SIZE
74#endif
75
Simon Glass0d89efe2012-10-17 13:24:59 +000076/* By default we scroll by a single line */
77#ifndef CONFIG_CONSOLE_SCROLL_LINES
78#define CONFIG_CONSOLE_SCROLL_LINES 1
79#endif
80
Jeroen Hofsteea5796c52013-01-12 12:07:59 +000081/************************************************************************/
82/* ** CONSOLE DEFINITIONS & FUNCTIONS */
83/************************************************************************/
84#if defined(CONFIG_LCD_LOGO) && !defined(CONFIG_LCD_INFO_BELOW_LOGO)
85# define CONSOLE_ROWS ((panel_info.vl_row-BMP_LOGO_HEIGHT) \
86 / VIDEO_FONT_HEIGHT)
87#else
88# define CONSOLE_ROWS (panel_info.vl_row / VIDEO_FONT_HEIGHT)
89#endif
Wolfgang Denkd87080b2006-03-31 18:32:53 +020090
Jeroen Hofsteea5796c52013-01-12 12:07:59 +000091#define CONSOLE_COLS (panel_info.vl_col / VIDEO_FONT_WIDTH)
92#define CONSOLE_ROW_SIZE (VIDEO_FONT_HEIGHT * lcd_line_length)
93#define CONSOLE_ROW_FIRST lcd_console_address
94#define CONSOLE_ROW_SECOND (lcd_console_address + CONSOLE_ROW_SIZE)
95#define CONSOLE_ROW_LAST (lcd_console_address + CONSOLE_SIZE \
96 - CONSOLE_ROW_SIZE)
97#define CONSOLE_SIZE (CONSOLE_ROW_SIZE * CONSOLE_ROWS)
98#define CONSOLE_SCROLL_SIZE (CONSOLE_SIZE - CONSOLE_ROW_SIZE)
99
100#if LCD_BPP == LCD_MONOCHROME
101# define COLOR_MASK(c) ((c) | (c) << 1 | (c) << 2 | (c) << 3 | \
102 (c) << 4 | (c) << 5 | (c) << 6 | (c) << 7)
Hannes Petermaier57d76a82014-03-07 18:55:40 +0100103#elif (LCD_BPP == LCD_COLOR8) || (LCD_BPP == LCD_COLOR16) || \
104 (LCD_BPP == LCD_COLOR32)
Jeroen Hofsteea5796c52013-01-12 12:07:59 +0000105# define COLOR_MASK(c) (c)
106#else
107# error Unsupported LCD BPP.
108#endif
109
wdenk8655b6f2004-10-09 23:25:58 +0000110DECLARE_GLOBAL_DATA_PTR;
wdenk8655b6f2004-10-09 23:25:58 +0000111
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000112static void lcd_drawchars(ushort x, ushort y, uchar *str, int count);
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000113static inline void lcd_putc_xy(ushort x, ushort y, uchar c);
wdenk8655b6f2004-10-09 23:25:58 +0000114
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000115static int lcd_init(void *lcdbase);
wdenk8655b6f2004-10-09 23:25:58 +0000116
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000117static void *lcd_logo(void);
wdenk8655b6f2004-10-09 23:25:58 +0000118
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000119static void lcd_setfgcolor(int color);
120static void lcd_setbgcolor(int color);
wdenk8655b6f2004-10-09 23:25:58 +0000121
Wolfgang Denk46d1d5d2013-01-05 09:45:48 +0000122static int lcd_color_fg;
123static int lcd_color_bg;
Jeroen Hofsteef1d205a2013-01-22 10:44:11 +0000124int lcd_line_length;
Wolfgang Denk46d1d5d2013-01-05 09:45:48 +0000125
wdenk8655b6f2004-10-09 23:25:58 +0000126char lcd_is_enabled = 0;
wdenk8655b6f2004-10-09 23:25:58 +0000127
Jeroen Hofsteef1d205a2013-01-22 10:44:11 +0000128static short console_col;
129static short console_row;
130
131static void *lcd_console_address;
Jeroen Hofstee00a0ca52013-01-22 10:44:12 +0000132static void *lcd_base; /* Start of framebuffer memory */
Jeroen Hofsteef1d205a2013-01-22 10:44:11 +0000133
Simon Glass9a8efc42012-10-30 13:40:18 +0000134static char lcd_flush_dcache; /* 1 to flush dcache after each lcd update */
135
wdenk8655b6f2004-10-09 23:25:58 +0000136/************************************************************************/
137
Simon Glass9a8efc42012-10-30 13:40:18 +0000138/* Flush LCD activity to the caches */
139void lcd_sync(void)
140{
141 /*
142 * flush_dcache_range() is declared in common.h but it seems that some
143 * architectures do not actually implement it. Is there a way to find
144 * out whether it exists? For now, ARM is safe.
145 */
146#if defined(CONFIG_ARM) && !defined(CONFIG_SYS_DCACHE_OFF)
147 int line_length;
148
149 if (lcd_flush_dcache)
150 flush_dcache_range((u32)lcd_base,
151 (u32)(lcd_base + lcd_get_size(&line_length)));
Simon Glass7d95f2a2014-02-27 13:26:19 -0700152#elif defined(CONFIG_SANDBOX) && defined(CONFIG_VIDEO_SANDBOX_SDL)
153 static ulong last_sync;
154
155 if (get_timer(last_sync) > 10) {
156 sandbox_sdl_sync(lcd_base);
157 last_sync = get_timer(0);
158 }
Simon Glass9a8efc42012-10-30 13:40:18 +0000159#endif
160}
161
162void lcd_set_flush_dcache(int flush)
163{
164 lcd_flush_dcache = (flush != 0);
165}
166
wdenk8655b6f2004-10-09 23:25:58 +0000167/*----------------------------------------------------------------------*/
168
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000169static void console_scrollup(void)
wdenk8655b6f2004-10-09 23:25:58 +0000170{
Simon Glass0d89efe2012-10-17 13:24:59 +0000171 const int rows = CONFIG_CONSOLE_SCROLL_LINES;
wdenk8655b6f2004-10-09 23:25:58 +0000172
Simon Glass0d89efe2012-10-17 13:24:59 +0000173 /* Copy up rows ignoring those that will be overwritten */
174 memcpy(CONSOLE_ROW_FIRST,
175 lcd_console_address + CONSOLE_ROW_SIZE * rows,
176 CONSOLE_SIZE - CONSOLE_ROW_SIZE * rows);
177
178 /* Clear the last rows */
Hannes Petermaier57d76a82014-03-07 18:55:40 +0100179#if (LCD_BPP != LCD_COLOR32)
Simon Glass0d89efe2012-10-17 13:24:59 +0000180 memset(lcd_console_address + CONSOLE_SIZE - CONSOLE_ROW_SIZE * rows,
181 COLOR_MASK(lcd_color_bg),
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000182 CONSOLE_ROW_SIZE * rows);
Hannes Petermaier57d76a82014-03-07 18:55:40 +0100183#else
184 u32 *ppix = lcd_console_address +
185 CONSOLE_SIZE - CONSOLE_ROW_SIZE * rows;
186 u32 i;
187 for (i = 0;
188 i < (CONSOLE_ROW_SIZE * rows) / NBYTES(panel_info.vl_bpix);
189 i++) {
190 *ppix++ = COLOR_MASK(lcd_color_bg);
191 }
192#endif
Simon Glass9a8efc42012-10-30 13:40:18 +0000193 lcd_sync();
Simon Glass0d89efe2012-10-17 13:24:59 +0000194 console_row -= rows;
wdenk8655b6f2004-10-09 23:25:58 +0000195}
196
197/*----------------------------------------------------------------------*/
198
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000199static inline void console_back(void)
wdenk8655b6f2004-10-09 23:25:58 +0000200{
201 if (--console_col < 0) {
202 console_col = CONSOLE_COLS-1 ;
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000203 if (--console_row < 0)
wdenk8655b6f2004-10-09 23:25:58 +0000204 console_row = 0;
wdenk8655b6f2004-10-09 23:25:58 +0000205 }
206
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000207 lcd_putc_xy(console_col * VIDEO_FONT_WIDTH,
208 console_row * VIDEO_FONT_HEIGHT, ' ');
wdenk8655b6f2004-10-09 23:25:58 +0000209}
210
211/*----------------------------------------------------------------------*/
212
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000213static inline void console_newline(void)
wdenk8655b6f2004-10-09 23:25:58 +0000214{
wdenk8655b6f2004-10-09 23:25:58 +0000215 console_col = 0;
216
217 /* Check if we need to scroll the terminal */
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000218 if (++console_row >= CONSOLE_ROWS)
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000219 console_scrollup();
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000220 else
Simon Glass9a8efc42012-10-30 13:40:18 +0000221 lcd_sync();
wdenk8655b6f2004-10-09 23:25:58 +0000222}
223
224/*----------------------------------------------------------------------*/
225
Simon Glass709ea542014-07-23 06:54:59 -0600226static void lcd_stub_putc(struct stdio_dev *dev, const char c)
227{
228 lcd_putc(c);
229}
230
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000231void lcd_putc(const char c)
wdenk8655b6f2004-10-09 23:25:58 +0000232{
233 if (!lcd_is_enabled) {
234 serial_putc(c);
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000235
wdenk8655b6f2004-10-09 23:25:58 +0000236 return;
237 }
238
239 switch (c) {
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000240 case '\r':
241 console_col = 0;
wdenk8655b6f2004-10-09 23:25:58 +0000242
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000243 return;
244 case '\n':
245 console_newline();
wdenk8655b6f2004-10-09 23:25:58 +0000246
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000247 return;
wdenk8655b6f2004-10-09 23:25:58 +0000248 case '\t': /* Tab (8 chars alignment) */
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000249 console_col += 8;
250 console_col &= ~7;
wdenk8655b6f2004-10-09 23:25:58 +0000251
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000252 if (console_col >= CONSOLE_COLS)
253 console_newline();
wdenk8655b6f2004-10-09 23:25:58 +0000254
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000255 return;
256 case '\b':
257 console_back();
wdenk8655b6f2004-10-09 23:25:58 +0000258
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000259 return;
260 default:
261 lcd_putc_xy(console_col * VIDEO_FONT_WIDTH,
262 console_row * VIDEO_FONT_HEIGHT, c);
263 if (++console_col >= CONSOLE_COLS)
264 console_newline();
wdenk8655b6f2004-10-09 23:25:58 +0000265 }
wdenk8655b6f2004-10-09 23:25:58 +0000266}
267
268/*----------------------------------------------------------------------*/
269
Simon Glass709ea542014-07-23 06:54:59 -0600270static void lcd_stub_puts(struct stdio_dev *dev, const char *s)
271{
272 lcd_puts(s);
273}
274
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000275void lcd_puts(const char *s)
wdenk8655b6f2004-10-09 23:25:58 +0000276{
277 if (!lcd_is_enabled) {
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000278 serial_puts(s);
279
wdenk8655b6f2004-10-09 23:25:58 +0000280 return;
281 }
282
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000283 while (*s)
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000284 lcd_putc(*s++);
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000285
Simon Glass9a8efc42012-10-30 13:40:18 +0000286 lcd_sync();
wdenk8655b6f2004-10-09 23:25:58 +0000287}
288
Haavard Skinnemoen15b17ab2008-09-01 16:21:20 +0200289/*----------------------------------------------------------------------*/
290
291void lcd_printf(const char *fmt, ...)
292{
293 va_list args;
294 char buf[CONFIG_SYS_PBSIZE];
295
296 va_start(args, fmt);
297 vsprintf(buf, fmt, args);
298 va_end(args);
299
300 lcd_puts(buf);
301}
302
wdenk8655b6f2004-10-09 23:25:58 +0000303/************************************************************************/
304/* ** Low-Level Graphics Routines */
305/************************************************************************/
306
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000307static void lcd_drawchars(ushort x, ushort y, uchar *str, int count)
wdenk8655b6f2004-10-09 23:25:58 +0000308{
309 uchar *dest;
Marek Vasutbe547c62011-09-26 02:26:04 +0200310 ushort row;
311
Anatolij Gustschin0f999c42012-04-27 04:41:16 +0000312#if defined(CONFIG_LCD_LOGO) && !defined(CONFIG_LCD_INFO_BELOW_LOGO)
313 y += BMP_LOGO_HEIGHT;
314#endif
315
Marek Vasutbe547c62011-09-26 02:26:04 +0200316#if LCD_BPP == LCD_MONOCHROME
317 ushort off = x * (1 << LCD_BPP) % 8;
318#endif
wdenk8655b6f2004-10-09 23:25:58 +0000319
Hannes Petermaier57d76a82014-03-07 18:55:40 +0100320 dest = (uchar *)(lcd_base + y * lcd_line_length + x * NBITS(LCD_BPP)/8);
wdenk8655b6f2004-10-09 23:25:58 +0000321
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000322 for (row = 0; row < VIDEO_FONT_HEIGHT; ++row, dest += lcd_line_length) {
wdenk8655b6f2004-10-09 23:25:58 +0000323 uchar *s = str;
wdenk8655b6f2004-10-09 23:25:58 +0000324 int i;
Alessandro Rubiniacb13862010-03-13 17:44:08 +0100325#if LCD_BPP == LCD_COLOR16
326 ushort *d = (ushort *)dest;
Hannes Petermaier57d76a82014-03-07 18:55:40 +0100327#elif LCD_BPP == LCD_COLOR32
328 u32 *d = (u32 *)dest;
Alessandro Rubiniacb13862010-03-13 17:44:08 +0100329#else
330 uchar *d = dest;
331#endif
wdenk8655b6f2004-10-09 23:25:58 +0000332
333#if LCD_BPP == LCD_MONOCHROME
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000334 uchar rest = *d & -(1 << (8 - off));
wdenk8655b6f2004-10-09 23:25:58 +0000335 uchar sym;
336#endif
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000337 for (i = 0; i < count; ++i) {
wdenk8655b6f2004-10-09 23:25:58 +0000338 uchar c, bits;
339
340 c = *s++;
341 bits = video_fontdata[c * VIDEO_FONT_HEIGHT + row];
342
343#if LCD_BPP == LCD_MONOCHROME
344 sym = (COLOR_MASK(lcd_color_fg) & bits) |
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000345 (COLOR_MASK(lcd_color_bg) & ~bits);
wdenk8655b6f2004-10-09 23:25:58 +0000346
347 *d++ = rest | (sym >> off);
348 rest = sym << (8-off);
349#elif LCD_BPP == LCD_COLOR8
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000350 for (c = 0; c < 8; ++c) {
wdenk8655b6f2004-10-09 23:25:58 +0000351 *d++ = (bits & 0x80) ?
352 lcd_color_fg : lcd_color_bg;
353 bits <<= 1;
354 }
355#elif LCD_BPP == LCD_COLOR16
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000356 for (c = 0; c < 8; ++c) {
wdenk8655b6f2004-10-09 23:25:58 +0000357 *d++ = (bits & 0x80) ?
358 lcd_color_fg : lcd_color_bg;
359 bits <<= 1;
360 }
Hannes Petermaier57d76a82014-03-07 18:55:40 +0100361#elif LCD_BPP == LCD_COLOR32
362 for (c = 0; c < 8; ++c) {
363 *d++ = (bits & 0x80) ?
364 lcd_color_fg : lcd_color_bg;
365 bits <<= 1;
366 }
wdenk8655b6f2004-10-09 23:25:58 +0000367#endif
368 }
369#if LCD_BPP == LCD_MONOCHROME
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000370 *d = rest | (*d & ((1 << (8 - off)) - 1));
wdenk8655b6f2004-10-09 23:25:58 +0000371#endif
372 }
373}
374
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000375static inline void lcd_putc_xy(ushort x, ushort y, uchar c)
wdenk8655b6f2004-10-09 23:25:58 +0000376{
Anatolij Gustschin0f999c42012-04-27 04:41:16 +0000377 lcd_drawchars(x, y, &c, 1);
wdenk8655b6f2004-10-09 23:25:58 +0000378}
379
380/************************************************************************/
381/** Small utility to check that you got the colours right */
382/************************************************************************/
383#ifdef LCD_TEST_PATTERN
384
385#define N_BLK_VERT 2
386#define N_BLK_HOR 3
387
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000388static int test_colors[N_BLK_HOR * N_BLK_VERT] = {
wdenk8655b6f2004-10-09 23:25:58 +0000389 CONSOLE_COLOR_RED, CONSOLE_COLOR_GREEN, CONSOLE_COLOR_YELLOW,
390 CONSOLE_COLOR_BLUE, CONSOLE_COLOR_MAGENTA, CONSOLE_COLOR_CYAN,
391};
392
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000393static void test_pattern(void)
wdenk8655b6f2004-10-09 23:25:58 +0000394{
395 ushort v_max = panel_info.vl_row;
396 ushort h_max = panel_info.vl_col;
397 ushort v_step = (v_max + N_BLK_VERT - 1) / N_BLK_VERT;
398 ushort h_step = (h_max + N_BLK_HOR - 1) / N_BLK_HOR;
399 ushort v, h;
400 uchar *pix = (uchar *)lcd_base;
401
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000402 printf("[LCD] Test Pattern: %d x %d [%d x %d]\n",
wdenk8655b6f2004-10-09 23:25:58 +0000403 h_max, v_max, h_step, v_step);
404
405 /* WARNING: Code silently assumes 8bit/pixel */
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000406 for (v = 0; v < v_max; ++v) {
wdenk8655b6f2004-10-09 23:25:58 +0000407 uchar iy = v / v_step;
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000408 for (h = 0; h < h_max; ++h) {
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000409 uchar ix = N_BLK_HOR * iy + h / h_step;
wdenk8655b6f2004-10-09 23:25:58 +0000410 *pix++ = test_colors[ix];
411 }
412 }
413}
414#endif /* LCD_TEST_PATTERN */
415
416
417/************************************************************************/
418/* ** GENERIC Initialization Routines */
419/************************************************************************/
Anatolij Gustschincefa4712013-11-09 11:00:09 +0100420/*
421 * With most lcd drivers the line length is set up
422 * by calculating it from panel_info parameters. Some
423 * drivers need to calculate the line length differently,
424 * so make the function weak to allow overriding it.
425 */
426__weak int lcd_get_size(int *line_length)
Simon Glass676d3192012-10-17 13:24:54 +0000427{
428 *line_length = (panel_info.vl_col * NBITS(panel_info.vl_bpix)) / 8;
429 return *line_length * panel_info.vl_row;
430}
431
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000432int drv_lcd_init(void)
wdenk8655b6f2004-10-09 23:25:58 +0000433{
Jean-Christophe PLAGNIOL-VILLARD52cb4d42009-05-16 12:14:54 +0200434 struct stdio_dev lcddev;
wdenk8655b6f2004-10-09 23:25:58 +0000435 int rc;
436
Simon Glass7d95f2a2014-02-27 13:26:19 -0700437 lcd_base = map_sysmem(gd->fb_base, 0);
wdenk8655b6f2004-10-09 23:25:58 +0000438
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000439 lcd_init(lcd_base); /* LCD initialization */
wdenk8655b6f2004-10-09 23:25:58 +0000440
441 /* Device initialization */
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000442 memset(&lcddev, 0, sizeof(lcddev));
wdenk8655b6f2004-10-09 23:25:58 +0000443
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000444 strcpy(lcddev.name, "lcd");
wdenk8655b6f2004-10-09 23:25:58 +0000445 lcddev.ext = 0; /* No extensions */
446 lcddev.flags = DEV_FLAGS_OUTPUT; /* Output only */
Simon Glass709ea542014-07-23 06:54:59 -0600447 lcddev.putc = lcd_stub_putc; /* 'putc' function */
448 lcddev.puts = lcd_stub_puts; /* 'puts' function */
wdenk8655b6f2004-10-09 23:25:58 +0000449
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000450 rc = stdio_register(&lcddev);
wdenk8655b6f2004-10-09 23:25:58 +0000451
452 return (rc == 0) ? 1 : rc;
453}
454
455/*----------------------------------------------------------------------*/
Che-Liang Chiou02110902011-10-20 23:07:03 +0000456void lcd_clear(void)
wdenk8655b6f2004-10-09 23:25:58 +0000457{
458#if LCD_BPP == LCD_MONOCHROME
459 /* Setting the palette */
460 lcd_initcolregs();
461
462#elif LCD_BPP == LCD_COLOR8
463 /* Setting the palette */
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000464 lcd_setcolreg(CONSOLE_COLOR_BLACK, 0, 0, 0);
465 lcd_setcolreg(CONSOLE_COLOR_RED, 0xFF, 0, 0);
466 lcd_setcolreg(CONSOLE_COLOR_GREEN, 0, 0xFF, 0);
467 lcd_setcolreg(CONSOLE_COLOR_YELLOW, 0xFF, 0xFF, 0);
468 lcd_setcolreg(CONSOLE_COLOR_BLUE, 0, 0, 0xFF);
469 lcd_setcolreg(CONSOLE_COLOR_MAGENTA, 0xFF, 0, 0xFF);
470 lcd_setcolreg(CONSOLE_COLOR_CYAN, 0, 0xFF, 0xFF);
471 lcd_setcolreg(CONSOLE_COLOR_GREY, 0xAA, 0xAA, 0xAA);
472 lcd_setcolreg(CONSOLE_COLOR_WHITE, 0xFF, 0xFF, 0xFF);
wdenk8655b6f2004-10-09 23:25:58 +0000473#endif
474
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200475#ifndef CONFIG_SYS_WHITE_ON_BLACK
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000476 lcd_setfgcolor(CONSOLE_COLOR_BLACK);
477 lcd_setbgcolor(CONSOLE_COLOR_WHITE);
wdenk8655b6f2004-10-09 23:25:58 +0000478#else
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000479 lcd_setfgcolor(CONSOLE_COLOR_WHITE);
480 lcd_setbgcolor(CONSOLE_COLOR_BLACK);
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200481#endif /* CONFIG_SYS_WHITE_ON_BLACK */
wdenk8655b6f2004-10-09 23:25:58 +0000482
483#ifdef LCD_TEST_PATTERN
484 test_pattern();
485#else
486 /* set framebuffer to background color */
Hannes Petermaier57d76a82014-03-07 18:55:40 +0100487#if (LCD_BPP != LCD_COLOR32)
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000488 memset((char *)lcd_base,
Hannes Petermaier8d9eaaf2014-03-07 18:45:20 +0100489 COLOR_MASK(lcd_color_bg),
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000490 lcd_line_length * panel_info.vl_row);
Hannes Petermaier57d76a82014-03-07 18:55:40 +0100491#else
492 u32 *ppix = lcd_base;
493 u32 i;
494 for (i = 0;
495 i < (lcd_line_length * panel_info.vl_row)/NBYTES(panel_info.vl_bpix);
496 i++) {
497 *ppix++ = COLOR_MASK(lcd_color_bg);
498 }
499#endif
wdenk8655b6f2004-10-09 23:25:58 +0000500#endif
501 /* Paint the logo and retrieve LCD base address */
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000502 debug("[LCD] Drawing the logo...\n");
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000503 lcd_console_address = lcd_logo();
wdenk8655b6f2004-10-09 23:25:58 +0000504
505 console_col = 0;
506 console_row = 0;
Simon Glass9a8efc42012-10-30 13:40:18 +0000507 lcd_sync();
508}
509
510static int do_lcd_clear(cmd_tbl_t *cmdtp, int flag, int argc,
511 char *const argv[])
512{
513 lcd_clear();
514 return 0;
wdenk8655b6f2004-10-09 23:25:58 +0000515}
516
517U_BOOT_CMD(
Che-Liang Chiou02110902011-10-20 23:07:03 +0000518 cls, 1, 1, do_lcd_clear,
Peter Tyser2fb26042009-01-27 18:03:12 -0600519 "clear screen",
Wolfgang Denka89c33d2009-05-24 17:06:54 +0200520 ""
wdenk8655b6f2004-10-09 23:25:58 +0000521);
522
523/*----------------------------------------------------------------------*/
524
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000525static int lcd_init(void *lcdbase)
wdenk8655b6f2004-10-09 23:25:58 +0000526{
527 /* Initialize the lcd controller */
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000528 debug("[LCD] Initializing LCD frambuffer at %p\n", lcdbase);
wdenk8655b6f2004-10-09 23:25:58 +0000529
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000530 lcd_ctrl_init(lcdbase);
Anatolij Gustschin1d3dea12013-03-29 14:00:13 +0100531
532 /*
533 * lcd_ctrl_init() of some drivers (i.e. bcm2835 on rpi_b) ignores
534 * the 'lcdbase' argument and uses custom lcd base address
535 * by setting up gd->fb_base. Check for this condition and fixup
536 * 'lcd_base' address.
537 */
Simon Glass7d95f2a2014-02-27 13:26:19 -0700538 if (map_to_sysmem(lcdbase) != gd->fb_base)
539 lcd_base = map_sysmem(gd->fb_base, 0);
Anatolij Gustschin1d3dea12013-03-29 14:00:13 +0100540
541 debug("[LCD] Using LCD frambuffer at %p\n", lcd_base);
542
Stephen Warren6d330712013-01-29 16:37:38 +0000543 lcd_get_size(&lcd_line_length);
Haavard Skinnemoen6f93d2b2008-09-01 16:21:21 +0200544 lcd_is_enabled = 1;
Che-Liang Chiou02110902011-10-20 23:07:03 +0000545 lcd_clear();
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000546 lcd_enable();
wdenk8655b6f2004-10-09 23:25:58 +0000547
548 /* Initialize the console */
549 console_col = 0;
wdenk88804d12005-07-04 00:03:16 +0000550#ifdef CONFIG_LCD_INFO_BELOW_LOGO
wdenk8655b6f2004-10-09 23:25:58 +0000551 console_row = 7 + BMP_LOGO_HEIGHT / VIDEO_FONT_HEIGHT;
552#else
553 console_row = 1; /* leave 1 blank line below logo */
554#endif
wdenk8655b6f2004-10-09 23:25:58 +0000555
556 return 0;
557}
558
559
560/************************************************************************/
561/* ** ROM capable initialization part - needed to reserve FB memory */
562/************************************************************************/
563/*
564 * This is called early in the system initialization to grab memory
565 * for the LCD controller.
566 * Returns new address for monitor, after reserving LCD buffer memory
567 *
568 * Note that this is running from ROM, so no write access to global data.
569 */
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000570ulong lcd_setmem(ulong addr)
wdenk8655b6f2004-10-09 23:25:58 +0000571{
572 ulong size;
Simon Glass676d3192012-10-17 13:24:54 +0000573 int line_length;
wdenk8655b6f2004-10-09 23:25:58 +0000574
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000575 debug("LCD panel info: %d x %d, %d bit/pix\n", panel_info.vl_col,
576 panel_info.vl_row, NBITS(panel_info.vl_bpix));
wdenk8655b6f2004-10-09 23:25:58 +0000577
Simon Glass676d3192012-10-17 13:24:54 +0000578 size = lcd_get_size(&line_length);
wdenk8655b6f2004-10-09 23:25:58 +0000579
Simon Glass676d3192012-10-17 13:24:54 +0000580 /* Round up to nearest full page, or MMU section if defined */
581 size = ALIGN(size, CONFIG_LCD_ALIGNMENT);
582 addr = ALIGN(addr - CONFIG_LCD_ALIGNMENT + 1, CONFIG_LCD_ALIGNMENT);
wdenk8655b6f2004-10-09 23:25:58 +0000583
584 /* Allocate pages for the frame buffer. */
585 addr -= size;
586
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000587 debug("Reserving %ldk for LCD Framebuffer at: %08lx\n",
588 size >> 10, addr);
wdenk8655b6f2004-10-09 23:25:58 +0000589
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000590 return addr;
wdenk8655b6f2004-10-09 23:25:58 +0000591}
592
593/*----------------------------------------------------------------------*/
594
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000595static void lcd_setfgcolor(int color)
wdenk8655b6f2004-10-09 23:25:58 +0000596{
Stelian Pop39cf4802008-05-09 21:57:18 +0200597 lcd_color_fg = color;
wdenk8655b6f2004-10-09 23:25:58 +0000598}
599
600/*----------------------------------------------------------------------*/
601
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000602static void lcd_setbgcolor(int color)
wdenk8655b6f2004-10-09 23:25:58 +0000603{
Stelian Pop39cf4802008-05-09 21:57:18 +0200604 lcd_color_bg = color;
wdenk8655b6f2004-10-09 23:25:58 +0000605}
606
wdenk8655b6f2004-10-09 23:25:58 +0000607/************************************************************************/
608/* ** Chipset depending Bitmap / Logo stuff... */
609/************************************************************************/
Nikita Kiryanov203c37b2012-08-09 00:14:52 +0000610static inline ushort *configuration_get_cmap(void)
611{
612#if defined CONFIG_CPU_PXA
613 struct pxafb_info *fbi = &panel_info.pxa;
614 return (ushort *)fbi->palette;
615#elif defined(CONFIG_MPC823)
616 immap_t *immr = (immap_t *) CONFIG_SYS_IMMR;
617 cpm8xx_t *cp = &(immr->im_cpm);
618 return (ushort *)&(cp->lcd_cmap[255 * sizeof(ushort)]);
619#elif defined(CONFIG_ATMEL_LCD)
620 return (ushort *)(panel_info.mmio + ATMEL_LCDC_LUT(0));
Anatolij Gustschind23019f2012-09-22 06:55:53 +0000621#elif !defined(CONFIG_ATMEL_HLCD) && !defined(CONFIG_EXYNOS_FB)
622 return panel_info.cmap;
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000623#elif defined(CONFIG_LCD_LOGO)
Anatolij Gustschind23019f2012-09-22 06:55:53 +0000624 return bmp_logo_palette;
625#else
626 return NULL;
627#endif
Nikita Kiryanov203c37b2012-08-09 00:14:52 +0000628}
629
wdenk8655b6f2004-10-09 23:25:58 +0000630#ifdef CONFIG_LCD_LOGO
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000631void bitmap_plot(int x, int y)
wdenk8655b6f2004-10-09 23:25:58 +0000632{
Stelian Pop39cf4802008-05-09 21:57:18 +0200633#ifdef CONFIG_ATMEL_LCD
Nikita Kiryanov203c37b2012-08-09 00:14:52 +0000634 uint *cmap = (uint *)bmp_logo_palette;
Stelian Pop39cf4802008-05-09 21:57:18 +0200635#else
Nikita Kiryanov203c37b2012-08-09 00:14:52 +0000636 ushort *cmap = (ushort *)bmp_logo_palette;
Stelian Pop39cf4802008-05-09 21:57:18 +0200637#endif
wdenk8655b6f2004-10-09 23:25:58 +0000638 ushort i, j;
639 uchar *bmap;
640 uchar *fb;
641 ushort *fb16;
Nikita Kiryanov203c37b2012-08-09 00:14:52 +0000642#if defined(CONFIG_MPC823)
643 immap_t *immr = (immap_t *) CONFIG_SYS_IMMR;
644 cpm8xx_t *cp = &(immr->im_cpm);
wdenk8655b6f2004-10-09 23:25:58 +0000645#endif
Andre Renaud317461c2013-02-13 17:48:00 +0000646 unsigned bpix = NBITS(panel_info.vl_bpix);
wdenk8655b6f2004-10-09 23:25:58 +0000647
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000648 debug("Logo: width %d height %d colors %d cmap %d\n",
wdenk8655b6f2004-10-09 23:25:58 +0000649 BMP_LOGO_WIDTH, BMP_LOGO_HEIGHT, BMP_LOGO_COLORS,
Anatolij Gustschin095407d2012-04-27 04:41:06 +0000650 ARRAY_SIZE(bmp_logo_palette));
wdenk8655b6f2004-10-09 23:25:58 +0000651
652 bmap = &bmp_logo_bitmap[0];
Andre Renaud317461c2013-02-13 17:48:00 +0000653 fb = (uchar *)(lcd_base + y * lcd_line_length + x * bpix / 8);
wdenk8655b6f2004-10-09 23:25:58 +0000654
Andre Renaud317461c2013-02-13 17:48:00 +0000655 if (bpix < 12) {
Nikita Kiryanov203c37b2012-08-09 00:14:52 +0000656 /* Leave room for default color map
657 * default case: generic system with no cmap (most likely 16bpp)
658 * cmap was set to the source palette, so no change is done.
659 * This avoids even more ifdefs in the next stanza
660 */
661#if defined(CONFIG_MPC823)
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000662 cmap = (ushort *) &(cp->lcd_cmap[BMP_LOGO_OFFSET * sizeof(ushort)]);
Stelian Pop39cf4802008-05-09 21:57:18 +0200663#elif defined(CONFIG_ATMEL_LCD)
Nikita Kiryanov203c37b2012-08-09 00:14:52 +0000664 cmap = (uint *)configuration_get_cmap();
Alessandro Rubiniacb13862010-03-13 17:44:08 +0100665#else
Nikita Kiryanov203c37b2012-08-09 00:14:52 +0000666 cmap = configuration_get_cmap();
wdenk8655b6f2004-10-09 23:25:58 +0000667#endif
668
669 WATCHDOG_RESET();
670
671 /* Set color map */
Anatolij Gustschin095407d2012-04-27 04:41:06 +0000672 for (i = 0; i < ARRAY_SIZE(bmp_logo_palette); ++i) {
wdenk8655b6f2004-10-09 23:25:58 +0000673 ushort colreg = bmp_logo_palette[i];
Stelian Pop39cf4802008-05-09 21:57:18 +0200674#ifdef CONFIG_ATMEL_LCD
675 uint lut_entry;
676#ifdef CONFIG_ATMEL_LCD_BGR555
677 lut_entry = ((colreg & 0x000F) << 11) |
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000678 ((colreg & 0x00F0) << 2) |
679 ((colreg & 0x0F00) >> 7);
Stelian Pop39cf4802008-05-09 21:57:18 +0200680#else /* CONFIG_ATMEL_LCD_RGB565 */
681 lut_entry = ((colreg & 0x000F) << 1) |
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000682 ((colreg & 0x00F0) << 3) |
683 ((colreg & 0x0F00) << 4);
Stelian Pop39cf4802008-05-09 21:57:18 +0200684#endif
685 *(cmap + BMP_LOGO_OFFSET) = lut_entry;
686 cmap++;
687#else /* !CONFIG_ATMEL_LCD */
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200688#ifdef CONFIG_SYS_INVERT_COLORS
wdenk8655b6f2004-10-09 23:25:58 +0000689 *cmap++ = 0xffff - colreg;
690#else
691 *cmap++ = colreg;
692#endif
Stelian Pop39cf4802008-05-09 21:57:18 +0200693#endif /* CONFIG_ATMEL_LCD */
wdenk8655b6f2004-10-09 23:25:58 +0000694 }
695
696 WATCHDOG_RESET();
697
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000698 for (i = 0; i < BMP_LOGO_HEIGHT; ++i) {
699 memcpy(fb, bmap, BMP_LOGO_WIDTH);
wdenk8655b6f2004-10-09 23:25:58 +0000700 bmap += BMP_LOGO_WIDTH;
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000701 fb += panel_info.vl_col;
wdenk8655b6f2004-10-09 23:25:58 +0000702 }
703 }
704 else { /* true color mode */
Alessandro Rubiniacb13862010-03-13 17:44:08 +0100705 u16 col16;
Andre Renaud317461c2013-02-13 17:48:00 +0000706 fb16 = (ushort *)fb;
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000707 for (i = 0; i < BMP_LOGO_HEIGHT; ++i) {
708 for (j = 0; j < BMP_LOGO_WIDTH; j++) {
Alessandro Rubiniacb13862010-03-13 17:44:08 +0100709 col16 = bmp_logo_palette[(bmap[j]-16)];
710 fb16[j] =
711 ((col16 & 0x000F) << 1) |
712 ((col16 & 0x00F0) << 3) |
713 ((col16 & 0x0F00) << 4);
wdenk8655b6f2004-10-09 23:25:58 +0000714 }
715 bmap += BMP_LOGO_WIDTH;
716 fb16 += panel_info.vl_col;
717 }
718 }
719
720 WATCHDOG_RESET();
Simon Glass9a8efc42012-10-30 13:40:18 +0000721 lcd_sync();
wdenk8655b6f2004-10-09 23:25:58 +0000722}
Anatolij Gustschin2b5cb3d2012-04-27 04:41:27 +0000723#else
724static inline void bitmap_plot(int x, int y) {}
wdenk8655b6f2004-10-09 23:25:58 +0000725#endif /* CONFIG_LCD_LOGO */
726
727/*----------------------------------------------------------------------*/
Jon Loeligerc3517f92007-07-08 18:10:08 -0500728#if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN)
wdenk8655b6f2004-10-09 23:25:58 +0000729/*
730 * Display the BMP file located at address bmp_image.
731 * Only uncompressed.
732 */
Matthias Weisser1ca298c2009-07-09 16:07:30 +0200733
734#ifdef CONFIG_SPLASH_SCREEN_ALIGN
735#define BMP_ALIGN_CENTER 0x7FFF
Nikita Kiryanov7c7e2802012-08-09 00:14:51 +0000736
737static void splash_align_axis(int *axis, unsigned long panel_size,
738 unsigned long picture_size)
739{
740 unsigned long panel_picture_delta = panel_size - picture_size;
741 unsigned long axis_alignment;
742
743 if (*axis == BMP_ALIGN_CENTER)
744 axis_alignment = panel_picture_delta / 2;
745 else if (*axis < 0)
746 axis_alignment = panel_picture_delta + *axis + 1;
747 else
748 return;
749
750 *axis = max(0, axis_alignment);
751}
Matthias Weisser1ca298c2009-07-09 16:07:30 +0200752#endif
753
Tom Wai-Hong Tam45d7f522012-09-28 15:11:16 +0000754
755#ifdef CONFIG_LCD_BMP_RLE8
756
757#define BMP_RLE8_ESCAPE 0
758#define BMP_RLE8_EOL 0
759#define BMP_RLE8_EOBMP 1
760#define BMP_RLE8_DELTA 2
761
762static void draw_unencoded_bitmap(ushort **fbp, uchar *bmap, ushort *cmap,
763 int cnt)
764{
765 while (cnt > 0) {
766 *(*fbp)++ = cmap[*bmap++];
767 cnt--;
768 }
769}
770
771static void draw_encoded_bitmap(ushort **fbp, ushort c, int cnt)
772{
773 ushort *fb = *fbp;
774 int cnt_8copy = cnt >> 3;
775
776 cnt -= cnt_8copy << 3;
777 while (cnt_8copy > 0) {
778 *fb++ = c;
779 *fb++ = c;
780 *fb++ = c;
781 *fb++ = c;
782 *fb++ = c;
783 *fb++ = c;
784 *fb++ = c;
785 *fb++ = c;
786 cnt_8copy--;
787 }
788 while (cnt > 0) {
789 *fb++ = c;
790 cnt--;
791 }
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000792 *fbp = fb;
Tom Wai-Hong Tam45d7f522012-09-28 15:11:16 +0000793}
794
795/*
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000796 * Do not call this function directly, must be called from lcd_display_bitmap.
Tom Wai-Hong Tam45d7f522012-09-28 15:11:16 +0000797 */
798static void lcd_display_rle8_bitmap(bmp_image_t *bmp, ushort *cmap, uchar *fb,
799 int x_off, int y_off)
800{
801 uchar *bmap;
802 ulong width, height;
803 ulong cnt, runlen;
804 int x, y;
805 int decode = 1;
806
Przemyslaw Marczakdca2a1c2014-01-22 11:24:13 +0100807 width = get_unaligned_le32(&bmp->header.width);
808 height = get_unaligned_le32(&bmp->header.height);
809 bmap = (uchar *)bmp + get_unaligned_le32(&bmp->header.data_offset);
Tom Wai-Hong Tam45d7f522012-09-28 15:11:16 +0000810
811 x = 0;
812 y = height - 1;
813
814 while (decode) {
815 if (bmap[0] == BMP_RLE8_ESCAPE) {
816 switch (bmap[1]) {
817 case BMP_RLE8_EOL:
818 /* end of line */
819 bmap += 2;
820 x = 0;
821 y--;
822 /* 16bpix, 2-byte per pixel, width should *2 */
823 fb -= (width * 2 + lcd_line_length);
824 break;
825 case BMP_RLE8_EOBMP:
826 /* end of bitmap */
827 decode = 0;
828 break;
829 case BMP_RLE8_DELTA:
830 /* delta run */
831 x += bmap[2];
832 y -= bmap[3];
833 /* 16bpix, 2-byte per pixel, x should *2 */
834 fb = (uchar *) (lcd_base + (y + y_off - 1)
835 * lcd_line_length + (x + x_off) * 2);
836 bmap += 4;
837 break;
838 default:
839 /* unencoded run */
840 runlen = bmap[1];
841 bmap += 2;
842 if (y < height) {
843 if (x < width) {
844 if (x + runlen > width)
845 cnt = width - x;
846 else
847 cnt = runlen;
848 draw_unencoded_bitmap(
849 (ushort **)&fb,
850 bmap, cmap, cnt);
851 }
852 x += runlen;
853 }
854 bmap += runlen;
855 if (runlen & 1)
856 bmap++;
857 }
858 } else {
859 /* encoded run */
860 if (y < height) {
861 runlen = bmap[0];
862 if (x < width) {
863 /* aggregate the same code */
864 while (bmap[0] == 0xff &&
865 bmap[2] != BMP_RLE8_ESCAPE &&
866 bmap[1] == bmap[3]) {
867 runlen += bmap[2];
868 bmap += 2;
869 }
870 if (x + runlen > width)
871 cnt = width - x;
872 else
873 cnt = runlen;
874 draw_encoded_bitmap((ushort **)&fb,
875 cmap[bmap[1]], cnt);
876 }
877 x += runlen;
878 }
879 bmap += 2;
880 }
881 }
882}
883#endif
884
Anatolij Gustschind23019f2012-09-22 06:55:53 +0000885#if defined(CONFIG_MPC823) || defined(CONFIG_MCC200)
Nikita Kiryanovbfdcc652012-08-09 00:14:53 +0000886#define FB_PUT_BYTE(fb, from) *(fb)++ = (255 - *(from)++)
Anatolij Gustschind23019f2012-09-22 06:55:53 +0000887#else
888#define FB_PUT_BYTE(fb, from) *(fb)++ = *(from)++
Nikita Kiryanovbfdcc652012-08-09 00:14:53 +0000889#endif
890
891#if defined(CONFIG_BMP_16BPP)
892#if defined(CONFIG_ATMEL_LCD_BGR555)
893static inline void fb_put_word(uchar **fb, uchar **from)
894{
895 *(*fb)++ = (((*from)[0] & 0x1f) << 2) | ((*from)[1] & 0x03);
896 *(*fb)++ = ((*from)[0] & 0xe0) | (((*from)[1] & 0x7c) >> 2);
897 *from += 2;
898}
899#else
900static inline void fb_put_word(uchar **fb, uchar **from)
901{
902 *(*fb)++ = *(*from)++;
903 *(*fb)++ = *(*from)++;
904}
905#endif
906#endif /* CONFIG_BMP_16BPP */
907
wdenk8655b6f2004-10-09 23:25:58 +0000908int lcd_display_bitmap(ulong bmp_image, int x, int y)
909{
Anatolij Gustschin00cc5592009-02-25 20:28:13 +0100910#if !defined(CONFIG_MCC200)
911 ushort *cmap = NULL;
912#endif
913 ushort *cmap_base = NULL;
wdenk8655b6f2004-10-09 23:25:58 +0000914 ushort i, j;
915 uchar *fb;
Simon Glass7d95f2a2014-02-27 13:26:19 -0700916 bmp_image_t *bmp = (bmp_image_t *)map_sysmem(bmp_image, 0);
wdenk8655b6f2004-10-09 23:25:58 +0000917 uchar *bmap;
Tom Wai-Hong Tamfecac462012-09-28 15:11:14 +0000918 ushort padded_width;
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100919 unsigned long width, height, byte_width;
Wolfgang Denke8143e72006-08-30 23:09:00 +0200920 unsigned long pwidth = panel_info.vl_col;
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100921 unsigned colors, bpix, bmp_bpix;
wdenk8655b6f2004-10-09 23:25:58 +0000922
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000923 if (!bmp || !(bmp->header.signature[0] == 'B' &&
924 bmp->header.signature[1] == 'M')) {
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000925 printf("Error: no valid bmp image at %lx\n", bmp_image);
926
wdenk8655b6f2004-10-09 23:25:58 +0000927 return 1;
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100928 }
wdenk8655b6f2004-10-09 23:25:58 +0000929
Przemyslaw Marczakdca2a1c2014-01-22 11:24:13 +0100930 width = get_unaligned_le32(&bmp->header.width);
931 height = get_unaligned_le32(&bmp->header.height);
932 bmp_bpix = get_unaligned_le16(&bmp->header.bit_count);
933
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100934 colors = 1 << bmp_bpix;
wdenk8655b6f2004-10-09 23:25:58 +0000935
936 bpix = NBITS(panel_info.vl_bpix);
937
Jeroen Hofstee6b035142013-01-12 12:07:56 +0000938 if (bpix != 1 && bpix != 8 && bpix != 16 && bpix != 32) {
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100939 printf ("Error: %d bit/pixel mode, but BMP has %d bit/pixel\n",
940 bpix, bmp_bpix);
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000941
wdenk8655b6f2004-10-09 23:25:58 +0000942 return 1;
943 }
944
Hannes Petermaiera305fb12014-07-15 16:28:46 +0200945 /*
946 * We support displaying 8bpp BMPs on 16bpp LCDs
947 * and displaying 24bpp BMPs on 32bpp LCDs
948 * */
949 if (bpix != bmp_bpix &&
950 !(bmp_bpix == 8 && bpix == 16) &&
951 !(bmp_bpix == 24 && bpix == 32)) {
wdenk8655b6f2004-10-09 23:25:58 +0000952 printf ("Error: %d bit/pixel mode, but BMP has %d bit/pixel\n",
Przemyslaw Marczakdca2a1c2014-01-22 11:24:13 +0100953 bpix, get_unaligned_le16(&bmp->header.bit_count));
wdenk8655b6f2004-10-09 23:25:58 +0000954 return 1;
955 }
956
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000957 debug("Display-bmp: %d x %d with %d colors\n",
wdenk8655b6f2004-10-09 23:25:58 +0000958 (int)width, (int)height, (int)colors);
959
Wolfgang Denkf6414712006-10-20 15:51:21 +0200960#if !defined(CONFIG_MCC200)
961 /* MCC200 LCD doesn't need CMAP, supports 1bpp b&w only */
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100962 if (bmp_bpix == 8) {
Nikita Kiryanov203c37b2012-08-09 00:14:52 +0000963 cmap = configuration_get_cmap();
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100964 cmap_base = cmap;
965
wdenk8655b6f2004-10-09 23:25:58 +0000966 /* Set color map */
Nikita Kiryanov8f47d912012-05-24 01:42:38 +0000967 for (i = 0; i < colors; ++i) {
wdenk8655b6f2004-10-09 23:25:58 +0000968 bmp_color_table_entry_t cte = bmp->color_table[i];
Mark Jackson1464eff2008-08-01 09:48:29 +0100969#if !defined(CONFIG_ATMEL_LCD)
wdenk8655b6f2004-10-09 23:25:58 +0000970 ushort colreg =
971 ( ((cte.red) << 8) & 0xf800) |
Wolfgang Denk59d80bf2005-09-21 15:24:52 +0200972 ( ((cte.green) << 3) & 0x07e0) |
973 ( ((cte.blue) >> 3) & 0x001f) ;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200974#ifdef CONFIG_SYS_INVERT_COLORS
wdenk25d67122004-12-10 11:40:40 +0000975 *cmap = 0xffff - colreg;
wdenk8655b6f2004-10-09 23:25:58 +0000976#else
wdenk25d67122004-12-10 11:40:40 +0000977 *cmap = colreg;
978#endif
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100979#if defined(CONFIG_MPC823)
wdenk25d67122004-12-10 11:40:40 +0000980 cmap--;
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +0100981#else
982 cmap++;
wdenk8655b6f2004-10-09 23:25:58 +0000983#endif
Mark Jackson1464eff2008-08-01 09:48:29 +0100984#else /* CONFIG_ATMEL_LCD */
985 lcd_setcolreg(i, cte.red, cte.green, cte.blue);
986#endif
wdenk8655b6f2004-10-09 23:25:58 +0000987 }
988 }
Wolfgang Denkf6414712006-10-20 15:51:21 +0200989#endif
Wolfgang Denke8143e72006-08-30 23:09:00 +0200990 /*
991 * BMP format for Monochrome assumes that the state of a
992 * pixel is described on a per Bit basis, not per Byte.
993 * So, in case of Monochrome BMP we should align widths
994 * on a byte boundary and convert them from Bit to Byte
995 * units.
Wolfgang Denk511d0c72006-10-09 00:42:01 +0200996 * Probably, PXA250 and MPC823 process 1bpp BMP images in
997 * their own ways, so make the converting to be MCC200
Wolfgang Denke8143e72006-08-30 23:09:00 +0200998 * specific.
999 */
1000#if defined(CONFIG_MCC200)
Nikita Kiryanov8f47d912012-05-24 01:42:38 +00001001 if (bpix == 1) {
Wolfgang Denke8143e72006-08-30 23:09:00 +02001002 width = ((width + 7) & ~7) >> 3;
1003 x = ((x + 7) & ~7) >> 3;
1004 pwidth= ((pwidth + 7) & ~7) >> 3;
1005 }
1006#endif
1007
Jeroen Hofstee6b035142013-01-12 12:07:56 +00001008 padded_width = (width & 0x3 ? (width & ~0x3) + 4 : width);
Matthias Weisser1ca298c2009-07-09 16:07:30 +02001009
1010#ifdef CONFIG_SPLASH_SCREEN_ALIGN
Nikita Kiryanov7c7e2802012-08-09 00:14:51 +00001011 splash_align_axis(&x, pwidth, width);
1012 splash_align_axis(&y, panel_info.vl_row, height);
Matthias Weisser1ca298c2009-07-09 16:07:30 +02001013#endif /* CONFIG_SPLASH_SCREEN_ALIGN */
1014
Nikita Kiryanov8f47d912012-05-24 01:42:38 +00001015 if ((x + width) > pwidth)
Wolfgang Denke8143e72006-08-30 23:09:00 +02001016 width = pwidth - x;
Nikita Kiryanov8f47d912012-05-24 01:42:38 +00001017 if ((y + height) > panel_info.vl_row)
wdenk8655b6f2004-10-09 23:25:58 +00001018 height = panel_info.vl_row - y;
1019
Przemyslaw Marczakdca2a1c2014-01-22 11:24:13 +01001020 bmap = (uchar *)bmp + get_unaligned_le32(&bmp->header.data_offset);
1021 fb = (uchar *)(lcd_base +
Liu Ying8d46d5b2011-01-11 15:29:58 +08001022 (y + height - 1) * lcd_line_length + x * bpix / 8);
Mark Jacksona303dfb2009-02-06 10:37:49 +01001023
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +01001024 switch (bmp_bpix) {
Mark Jacksona303dfb2009-02-06 10:37:49 +01001025 case 1: /* pass through */
1026 case 8:
Tom Wai-Hong Tam45d7f522012-09-28 15:11:16 +00001027#ifdef CONFIG_LCD_BMP_RLE8
Przemyslaw Marczakdca2a1c2014-01-22 11:24:13 +01001028 u32 compression = get_unaligned_le32(&bmp->header.compression);
1029 if (compression == BMP_BI_RLE8) {
Tom Wai-Hong Tam45d7f522012-09-28 15:11:16 +00001030 if (bpix != 16) {
1031 /* TODO implement render code for bpix != 16 */
1032 printf("Error: only support 16 bpix");
1033 return 1;
1034 }
1035 lcd_display_rle8_bitmap(bmp, cmap_base, fb, x, y);
1036 break;
1037 }
1038#endif
1039
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +01001040 if (bpix != 16)
1041 byte_width = width;
1042 else
1043 byte_width = width * 2;
1044
Mark Jacksona303dfb2009-02-06 10:37:49 +01001045 for (i = 0; i < height; ++i) {
1046 WATCHDOG_RESET();
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +01001047 for (j = 0; j < width; j++) {
1048 if (bpix != 16) {
Nikita Kiryanovbfdcc652012-08-09 00:14:53 +00001049 FB_PUT_BYTE(fb, bmap);
Guennadi Liakhovetskib245e652009-02-06 10:37:53 +01001050 } else {
1051 *(uint16_t *)fb = cmap_base[*(bmap++)];
1052 fb += sizeof(uint16_t) / sizeof(*fb);
1053 }
1054 }
Tom Wai-Hong Tamfecac462012-09-28 15:11:14 +00001055 bmap += (padded_width - width);
Jeroen Hofstee6b035142013-01-12 12:07:56 +00001056 fb -= byte_width + lcd_line_length;
Mark Jacksona303dfb2009-02-06 10:37:49 +01001057 }
1058 break;
1059
1060#if defined(CONFIG_BMP_16BPP)
1061 case 16:
1062 for (i = 0; i < height; ++i) {
1063 WATCHDOG_RESET();
Nikita Kiryanovbfdcc652012-08-09 00:14:53 +00001064 for (j = 0; j < width; j++)
1065 fb_put_word(&fb, &bmap);
1066
Tom Wai-Hong Tamfecac462012-09-28 15:11:14 +00001067 bmap += (padded_width - width) * 2;
Jeroen Hofstee6b035142013-01-12 12:07:56 +00001068 fb -= width * 2 + lcd_line_length;
Mark Jacksona303dfb2009-02-06 10:37:49 +01001069 }
1070 break;
1071#endif /* CONFIG_BMP_16BPP */
Hannes Petermaiera305fb12014-07-15 16:28:46 +02001072#if defined(CONFIG_BMP_24BMP)
1073 case 24:
1074 for (i = 0; i < height; ++i) {
1075 for (j = 0; j < width; j++) {
1076 *(fb++) = *(bmap++);
1077 *(fb++) = *(bmap++);
1078 *(fb++) = *(bmap++);
1079 *(fb++) = 0;
1080 }
1081 fb -= lcd_line_length + width * (bpix / 8);
1082 }
1083 break;
1084#endif /* CONFIG_BMP_24BMP */
Donghwa Leefb6a9aa2012-05-09 19:23:37 +00001085#if defined(CONFIG_BMP_32BPP)
1086 case 32:
1087 for (i = 0; i < height; ++i) {
1088 for (j = 0; j < width; j++) {
1089 *(fb++) = *(bmap++);
1090 *(fb++) = *(bmap++);
1091 *(fb++) = *(bmap++);
1092 *(fb++) = *(bmap++);
1093 }
Jeroen Hofstee6b035142013-01-12 12:07:56 +00001094 fb -= lcd_line_length + width * (bpix / 8);
Donghwa Leefb6a9aa2012-05-09 19:23:37 +00001095 }
1096 break;
1097#endif /* CONFIG_BMP_32BPP */
Mark Jacksona303dfb2009-02-06 10:37:49 +01001098 default:
1099 break;
1100 };
wdenk8655b6f2004-10-09 23:25:58 +00001101
Simon Glass9a8efc42012-10-30 13:40:18 +00001102 lcd_sync();
Nikita Kiryanov8f47d912012-05-24 01:42:38 +00001103 return 0;
wdenk8655b6f2004-10-09 23:25:58 +00001104}
Jon Loeligerc3517f92007-07-08 18:10:08 -05001105#endif
wdenk8655b6f2004-10-09 23:25:58 +00001106
Nikita Kiryanov8f47d912012-05-24 01:42:38 +00001107static void *lcd_logo(void)
wdenk8655b6f2004-10-09 23:25:58 +00001108{
wdenk8655b6f2004-10-09 23:25:58 +00001109#ifdef CONFIG_SPLASH_SCREEN
1110 char *s;
1111 ulong addr;
1112 static int do_splash = 1;
1113
1114 if (do_splash && (s = getenv("splashimage")) != NULL) {
Matthias Weisser1ca298c2009-07-09 16:07:30 +02001115 int x = 0, y = 0;
wdenk8655b6f2004-10-09 23:25:58 +00001116 do_splash = 0;
1117
Nikita Kiryanov581bb412013-01-30 21:39:57 +00001118 if (splash_screen_prepare())
Robert Winklerdd4425e2013-06-17 11:31:29 -07001119 return (void *)lcd_base;
Nikita Kiryanov581bb412013-01-30 21:39:57 +00001120
Matthias Weisser1ca298c2009-07-09 16:07:30 +02001121 addr = simple_strtoul (s, NULL, 16);
Matthias Weisser1ca298c2009-07-09 16:07:30 +02001122
Anatolij Gustschinff8fb562013-07-02 00:04:05 +02001123 splash_get_pos(&x, &y);
Matthias Weisser1ca298c2009-07-09 16:07:30 +02001124
Nikita Kiryanovd3a555e2012-08-09 00:14:50 +00001125 if (bmp_display(addr, x, y) == 0)
Nikita Kiryanov8f47d912012-05-24 01:42:38 +00001126 return (void *)lcd_base;
wdenk8655b6f2004-10-09 23:25:58 +00001127 }
1128#endif /* CONFIG_SPLASH_SCREEN */
1129
Anatolij Gustschin2b5cb3d2012-04-27 04:41:27 +00001130 bitmap_plot(0, 0);
wdenk8655b6f2004-10-09 23:25:58 +00001131
Haavard Skinnemoen6b59e032008-09-01 16:21:22 +02001132#ifdef CONFIG_LCD_INFO
1133 console_col = LCD_INFO_X / VIDEO_FONT_WIDTH;
1134 console_row = LCD_INFO_Y / VIDEO_FONT_HEIGHT;
1135 lcd_show_board_info();
1136#endif /* CONFIG_LCD_INFO */
Stelian Pop39cf4802008-05-09 21:57:18 +02001137
wdenk88804d12005-07-04 00:03:16 +00001138#if defined(CONFIG_LCD_LOGO) && !defined(CONFIG_LCD_INFO_BELOW_LOGO)
Nikita Kiryanov8f47d912012-05-24 01:42:38 +00001139 return (void *)((ulong)lcd_base + BMP_LOGO_HEIGHT * lcd_line_length);
wdenk8655b6f2004-10-09 23:25:58 +00001140#else
Nikita Kiryanov8f47d912012-05-24 01:42:38 +00001141 return (void *)lcd_base;
Jeroen Hofstee6b035142013-01-12 12:07:56 +00001142#endif /* CONFIG_LCD_LOGO && !defined(CONFIG_LCD_INFO_BELOW_LOGO) */
wdenk8655b6f2004-10-09 23:25:58 +00001143}
1144
Nikita Kiryanovc0880482013-02-24 21:28:43 +00001145#ifdef CONFIG_SPLASHIMAGE_GUARD
1146static int on_splashimage(const char *name, const char *value, enum env_op op,
1147 int flags)
1148{
1149 ulong addr;
1150 int aligned;
1151
1152 if (op == env_op_delete)
1153 return 0;
1154
1155 addr = simple_strtoul(value, NULL, 16);
1156 /* See README.displaying-bmps */
1157 aligned = (addr % 4 == 2);
1158 if (!aligned) {
1159 printf("Invalid splashimage value. Value must be 16 bit aligned, but not 32 bit aligned\n");
1160 return -1;
1161 }
1162
1163 return 0;
1164}
1165
1166U_BOOT_ENV_CALLBACK(splashimage, on_splashimage);
1167#endif
1168
Vadim Bendebury395166c2012-09-28 15:11:13 +00001169void lcd_position_cursor(unsigned col, unsigned row)
1170{
1171 console_col = min(col, CONSOLE_COLS - 1);
1172 console_row = min(row, CONSOLE_ROWS - 1);
1173}
1174
1175int lcd_get_pixel_width(void)
1176{
1177 return panel_info.vl_col;
1178}
1179
1180int lcd_get_pixel_height(void)
1181{
1182 return panel_info.vl_row;
1183}
1184
1185int lcd_get_screen_rows(void)
1186{
1187 return CONSOLE_ROWS;
1188}
1189
1190int lcd_get_screen_columns(void)
1191{
1192 return CONSOLE_COLS;
1193}
Stephen Warren6a195d22013-05-27 18:31:17 +00001194
1195#if defined(CONFIG_LCD_DT_SIMPLEFB)
1196static int lcd_dt_simplefb_configure_node(void *blob, int off)
1197{
1198 u32 stride;
1199 fdt32_t cells[2];
1200 int ret;
Stephen Warren5af7d0f2013-06-13 17:13:11 -06001201 static const char format[] =
Stephen Warren6a195d22013-05-27 18:31:17 +00001202#if LCD_BPP == LCD_COLOR16
1203 "r5g6b5";
1204#else
1205 "";
1206#endif
1207
1208 if (!format[0])
1209 return -1;
1210
1211 stride = panel_info.vl_col * 2;
1212
1213 cells[0] = cpu_to_fdt32(gd->fb_base);
1214 cells[1] = cpu_to_fdt32(stride * panel_info.vl_row);
1215 ret = fdt_setprop(blob, off, "reg", cells, sizeof(cells[0]) * 2);
1216 if (ret < 0)
1217 return -1;
1218
1219 cells[0] = cpu_to_fdt32(panel_info.vl_col);
1220 ret = fdt_setprop(blob, off, "width", cells, sizeof(cells[0]));
1221 if (ret < 0)
1222 return -1;
1223
1224 cells[0] = cpu_to_fdt32(panel_info.vl_row);
1225 ret = fdt_setprop(blob, off, "height", cells, sizeof(cells[0]));
1226 if (ret < 0)
1227 return -1;
1228
1229 cells[0] = cpu_to_fdt32(stride);
1230 ret = fdt_setprop(blob, off, "stride", cells, sizeof(cells[0]));
1231 if (ret < 0)
1232 return -1;
1233
1234 ret = fdt_setprop(blob, off, "format", format, strlen(format) + 1);
1235 if (ret < 0)
1236 return -1;
1237
1238 ret = fdt_delprop(blob, off, "status");
1239 if (ret < 0)
1240 return -1;
1241
1242 return 0;
1243}
1244
1245int lcd_dt_simplefb_add_node(void *blob)
1246{
Stephen Warren5af7d0f2013-06-13 17:13:11 -06001247 static const char compat[] = "simple-framebuffer";
1248 static const char disabled[] = "disabled";
Stephen Warren6a195d22013-05-27 18:31:17 +00001249 int off, ret;
1250
1251 off = fdt_add_subnode(blob, 0, "framebuffer");
1252 if (off < 0)
1253 return -1;
1254
1255 ret = fdt_setprop(blob, off, "status", disabled, sizeof(disabled));
1256 if (ret < 0)
1257 return -1;
1258
1259 ret = fdt_setprop(blob, off, "compatible", compat, sizeof(compat));
1260 if (ret < 0)
1261 return -1;
1262
1263 return lcd_dt_simplefb_configure_node(blob, off);
1264}
1265
1266int lcd_dt_simplefb_enable_existing_node(void *blob)
1267{
1268 int off;
1269
1270 off = fdt_node_offset_by_compatible(blob, -1, "simple-framebuffer");
1271 if (off < 0)
1272 return -1;
1273
1274 return lcd_dt_simplefb_configure_node(blob, off);
1275}
1276#endif