Blame view
common/lcd.c
28.9 KB
8655b6f86
|
1 2 3 4 5 6 |
/* * Common LCD routines for supported CPUs * * (C) Copyright 2001-2002 * Wolfgang Denk, DENX Software Engineering -- wd@denx.de * |
3765b3e7b
|
7 |
* SPDX-License-Identifier: GPL-2.0+ |
8655b6f86
|
8 9 10 11 12 13 14 15 16 17 18 |
*/ /************************************************************************/ /* ** HEADER FILES */ /************************************************************************/ /* #define DEBUG */ #include <config.h> #include <common.h> #include <command.h> |
8655b6f86
|
19 |
#include <stdarg.h> |
c08804853
|
20 21 |
#include <search.h> #include <env_callback.h> |
8655b6f86
|
22 |
#include <linux/types.h> |
52cb4d4fb
|
23 |
#include <stdio_dev.h> |
8655b6f86
|
24 25 26 27 |
#if defined(CONFIG_POST) #include <post.h> #endif #include <lcd.h> |
8b0bfc680
|
28 |
#include <watchdog.h> |
dca2a1c18
|
29 |
#include <asm/unaligned.h> |
dd4425e85
|
30 |
#include <splash.h> |
abc20aba1
|
31 32 33 |
#if defined(CONFIG_CPU_PXA25X) || defined(CONFIG_CPU_PXA27X) || \ defined(CONFIG_CPU_MONAHANS) #define CONFIG_CPU_PXA |
8655b6f86
|
34 35 36 37 |
#include <asm/byteorder.h> #endif #if defined(CONFIG_MPC823) |
8655b6f86
|
38 39 |
#include <lcdvideo.h> #endif |
39cf48048
|
40 41 |
#if defined(CONFIG_ATMEL_LCD) #include <atmel_lcdc.h> |
39cf48048
|
42 |
#endif |
6a195d2d8
|
43 44 45 |
#if defined(CONFIG_LCD_DT_SIMPLEFB) #include <libfdt.h> #endif |
8655b6f86
|
46 47 48 49 |
/************************************************************************/ /* ** FONT DATA */ /************************************************************************/ #include <video_font.h> /* Get font data, width and height */ |
88804d19e
|
50 51 52 53 54 |
/************************************************************************/ /* ** LOGO DATA */ /************************************************************************/ #ifdef CONFIG_LCD_LOGO # include <bmp_logo.h> /* Get logo data, width and height */ |
c270730f5
|
55 |
# include <bmp_logo_data.h> |
acb138689
|
56 |
# if (CONSOLE_COLOR_WHITE >= BMP_LOGO_OFFSET) && (LCD_BPP != LCD_COLOR16) |
88804d19e
|
57 58 59 |
# error Default Color Map overlaps with Logo Color Map # endif #endif |
8655b6f86
|
60 |
|
676d319ef
|
61 62 63 |
#ifndef CONFIG_LCD_ALIGNMENT #define CONFIG_LCD_ALIGNMENT PAGE_SIZE #endif |
0d89efef7
|
64 65 66 67 |
/* By default we scroll by a single line */ #ifndef CONFIG_CONSOLE_SCROLL_LINES #define CONFIG_CONSOLE_SCROLL_LINES 1 #endif |
a5796c51c
|
68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 |
/************************************************************************/ /* ** CONSOLE DEFINITIONS & FUNCTIONS */ /************************************************************************/ #if defined(CONFIG_LCD_LOGO) && !defined(CONFIG_LCD_INFO_BELOW_LOGO) # define CONSOLE_ROWS ((panel_info.vl_row-BMP_LOGO_HEIGHT) \ / VIDEO_FONT_HEIGHT) #else # define CONSOLE_ROWS (panel_info.vl_row / VIDEO_FONT_HEIGHT) #endif #define CONSOLE_COLS (panel_info.vl_col / VIDEO_FONT_WIDTH) #define CONSOLE_ROW_SIZE (VIDEO_FONT_HEIGHT * lcd_line_length) #define CONSOLE_ROW_FIRST lcd_console_address #define CONSOLE_ROW_SECOND (lcd_console_address + CONSOLE_ROW_SIZE) #define CONSOLE_ROW_LAST (lcd_console_address + CONSOLE_SIZE \ - CONSOLE_ROW_SIZE) #define CONSOLE_SIZE (CONSOLE_ROW_SIZE * CONSOLE_ROWS) #define CONSOLE_SCROLL_SIZE (CONSOLE_SIZE - CONSOLE_ROW_SIZE) |
d87080b72
|
86 |
|
a5796c51c
|
87 88 89 90 91 92 93 94 |
#if LCD_BPP == LCD_MONOCHROME # define COLOR_MASK(c) ((c) | (c) << 1 | (c) << 2 | (c) << 3 | \ (c) << 4 | (c) << 5 | (c) << 6 | (c) << 7) #elif (LCD_BPP == LCD_COLOR8) || (LCD_BPP == LCD_COLOR16) # define COLOR_MASK(c) (c) #else # error Unsupported LCD BPP. #endif |
d87080b72
|
95 |
DECLARE_GLOBAL_DATA_PTR; |
8655b6f86
|
96 |
|
8f47d917c
|
97 98 99 |
static void lcd_drawchars(ushort x, ushort y, uchar *str, int count); static inline void lcd_puts_xy(ushort x, ushort y, uchar *s); static inline void lcd_putc_xy(ushort x, ushort y, uchar c); |
8655b6f86
|
100 |
|
8f47d917c
|
101 |
static int lcd_init(void *lcdbase); |
8655b6f86
|
102 |
|
6b035141f
|
103 |
static void *lcd_logo(void); |
8655b6f86
|
104 |
|
8f47d917c
|
105 106 107 |
static int lcd_getbgcolor(void); static void lcd_setfgcolor(int color); static void lcd_setbgcolor(int color); |
8655b6f86
|
108 |
|
46d1d5dd4
|
109 110 |
static int lcd_color_fg; static int lcd_color_bg; |
f1d205a19
|
111 |
int lcd_line_length; |
46d1d5dd4
|
112 |
|
8655b6f86
|
113 |
char lcd_is_enabled = 0; |
8655b6f86
|
114 |
|
f1d205a19
|
115 116 |
static short console_col; static short console_row; |
9a8efc460
|
117 |
|
f1d205a19
|
118 |
static void *lcd_console_address; |
00a0ca598
|
119 |
static void *lcd_base; /* Start of framebuffer memory */ |
9a8efc460
|
120 |
|
9a8efc460
|
121 |
static char lcd_flush_dcache; /* 1 to flush dcache after each lcd update */ |
8655b6f86
|
122 123 |
/************************************************************************/ |
9a8efc460
|
124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 |
/* Flush LCD activity to the caches */ void lcd_sync(void) { /* * flush_dcache_range() is declared in common.h but it seems that some * architectures do not actually implement it. Is there a way to find * out whether it exists? For now, ARM is safe. */ #if defined(CONFIG_ARM) && !defined(CONFIG_SYS_DCACHE_OFF) int line_length; if (lcd_flush_dcache) flush_dcache_range((u32)lcd_base, (u32)(lcd_base + lcd_get_size(&line_length))); #endif } void lcd_set_flush_dcache(int flush) { lcd_flush_dcache = (flush != 0); } |
8655b6f86
|
145 |
/*----------------------------------------------------------------------*/ |
8f47d917c
|
146 |
static void console_scrollup(void) |
8655b6f86
|
147 |
{ |
0d89efef7
|
148 149 150 151 152 153 154 155 156 157 |
const int rows = CONFIG_CONSOLE_SCROLL_LINES; /* Copy up rows ignoring those that will be overwritten */ memcpy(CONSOLE_ROW_FIRST, lcd_console_address + CONSOLE_ROW_SIZE * rows, CONSOLE_SIZE - CONSOLE_ROW_SIZE * rows); /* Clear the last rows */ memset(lcd_console_address + CONSOLE_SIZE - CONSOLE_ROW_SIZE * rows, COLOR_MASK(lcd_color_bg), |
6b035141f
|
158 |
CONSOLE_ROW_SIZE * rows); |
8655b6f86
|
159 |
|
9a8efc460
|
160 |
lcd_sync(); |
0d89efef7
|
161 |
console_row -= rows; |
8655b6f86
|
162 163 164 |
} /*----------------------------------------------------------------------*/ |
8f47d917c
|
165 |
static inline void console_back(void) |
8655b6f86
|
166 167 168 |
{ if (--console_col < 0) { console_col = CONSOLE_COLS-1 ; |
6b035141f
|
169 |
if (--console_row < 0) |
8655b6f86
|
170 |
console_row = 0; |
8655b6f86
|
171 |
} |
8f47d917c
|
172 173 |
lcd_putc_xy(console_col * VIDEO_FONT_WIDTH, console_row * VIDEO_FONT_HEIGHT, ' '); |
8655b6f86
|
174 175 176 |
} /*----------------------------------------------------------------------*/ |
8f47d917c
|
177 |
static inline void console_newline(void) |
8655b6f86
|
178 |
{ |
8655b6f86
|
179 180 181 |
console_col = 0; /* Check if we need to scroll the terminal */ |
6b035141f
|
182 |
if (++console_row >= CONSOLE_ROWS) |
8f47d917c
|
183 |
console_scrollup(); |
6b035141f
|
184 |
else |
9a8efc460
|
185 |
lcd_sync(); |
8655b6f86
|
186 187 188 |
} /*----------------------------------------------------------------------*/ |
8f47d917c
|
189 |
void lcd_putc(const char c) |
8655b6f86
|
190 191 192 |
{ if (!lcd_is_enabled) { serial_putc(c); |
8f47d917c
|
193 |
|
8655b6f86
|
194 195 196 197 |
return; } switch (c) { |
8f47d917c
|
198 199 |
case '\r': console_col = 0; |
8655b6f86
|
200 |
|
8f47d917c
|
201 202 203 204 |
return; case ' ': console_newline(); |
8655b6f86
|
205 |
|
8f47d917c
|
206 |
return; |
8655b6f86
|
207 |
case '\t': /* Tab (8 chars alignment) */ |
8f47d917c
|
208 209 |
console_col += 8; console_col &= ~7; |
8655b6f86
|
210 |
|
8f47d917c
|
211 212 |
if (console_col >= CONSOLE_COLS) console_newline(); |
8655b6f86
|
213 |
|
8f47d917c
|
214 215 216 |
return; case '\b': console_back(); |
8655b6f86
|
217 |
|
8f47d917c
|
218 219 220 221 222 223 |
return; default: lcd_putc_xy(console_col * VIDEO_FONT_WIDTH, console_row * VIDEO_FONT_HEIGHT, c); if (++console_col >= CONSOLE_COLS) console_newline(); |
8655b6f86
|
224 |
} |
8655b6f86
|
225 226 227 |
} /*----------------------------------------------------------------------*/ |
8f47d917c
|
228 |
void lcd_puts(const char *s) |
8655b6f86
|
229 230 |
{ if (!lcd_is_enabled) { |
8f47d917c
|
231 |
serial_puts(s); |
8655b6f86
|
232 233 |
return; } |
6b035141f
|
234 |
while (*s) |
8f47d917c
|
235 |
lcd_putc(*s++); |
6b035141f
|
236 |
|
9a8efc460
|
237 |
lcd_sync(); |
8655b6f86
|
238 |
} |
15b17ab52
|
239 240 241 242 243 244 245 246 247 248 249 250 251 |
/*----------------------------------------------------------------------*/ void lcd_printf(const char *fmt, ...) { va_list args; char buf[CONFIG_SYS_PBSIZE]; va_start(args, fmt); vsprintf(buf, fmt, args); va_end(args); lcd_puts(buf); } |
8655b6f86
|
252 253 254 |
/************************************************************************/ /* ** Low-Level Graphics Routines */ /************************************************************************/ |
8f47d917c
|
255 |
static void lcd_drawchars(ushort x, ushort y, uchar *str, int count) |
8655b6f86
|
256 257 |
{ uchar *dest; |
be547c6db
|
258 |
ushort row; |
0f999c49e
|
259 260 261 |
#if defined(CONFIG_LCD_LOGO) && !defined(CONFIG_LCD_INFO_BELOW_LOGO) y += BMP_LOGO_HEIGHT; #endif |
be547c6db
|
262 263 264 |
#if LCD_BPP == LCD_MONOCHROME ushort off = x * (1 << LCD_BPP) % 8; #endif |
8655b6f86
|
265 266 |
dest = (uchar *)(lcd_base + y * lcd_line_length + x * (1 << LCD_BPP) / 8); |
8655b6f86
|
267 |
|
8f47d917c
|
268 |
for (row = 0; row < VIDEO_FONT_HEIGHT; ++row, dest += lcd_line_length) { |
8655b6f86
|
269 |
uchar *s = str; |
8655b6f86
|
270 |
int i; |
acb138689
|
271 272 273 274 275 |
#if LCD_BPP == LCD_COLOR16 ushort *d = (ushort *)dest; #else uchar *d = dest; #endif |
8655b6f86
|
276 277 |
#if LCD_BPP == LCD_MONOCHROME |
6b035141f
|
278 |
uchar rest = *d & -(1 << (8 - off)); |
8655b6f86
|
279 280 |
uchar sym; #endif |
8f47d917c
|
281 |
for (i = 0; i < count; ++i) { |
8655b6f86
|
282 283 284 285 286 287 288 |
uchar c, bits; c = *s++; bits = video_fontdata[c * VIDEO_FONT_HEIGHT + row]; #if LCD_BPP == LCD_MONOCHROME sym = (COLOR_MASK(lcd_color_fg) & bits) | |
8f47d917c
|
289 |
(COLOR_MASK(lcd_color_bg) & ~bits); |
8655b6f86
|
290 291 292 293 |
*d++ = rest | (sym >> off); rest = sym << (8-off); #elif LCD_BPP == LCD_COLOR8 |
8f47d917c
|
294 |
for (c = 0; c < 8; ++c) { |
8655b6f86
|
295 296 297 298 299 |
*d++ = (bits & 0x80) ? lcd_color_fg : lcd_color_bg; bits <<= 1; } #elif LCD_BPP == LCD_COLOR16 |
8f47d917c
|
300 |
for (c = 0; c < 8; ++c) { |
8655b6f86
|
301 302 303 304 305 306 307 |
*d++ = (bits & 0x80) ? lcd_color_fg : lcd_color_bg; bits <<= 1; } #endif } #if LCD_BPP == LCD_MONOCHROME |
6b035141f
|
308 |
*d = rest | (*d & ((1 << (8 - off)) - 1)); |
8655b6f86
|
309 310 311 312 313 |
#endif } } /*----------------------------------------------------------------------*/ |
8f47d917c
|
314 |
static inline void lcd_puts_xy(ushort x, ushort y, uchar *s) |
8655b6f86
|
315 |
{ |
0f999c49e
|
316 |
lcd_drawchars(x, y, s, strlen((char *)s)); |
8655b6f86
|
317 318 319 |
} /*----------------------------------------------------------------------*/ |
8f47d917c
|
320 |
static inline void lcd_putc_xy(ushort x, ushort y, uchar c) |
8655b6f86
|
321 |
{ |
0f999c49e
|
322 |
lcd_drawchars(x, y, &c, 1); |
8655b6f86
|
323 324 325 326 327 328 329 330 331 |
} /************************************************************************/ /** Small utility to check that you got the colours right */ /************************************************************************/ #ifdef LCD_TEST_PATTERN #define N_BLK_VERT 2 #define N_BLK_HOR 3 |
6b035141f
|
332 |
static int test_colors[N_BLK_HOR * N_BLK_VERT] = { |
8655b6f86
|
333 334 335 |
CONSOLE_COLOR_RED, CONSOLE_COLOR_GREEN, CONSOLE_COLOR_YELLOW, CONSOLE_COLOR_BLUE, CONSOLE_COLOR_MAGENTA, CONSOLE_COLOR_CYAN, }; |
8f47d917c
|
336 |
static void test_pattern(void) |
8655b6f86
|
337 338 339 340 341 342 343 |
{ ushort v_max = panel_info.vl_row; ushort h_max = panel_info.vl_col; ushort v_step = (v_max + N_BLK_VERT - 1) / N_BLK_VERT; ushort h_step = (h_max + N_BLK_HOR - 1) / N_BLK_HOR; ushort v, h; uchar *pix = (uchar *)lcd_base; |
8f47d917c
|
344 345 |
printf("[LCD] Test Pattern: %d x %d [%d x %d] ", |
8655b6f86
|
346 347 348 |
h_max, v_max, h_step, v_step); /* WARNING: Code silently assumes 8bit/pixel */ |
8f47d917c
|
349 |
for (v = 0; v < v_max; ++v) { |
8655b6f86
|
350 |
uchar iy = v / v_step; |
8f47d917c
|
351 |
for (h = 0; h < h_max; ++h) { |
6b035141f
|
352 |
uchar ix = N_BLK_HOR * iy + h / h_step; |
8655b6f86
|
353 354 355 356 357 358 359 360 361 362 |
*pix++ = test_colors[ix]; } } } #endif /* LCD_TEST_PATTERN */ /************************************************************************/ /* ** GENERIC Initialization Routines */ /************************************************************************/ |
cefa47171
|
363 364 365 366 367 368 369 |
/* * With most lcd drivers the line length is set up * by calculating it from panel_info parameters. Some * drivers need to calculate the line length differently, * so make the function weak to allow overriding it. */ __weak int lcd_get_size(int *line_length) |
676d319ef
|
370 371 372 373 |
{ *line_length = (panel_info.vl_col * NBITS(panel_info.vl_bpix)) / 8; return *line_length * panel_info.vl_row; } |
6b035141f
|
374 |
int drv_lcd_init(void) |
8655b6f86
|
375 |
{ |
52cb4d4fb
|
376 |
struct stdio_dev lcddev; |
8655b6f86
|
377 |
int rc; |
6b035141f
|
378 |
lcd_base = (void *) gd->fb_base; |
8655b6f86
|
379 |
|
8f47d917c
|
380 |
lcd_init(lcd_base); /* LCD initialization */ |
8655b6f86
|
381 382 |
/* Device initialization */ |
8f47d917c
|
383 |
memset(&lcddev, 0, sizeof(lcddev)); |
8655b6f86
|
384 |
|
8f47d917c
|
385 |
strcpy(lcddev.name, "lcd"); |
8655b6f86
|
386 387 388 389 |
lcddev.ext = 0; /* No extensions */ lcddev.flags = DEV_FLAGS_OUTPUT; /* Output only */ lcddev.putc = lcd_putc; /* 'putc' function */ lcddev.puts = lcd_puts; /* 'puts' function */ |
6b035141f
|
390 |
rc = stdio_register(&lcddev); |
8655b6f86
|
391 392 393 394 395 |
return (rc == 0) ? 1 : rc; } /*----------------------------------------------------------------------*/ |
02110903a
|
396 |
void lcd_clear(void) |
8655b6f86
|
397 398 399 400 401 402 403 |
{ #if LCD_BPP == LCD_MONOCHROME /* Setting the palette */ lcd_initcolregs(); #elif LCD_BPP == LCD_COLOR8 /* Setting the palette */ |
8f47d917c
|
404 405 406 407 408 409 410 411 412 |
lcd_setcolreg(CONSOLE_COLOR_BLACK, 0, 0, 0); lcd_setcolreg(CONSOLE_COLOR_RED, 0xFF, 0, 0); lcd_setcolreg(CONSOLE_COLOR_GREEN, 0, 0xFF, 0); lcd_setcolreg(CONSOLE_COLOR_YELLOW, 0xFF, 0xFF, 0); lcd_setcolreg(CONSOLE_COLOR_BLUE, 0, 0, 0xFF); lcd_setcolreg(CONSOLE_COLOR_MAGENTA, 0xFF, 0, 0xFF); lcd_setcolreg(CONSOLE_COLOR_CYAN, 0, 0xFF, 0xFF); lcd_setcolreg(CONSOLE_COLOR_GREY, 0xAA, 0xAA, 0xAA); lcd_setcolreg(CONSOLE_COLOR_WHITE, 0xFF, 0xFF, 0xFF); |
8655b6f86
|
413 |
#endif |
6d0f6bcf3
|
414 |
#ifndef CONFIG_SYS_WHITE_ON_BLACK |
8f47d917c
|
415 416 |
lcd_setfgcolor(CONSOLE_COLOR_BLACK); lcd_setbgcolor(CONSOLE_COLOR_WHITE); |
8655b6f86
|
417 |
#else |
8f47d917c
|
418 419 |
lcd_setfgcolor(CONSOLE_COLOR_WHITE); lcd_setbgcolor(CONSOLE_COLOR_BLACK); |
6d0f6bcf3
|
420 |
#endif /* CONFIG_SYS_WHITE_ON_BLACK */ |
8655b6f86
|
421 422 423 424 425 |
#ifdef LCD_TEST_PATTERN test_pattern(); #else /* set framebuffer to background color */ |
8f47d917c
|
426 |
memset((char *)lcd_base, |
8655b6f86
|
427 |
COLOR_MASK(lcd_getbgcolor()), |
6b035141f
|
428 |
lcd_line_length * panel_info.vl_row); |
8655b6f86
|
429 430 |
#endif /* Paint the logo and retrieve LCD base address */ |
8f47d917c
|
431 432 |
debug("[LCD] Drawing the logo... "); |
6b035141f
|
433 |
lcd_console_address = lcd_logo(); |
8655b6f86
|
434 435 436 |
console_col = 0; console_row = 0; |
9a8efc460
|
437 438 439 440 441 442 443 444 |
lcd_sync(); } static int do_lcd_clear(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) { lcd_clear(); return 0; |
8655b6f86
|
445 446 447 |
} U_BOOT_CMD( |
02110903a
|
448 |
cls, 1, 1, do_lcd_clear, |
2fb2604d5
|
449 |
"clear screen", |
a89c33db9
|
450 |
"" |
8655b6f86
|
451 452 453 |
); /*----------------------------------------------------------------------*/ |
8f47d917c
|
454 |
static int lcd_init(void *lcdbase) |
8655b6f86
|
455 456 |
{ /* Initialize the lcd controller */ |
8f47d917c
|
457 458 |
debug("[LCD] Initializing LCD frambuffer at %p ", lcdbase); |
8655b6f86
|
459 |
|
8f47d917c
|
460 |
lcd_ctrl_init(lcdbase); |
1d3dea12e
|
461 462 463 464 465 466 467 468 469 470 471 472 |
/* * lcd_ctrl_init() of some drivers (i.e. bcm2835 on rpi_b) ignores * the 'lcdbase' argument and uses custom lcd base address * by setting up gd->fb_base. Check for this condition and fixup * 'lcd_base' address. */ if ((unsigned long)lcdbase != gd->fb_base) lcd_base = (void *)gd->fb_base; debug("[LCD] Using LCD frambuffer at %p ", lcd_base); |
6d3307195
|
473 |
lcd_get_size(&lcd_line_length); |
6f93d2b8f
|
474 |
lcd_is_enabled = 1; |
02110903a
|
475 |
lcd_clear(); |
6b035141f
|
476 |
lcd_enable(); |
8655b6f86
|
477 478 479 |
/* Initialize the console */ console_col = 0; |
88804d19e
|
480 |
#ifdef CONFIG_LCD_INFO_BELOW_LOGO |
8655b6f86
|
481 482 483 484 |
console_row = 7 + BMP_LOGO_HEIGHT / VIDEO_FONT_HEIGHT; #else console_row = 1; /* leave 1 blank line below logo */ #endif |
8655b6f86
|
485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 |
return 0; } /************************************************************************/ /* ** ROM capable initialization part - needed to reserve FB memory */ /************************************************************************/ /* * This is called early in the system initialization to grab memory * for the LCD controller. * Returns new address for monitor, after reserving LCD buffer memory * * Note that this is running from ROM, so no write access to global data. */ |
8f47d917c
|
500 |
ulong lcd_setmem(ulong addr) |
8655b6f86
|
501 502 |
{ ulong size; |
676d319ef
|
503 |
int line_length; |
8655b6f86
|
504 |
|
8f47d917c
|
505 506 507 |
debug("LCD panel info: %d x %d, %d bit/pix ", panel_info.vl_col, panel_info.vl_row, NBITS(panel_info.vl_bpix)); |
8655b6f86
|
508 |
|
676d319ef
|
509 |
size = lcd_get_size(&line_length); |
8655b6f86
|
510 |
|
676d319ef
|
511 512 513 |
/* Round up to nearest full page, or MMU section if defined */ size = ALIGN(size, CONFIG_LCD_ALIGNMENT); addr = ALIGN(addr - CONFIG_LCD_ALIGNMENT + 1, CONFIG_LCD_ALIGNMENT); |
8655b6f86
|
514 515 516 |
/* Allocate pages for the frame buffer. */ addr -= size; |
6b035141f
|
517 518 519 |
debug("Reserving %ldk for LCD Framebuffer at: %08lx ", size >> 10, addr); |
8655b6f86
|
520 |
|
8f47d917c
|
521 |
return addr; |
8655b6f86
|
522 523 524 |
} /*----------------------------------------------------------------------*/ |
8f47d917c
|
525 |
static void lcd_setfgcolor(int color) |
8655b6f86
|
526 |
{ |
39cf48048
|
527 |
lcd_color_fg = color; |
8655b6f86
|
528 529 530 |
} /*----------------------------------------------------------------------*/ |
8f47d917c
|
531 |
static void lcd_setbgcolor(int color) |
8655b6f86
|
532 |
{ |
39cf48048
|
533 |
lcd_color_bg = color; |
8655b6f86
|
534 535 536 |
} /*----------------------------------------------------------------------*/ |
46d1d5dd4
|
537 |
int lcd_getfgcolor(void) |
8655b6f86
|
538 539 540 |
{ return lcd_color_fg; } |
8655b6f86
|
541 542 |
/*----------------------------------------------------------------------*/ |
8f47d917c
|
543 |
static int lcd_getbgcolor(void) |
8655b6f86
|
544 545 546 |
{ return lcd_color_bg; } |
8655b6f86
|
547 548 549 |
/************************************************************************/ /* ** Chipset depending Bitmap / Logo stuff... */ /************************************************************************/ |
203c37b8c
|
550 551 552 553 554 555 556 557 558 559 560 |
static inline ushort *configuration_get_cmap(void) { #if defined CONFIG_CPU_PXA struct pxafb_info *fbi = &panel_info.pxa; return (ushort *)fbi->palette; #elif defined(CONFIG_MPC823) immap_t *immr = (immap_t *) CONFIG_SYS_IMMR; cpm8xx_t *cp = &(immr->im_cpm); return (ushort *)&(cp->lcd_cmap[255 * sizeof(ushort)]); #elif defined(CONFIG_ATMEL_LCD) return (ushort *)(panel_info.mmio + ATMEL_LCDC_LUT(0)); |
d23019f3d
|
561 562 |
#elif !defined(CONFIG_ATMEL_HLCD) && !defined(CONFIG_EXYNOS_FB) return panel_info.cmap; |
6b035141f
|
563 |
#elif defined(CONFIG_LCD_LOGO) |
d23019f3d
|
564 565 566 567 |
return bmp_logo_palette; #else return NULL; #endif |
203c37b8c
|
568 |
} |
8655b6f86
|
569 |
#ifdef CONFIG_LCD_LOGO |
8f47d917c
|
570 |
void bitmap_plot(int x, int y) |
8655b6f86
|
571 |
{ |
39cf48048
|
572 |
#ifdef CONFIG_ATMEL_LCD |
203c37b8c
|
573 |
uint *cmap = (uint *)bmp_logo_palette; |
39cf48048
|
574 |
#else |
203c37b8c
|
575 |
ushort *cmap = (ushort *)bmp_logo_palette; |
39cf48048
|
576 |
#endif |
8655b6f86
|
577 578 579 580 |
ushort i, j; uchar *bmap; uchar *fb; ushort *fb16; |
203c37b8c
|
581 582 583 |
#if defined(CONFIG_MPC823) immap_t *immr = (immap_t *) CONFIG_SYS_IMMR; cpm8xx_t *cp = &(immr->im_cpm); |
8655b6f86
|
584 |
#endif |
317461c1d
|
585 |
unsigned bpix = NBITS(panel_info.vl_bpix); |
8655b6f86
|
586 |
|
8f47d917c
|
587 588 |
debug("Logo: width %d height %d colors %d cmap %d ", |
8655b6f86
|
589 |
BMP_LOGO_WIDTH, BMP_LOGO_HEIGHT, BMP_LOGO_COLORS, |
095407da5
|
590 |
ARRAY_SIZE(bmp_logo_palette)); |
8655b6f86
|
591 592 |
bmap = &bmp_logo_bitmap[0]; |
317461c1d
|
593 |
fb = (uchar *)(lcd_base + y * lcd_line_length + x * bpix / 8); |
8655b6f86
|
594 |
|
317461c1d
|
595 |
if (bpix < 12) { |
203c37b8c
|
596 597 598 599 600 601 |
/* Leave room for default color map * default case: generic system with no cmap (most likely 16bpp) * cmap was set to the source palette, so no change is done. * This avoids even more ifdefs in the next stanza */ #if defined(CONFIG_MPC823) |
8f47d917c
|
602 |
cmap = (ushort *) &(cp->lcd_cmap[BMP_LOGO_OFFSET * sizeof(ushort)]); |
39cf48048
|
603 |
#elif defined(CONFIG_ATMEL_LCD) |
203c37b8c
|
604 |
cmap = (uint *)configuration_get_cmap(); |
acb138689
|
605 |
#else |
203c37b8c
|
606 |
cmap = configuration_get_cmap(); |
8655b6f86
|
607 608 609 610 611 |
#endif WATCHDOG_RESET(); /* Set color map */ |
095407da5
|
612 |
for (i = 0; i < ARRAY_SIZE(bmp_logo_palette); ++i) { |
8655b6f86
|
613 |
ushort colreg = bmp_logo_palette[i]; |
39cf48048
|
614 615 616 617 |
#ifdef CONFIG_ATMEL_LCD uint lut_entry; #ifdef CONFIG_ATMEL_LCD_BGR555 lut_entry = ((colreg & 0x000F) << 11) | |
8f47d917c
|
618 619 |
((colreg & 0x00F0) << 2) | ((colreg & 0x0F00) >> 7); |
39cf48048
|
620 621 |
#else /* CONFIG_ATMEL_LCD_RGB565 */ lut_entry = ((colreg & 0x000F) << 1) | |
8f47d917c
|
622 623 |
((colreg & 0x00F0) << 3) | ((colreg & 0x0F00) << 4); |
39cf48048
|
624 625 626 627 |
#endif *(cmap + BMP_LOGO_OFFSET) = lut_entry; cmap++; #else /* !CONFIG_ATMEL_LCD */ |
6d0f6bcf3
|
628 |
#ifdef CONFIG_SYS_INVERT_COLORS |
8655b6f86
|
629 630 631 632 |
*cmap++ = 0xffff - colreg; #else *cmap++ = colreg; #endif |
39cf48048
|
633 |
#endif /* CONFIG_ATMEL_LCD */ |
8655b6f86
|
634 635 636 |
} WATCHDOG_RESET(); |
8f47d917c
|
637 638 |
for (i = 0; i < BMP_LOGO_HEIGHT; ++i) { memcpy(fb, bmap, BMP_LOGO_WIDTH); |
8655b6f86
|
639 |
bmap += BMP_LOGO_WIDTH; |
6b035141f
|
640 |
fb += panel_info.vl_col; |
8655b6f86
|
641 642 643 |
} } else { /* true color mode */ |
acb138689
|
644 |
u16 col16; |
317461c1d
|
645 |
fb16 = (ushort *)fb; |
8f47d917c
|
646 647 |
for (i = 0; i < BMP_LOGO_HEIGHT; ++i) { for (j = 0; j < BMP_LOGO_WIDTH; j++) { |
acb138689
|
648 649 650 651 652 |
col16 = bmp_logo_palette[(bmap[j]-16)]; fb16[j] = ((col16 & 0x000F) << 1) | ((col16 & 0x00F0) << 3) | ((col16 & 0x0F00) << 4); |
8655b6f86
|
653 654 655 656 657 658 659 |
} bmap += BMP_LOGO_WIDTH; fb16 += panel_info.vl_col; } } WATCHDOG_RESET(); |
9a8efc460
|
660 |
lcd_sync(); |
8655b6f86
|
661 |
} |
2b5cb3d33
|
662 663 |
#else static inline void bitmap_plot(int x, int y) {} |
8655b6f86
|
664 665 666 |
#endif /* CONFIG_LCD_LOGO */ /*----------------------------------------------------------------------*/ |
c3517f919
|
667 |
#if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN) |
8655b6f86
|
668 669 670 671 |
/* * Display the BMP file located at address bmp_image. * Only uncompressed. */ |
1ca298ced
|
672 673 674 |
#ifdef CONFIG_SPLASH_SCREEN_ALIGN #define BMP_ALIGN_CENTER 0x7FFF |
7c7e280aa
|
675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 |
static void splash_align_axis(int *axis, unsigned long panel_size, unsigned long picture_size) { unsigned long panel_picture_delta = panel_size - picture_size; unsigned long axis_alignment; if (*axis == BMP_ALIGN_CENTER) axis_alignment = panel_picture_delta / 2; else if (*axis < 0) axis_alignment = panel_picture_delta + *axis + 1; else return; *axis = max(0, axis_alignment); } |
1ca298ced
|
691 |
#endif |
45d7f5251
|
692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 |
#ifdef CONFIG_LCD_BMP_RLE8 #define BMP_RLE8_ESCAPE 0 #define BMP_RLE8_EOL 0 #define BMP_RLE8_EOBMP 1 #define BMP_RLE8_DELTA 2 static void draw_unencoded_bitmap(ushort **fbp, uchar *bmap, ushort *cmap, int cnt) { while (cnt > 0) { *(*fbp)++ = cmap[*bmap++]; cnt--; } } static void draw_encoded_bitmap(ushort **fbp, ushort c, int cnt) { ushort *fb = *fbp; int cnt_8copy = cnt >> 3; cnt -= cnt_8copy << 3; while (cnt_8copy > 0) { *fb++ = c; *fb++ = c; *fb++ = c; *fb++ = c; *fb++ = c; *fb++ = c; *fb++ = c; *fb++ = c; cnt_8copy--; } while (cnt > 0) { *fb++ = c; cnt--; } |
6b035141f
|
730 |
*fbp = fb; |
45d7f5251
|
731 732 733 |
} /* |
6b035141f
|
734 |
* Do not call this function directly, must be called from lcd_display_bitmap. |
45d7f5251
|
735 736 737 738 739 740 741 742 743 |
*/ static void lcd_display_rle8_bitmap(bmp_image_t *bmp, ushort *cmap, uchar *fb, int x_off, int y_off) { uchar *bmap; ulong width, height; ulong cnt, runlen; int x, y; int decode = 1; |
dca2a1c18
|
744 745 746 |
width = get_unaligned_le32(&bmp->header.width); height = get_unaligned_le32(&bmp->header.height); bmap = (uchar *)bmp + get_unaligned_le32(&bmp->header.data_offset); |
45d7f5251
|
747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 |
x = 0; y = height - 1; while (decode) { if (bmap[0] == BMP_RLE8_ESCAPE) { switch (bmap[1]) { case BMP_RLE8_EOL: /* end of line */ bmap += 2; x = 0; y--; /* 16bpix, 2-byte per pixel, width should *2 */ fb -= (width * 2 + lcd_line_length); break; case BMP_RLE8_EOBMP: /* end of bitmap */ decode = 0; break; case BMP_RLE8_DELTA: /* delta run */ x += bmap[2]; y -= bmap[3]; /* 16bpix, 2-byte per pixel, x should *2 */ fb = (uchar *) (lcd_base + (y + y_off - 1) * lcd_line_length + (x + x_off) * 2); bmap += 4; break; default: /* unencoded run */ runlen = bmap[1]; bmap += 2; if (y < height) { if (x < width) { if (x + runlen > width) cnt = width - x; else cnt = runlen; draw_unencoded_bitmap( (ushort **)&fb, bmap, cmap, cnt); } x += runlen; } bmap += runlen; if (runlen & 1) bmap++; } } else { /* encoded run */ if (y < height) { runlen = bmap[0]; if (x < width) { /* aggregate the same code */ while (bmap[0] == 0xff && bmap[2] != BMP_RLE8_ESCAPE && bmap[1] == bmap[3]) { runlen += bmap[2]; bmap += 2; } if (x + runlen > width) cnt = width - x; else cnt = runlen; draw_encoded_bitmap((ushort **)&fb, cmap[bmap[1]], cnt); } x += runlen; } bmap += 2; } } } #endif |
d23019f3d
|
821 |
#if defined(CONFIG_MPC823) || defined(CONFIG_MCC200) |
bfdcc65e1
|
822 |
#define FB_PUT_BYTE(fb, from) *(fb)++ = (255 - *(from)++) |
d23019f3d
|
823 824 |
#else #define FB_PUT_BYTE(fb, from) *(fb)++ = *(from)++ |
bfdcc65e1
|
825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 |
#endif #if defined(CONFIG_BMP_16BPP) #if defined(CONFIG_ATMEL_LCD_BGR555) static inline void fb_put_word(uchar **fb, uchar **from) { *(*fb)++ = (((*from)[0] & 0x1f) << 2) | ((*from)[1] & 0x03); *(*fb)++ = ((*from)[0] & 0xe0) | (((*from)[1] & 0x7c) >> 2); *from += 2; } #else static inline void fb_put_word(uchar **fb, uchar **from) { *(*fb)++ = *(*from)++; *(*fb)++ = *(*from)++; } #endif #endif /* CONFIG_BMP_16BPP */ |
8655b6f86
|
843 844 |
int lcd_display_bitmap(ulong bmp_image, int x, int y) { |
00cc5595a
|
845 846 847 848 |
#if !defined(CONFIG_MCC200) ushort *cmap = NULL; #endif ushort *cmap_base = NULL; |
8655b6f86
|
849 850 851 852 |
ushort i, j; uchar *fb; bmp_image_t *bmp=(bmp_image_t *)bmp_image; uchar *bmap; |
fecac46cf
|
853 |
ushort padded_width; |
b245e65ee
|
854 |
unsigned long width, height, byte_width; |
e8143e72e
|
855 |
unsigned long pwidth = panel_info.vl_col; |
b245e65ee
|
856 |
unsigned colors, bpix, bmp_bpix; |
8655b6f86
|
857 |
|
6b035141f
|
858 859 |
if (!bmp || !(bmp->header.signature[0] == 'B' && bmp->header.signature[1] == 'M')) { |
8f47d917c
|
860 861 |
printf("Error: no valid bmp image at %lx ", bmp_image); |
8655b6f86
|
862 |
return 1; |
b245e65ee
|
863 |
} |
8655b6f86
|
864 |
|
dca2a1c18
|
865 866 867 |
width = get_unaligned_le32(&bmp->header.width); height = get_unaligned_le32(&bmp->header.height); bmp_bpix = get_unaligned_le16(&bmp->header.bit_count); |
b245e65ee
|
868 |
colors = 1 << bmp_bpix; |
8655b6f86
|
869 870 |
bpix = NBITS(panel_info.vl_bpix); |
6b035141f
|
871 |
if (bpix != 1 && bpix != 8 && bpix != 16 && bpix != 32) { |
b245e65ee
|
872 873 874 |
printf ("Error: %d bit/pixel mode, but BMP has %d bit/pixel ", bpix, bmp_bpix); |
8f47d917c
|
875 |
|
8655b6f86
|
876 877 |
return 1; } |
b245e65ee
|
878 |
/* We support displaying 8bpp BMPs on 16bpp LCDs */ |
dad631ccf
|
879 |
if (bpix != bmp_bpix && !(bmp_bpix == 8 && bpix == 16)) { |
8655b6f86
|
880 881 |
printf ("Error: %d bit/pixel mode, but BMP has %d bit/pixel ", |
dca2a1c18
|
882 |
bpix, get_unaligned_le16(&bmp->header.bit_count)); |
8655b6f86
|
883 884 |
return 1; } |
8f47d917c
|
885 886 |
debug("Display-bmp: %d x %d with %d colors ", |
8655b6f86
|
887 |
(int)width, (int)height, (int)colors); |
f64147149
|
888 889 |
#if !defined(CONFIG_MCC200) /* MCC200 LCD doesn't need CMAP, supports 1bpp b&w only */ |
b245e65ee
|
890 |
if (bmp_bpix == 8) { |
203c37b8c
|
891 |
cmap = configuration_get_cmap(); |
b245e65ee
|
892 |
cmap_base = cmap; |
8655b6f86
|
893 |
/* Set color map */ |
8f47d917c
|
894 |
for (i = 0; i < colors; ++i) { |
8655b6f86
|
895 |
bmp_color_table_entry_t cte = bmp->color_table[i]; |
1464eff77
|
896 |
#if !defined(CONFIG_ATMEL_LCD) |
8655b6f86
|
897 898 |
ushort colreg = ( ((cte.red) << 8) & 0xf800) | |
59d80bf18
|
899 900 |
( ((cte.green) << 3) & 0x07e0) | ( ((cte.blue) >> 3) & 0x001f) ; |
6d0f6bcf3
|
901 |
#ifdef CONFIG_SYS_INVERT_COLORS |
25d6712a8
|
902 |
*cmap = 0xffff - colreg; |
8655b6f86
|
903 |
#else |
25d6712a8
|
904 905 |
*cmap = colreg; #endif |
b245e65ee
|
906 |
#if defined(CONFIG_MPC823) |
25d6712a8
|
907 |
cmap--; |
b245e65ee
|
908 909 |
#else cmap++; |
8655b6f86
|
910 |
#endif |
1464eff77
|
911 912 913 |
#else /* CONFIG_ATMEL_LCD */ lcd_setcolreg(i, cte.red, cte.green, cte.blue); #endif |
8655b6f86
|
914 915 |
} } |
f64147149
|
916 |
#endif |
e8143e72e
|
917 918 919 920 921 922 |
/* * BMP format for Monochrome assumes that the state of a * pixel is described on a per Bit basis, not per Byte. * So, in case of Monochrome BMP we should align widths * on a byte boundary and convert them from Bit to Byte * units. |
511d0c72b
|
923 924 |
* Probably, PXA250 and MPC823 process 1bpp BMP images in * their own ways, so make the converting to be MCC200 |
e8143e72e
|
925 926 927 |
* specific. */ #if defined(CONFIG_MCC200) |
8f47d917c
|
928 |
if (bpix == 1) { |
e8143e72e
|
929 930 931 932 933 |
width = ((width + 7) & ~7) >> 3; x = ((x + 7) & ~7) >> 3; pwidth= ((pwidth + 7) & ~7) >> 3; } #endif |
6b035141f
|
934 |
padded_width = (width & 0x3 ? (width & ~0x3) + 4 : width); |
1ca298ced
|
935 936 |
#ifdef CONFIG_SPLASH_SCREEN_ALIGN |
7c7e280aa
|
937 938 |
splash_align_axis(&x, pwidth, width); splash_align_axis(&y, panel_info.vl_row, height); |
1ca298ced
|
939 |
#endif /* CONFIG_SPLASH_SCREEN_ALIGN */ |
8f47d917c
|
940 |
if ((x + width) > pwidth) |
e8143e72e
|
941 |
width = pwidth - x; |
8f47d917c
|
942 |
if ((y + height) > panel_info.vl_row) |
8655b6f86
|
943 |
height = panel_info.vl_row - y; |
dca2a1c18
|
944 945 |
bmap = (uchar *)bmp + get_unaligned_le32(&bmp->header.data_offset); fb = (uchar *)(lcd_base + |
8d46d5b18
|
946 |
(y + height - 1) * lcd_line_length + x * bpix / 8); |
a303dfb0e
|
947 |
|
b245e65ee
|
948 |
switch (bmp_bpix) { |
a303dfb0e
|
949 950 |
case 1: /* pass through */ case 8: |
45d7f5251
|
951 |
#ifdef CONFIG_LCD_BMP_RLE8 |
dca2a1c18
|
952 953 |
u32 compression = get_unaligned_le32(&bmp->header.compression); if (compression == BMP_BI_RLE8) { |
45d7f5251
|
954 955 956 957 958 959 960 961 962 |
if (bpix != 16) { /* TODO implement render code for bpix != 16 */ printf("Error: only support 16 bpix"); return 1; } lcd_display_rle8_bitmap(bmp, cmap_base, fb, x, y); break; } #endif |
b245e65ee
|
963 964 965 966 |
if (bpix != 16) byte_width = width; else byte_width = width * 2; |
a303dfb0e
|
967 968 |
for (i = 0; i < height; ++i) { WATCHDOG_RESET(); |
b245e65ee
|
969 970 |
for (j = 0; j < width; j++) { if (bpix != 16) { |
bfdcc65e1
|
971 |
FB_PUT_BYTE(fb, bmap); |
b245e65ee
|
972 973 974 975 976 |
} else { *(uint16_t *)fb = cmap_base[*(bmap++)]; fb += sizeof(uint16_t) / sizeof(*fb); } } |
fecac46cf
|
977 |
bmap += (padded_width - width); |
6b035141f
|
978 |
fb -= byte_width + lcd_line_length; |
a303dfb0e
|
979 980 981 982 983 984 985 |
} break; #if defined(CONFIG_BMP_16BPP) case 16: for (i = 0; i < height; ++i) { WATCHDOG_RESET(); |
bfdcc65e1
|
986 987 |
for (j = 0; j < width; j++) fb_put_word(&fb, &bmap); |
fecac46cf
|
988 |
bmap += (padded_width - width) * 2; |
6b035141f
|
989 |
fb -= width * 2 + lcd_line_length; |
a303dfb0e
|
990 991 992 |
} break; #endif /* CONFIG_BMP_16BPP */ |
fb6a9aab7
|
993 994 995 996 997 998 999 1000 1001 |
#if defined(CONFIG_BMP_32BPP) case 32: for (i = 0; i < height; ++i) { for (j = 0; j < width; j++) { *(fb++) = *(bmap++); *(fb++) = *(bmap++); *(fb++) = *(bmap++); *(fb++) = *(bmap++); } |
6b035141f
|
1002 |
fb -= lcd_line_length + width * (bpix / 8); |
fb6a9aab7
|
1003 1004 1005 |
} break; #endif /* CONFIG_BMP_32BPP */ |
a303dfb0e
|
1006 1007 1008 |
default: break; }; |
8655b6f86
|
1009 |
|
9a8efc460
|
1010 |
lcd_sync(); |
8f47d917c
|
1011 |
return 0; |
8655b6f86
|
1012 |
} |
c3517f919
|
1013 |
#endif |
8655b6f86
|
1014 |
|
8f47d917c
|
1015 |
static void *lcd_logo(void) |
8655b6f86
|
1016 |
{ |
8655b6f86
|
1017 1018 1019 1020 1021 1022 |
#ifdef CONFIG_SPLASH_SCREEN char *s; ulong addr; static int do_splash = 1; if (do_splash && (s = getenv("splashimage")) != NULL) { |
1ca298ced
|
1023 |
int x = 0, y = 0; |
8655b6f86
|
1024 |
do_splash = 0; |
581bb4198
|
1025 |
if (splash_screen_prepare()) |
dd4425e85
|
1026 |
return (void *)lcd_base; |
581bb4198
|
1027 |
|
1ca298ced
|
1028 |
addr = simple_strtoul (s, NULL, 16); |
ff8fb56b6
|
1029 1030 |
splash_get_pos(&x, &y); |
1ca298ced
|
1031 |
|
d3a555edd
|
1032 |
if (bmp_display(addr, x, y) == 0) |
8f47d917c
|
1033 |
return (void *)lcd_base; |
8655b6f86
|
1034 1035 |
} #endif /* CONFIG_SPLASH_SCREEN */ |
2b5cb3d33
|
1036 |
bitmap_plot(0, 0); |
8655b6f86
|
1037 |
|
6b59e03e0
|
1038 1039 1040 1041 1042 |
#ifdef CONFIG_LCD_INFO console_col = LCD_INFO_X / VIDEO_FONT_WIDTH; console_row = LCD_INFO_Y / VIDEO_FONT_HEIGHT; lcd_show_board_info(); #endif /* CONFIG_LCD_INFO */ |
39cf48048
|
1043 |
|
88804d19e
|
1044 |
#if defined(CONFIG_LCD_LOGO) && !defined(CONFIG_LCD_INFO_BELOW_LOGO) |
8f47d917c
|
1045 |
return (void *)((ulong)lcd_base + BMP_LOGO_HEIGHT * lcd_line_length); |
8655b6f86
|
1046 |
#else |
8f47d917c
|
1047 |
return (void *)lcd_base; |
6b035141f
|
1048 |
#endif /* CONFIG_LCD_LOGO && !defined(CONFIG_LCD_INFO_BELOW_LOGO) */ |
8655b6f86
|
1049 |
} |
c08804853
|
1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 |
#ifdef CONFIG_SPLASHIMAGE_GUARD static int on_splashimage(const char *name, const char *value, enum env_op op, int flags) { ulong addr; int aligned; if (op == env_op_delete) return 0; addr = simple_strtoul(value, NULL, 16); /* See README.displaying-bmps */ aligned = (addr % 4 == 2); if (!aligned) { printf("Invalid splashimage value. Value must be 16 bit aligned, but not 32 bit aligned "); return -1; } return 0; } U_BOOT_ENV_CALLBACK(splashimage, on_splashimage); #endif |
395166cff
|
1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 |
void lcd_position_cursor(unsigned col, unsigned row) { console_col = min(col, CONSOLE_COLS - 1); console_row = min(row, CONSOLE_ROWS - 1); } int lcd_get_pixel_width(void) { return panel_info.vl_col; } int lcd_get_pixel_height(void) { return panel_info.vl_row; } int lcd_get_screen_rows(void) { return CONSOLE_ROWS; } int lcd_get_screen_columns(void) { return CONSOLE_COLS; } |
6a195d2d8
|
1099 1100 1101 1102 1103 1104 1105 |
#if defined(CONFIG_LCD_DT_SIMPLEFB) static int lcd_dt_simplefb_configure_node(void *blob, int off) { u32 stride; fdt32_t cells[2]; int ret; |
5af7d0f09
|
1106 |
static const char format[] = |
6a195d2d8
|
1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 |
#if LCD_BPP == LCD_COLOR16 "r5g6b5"; #else ""; #endif if (!format[0]) return -1; stride = panel_info.vl_col * 2; cells[0] = cpu_to_fdt32(gd->fb_base); cells[1] = cpu_to_fdt32(stride * panel_info.vl_row); ret = fdt_setprop(blob, off, "reg", cells, sizeof(cells[0]) * 2); if (ret < 0) return -1; cells[0] = cpu_to_fdt32(panel_info.vl_col); ret = fdt_setprop(blob, off, "width", cells, sizeof(cells[0])); if (ret < 0) return -1; cells[0] = cpu_to_fdt32(panel_info.vl_row); ret = fdt_setprop(blob, off, "height", cells, sizeof(cells[0])); if (ret < 0) return -1; cells[0] = cpu_to_fdt32(stride); ret = fdt_setprop(blob, off, "stride", cells, sizeof(cells[0])); if (ret < 0) return -1; ret = fdt_setprop(blob, off, "format", format, strlen(format) + 1); if (ret < 0) return -1; ret = fdt_delprop(blob, off, "status"); if (ret < 0) return -1; return 0; } int lcd_dt_simplefb_add_node(void *blob) { |
5af7d0f09
|
1152 1153 |
static const char compat[] = "simple-framebuffer"; static const char disabled[] = "disabled"; |
6a195d2d8
|
1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 |
int off, ret; off = fdt_add_subnode(blob, 0, "framebuffer"); if (off < 0) return -1; ret = fdt_setprop(blob, off, "status", disabled, sizeof(disabled)); if (ret < 0) return -1; ret = fdt_setprop(blob, off, "compatible", compat, sizeof(compat)); if (ret < 0) return -1; return lcd_dt_simplefb_configure_node(blob, off); } int lcd_dt_simplefb_enable_existing_node(void *blob) { int off; off = fdt_node_offset_by_compatible(blob, -1, "simple-framebuffer"); if (off < 0) return -1; return lcd_dt_simplefb_configure_node(blob, off); } #endif |